Don't leak file descriptors
[qemu.git] / qemu-sockets.c
1 /*
2 * inet and unix socket functions for qemu
3 *
4 * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; under version 2 of the License.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <ctype.h>
19 #include <errno.h>
20 #include <unistd.h>
21
22 #include "qemu_socket.h"
23 #include "qemu-common.h" /* for qemu_isdigit */
24
25 #ifndef AI_ADDRCONFIG
26 # define AI_ADDRCONFIG 0
27 #endif
28
29 static int sockets_debug = 0;
30 static const int on=1, off=0;
31
32 /* used temporarely until all users are converted to QemuOpts */
33 static QemuOptsList dummy_opts = {
34 .name = "dummy",
35 .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
36 .desc = {
37 {
38 .name = "path",
39 .type = QEMU_OPT_STRING,
40 },{
41 .name = "host",
42 .type = QEMU_OPT_STRING,
43 },{
44 .name = "port",
45 .type = QEMU_OPT_STRING,
46 },{
47 .name = "to",
48 .type = QEMU_OPT_NUMBER,
49 },{
50 .name = "ipv4",
51 .type = QEMU_OPT_BOOL,
52 },{
53 .name = "ipv6",
54 .type = QEMU_OPT_BOOL,
55 },
56 { /* end if list */ }
57 },
58 };
59
60 static int inet_getport(struct addrinfo *e)
61 {
62 struct sockaddr_in *i4;
63 struct sockaddr_in6 *i6;
64
65 switch (e->ai_family) {
66 case PF_INET6:
67 i6 = (void*)e->ai_addr;
68 return ntohs(i6->sin6_port);
69 case PF_INET:
70 i4 = (void*)e->ai_addr;
71 return ntohs(i4->sin_port);
72 default:
73 return 0;
74 }
75 }
76
77 static void inet_setport(struct addrinfo *e, int port)
78 {
79 struct sockaddr_in *i4;
80 struct sockaddr_in6 *i6;
81
82 switch (e->ai_family) {
83 case PF_INET6:
84 i6 = (void*)e->ai_addr;
85 i6->sin6_port = htons(port);
86 break;
87 case PF_INET:
88 i4 = (void*)e->ai_addr;
89 i4->sin_port = htons(port);
90 break;
91 }
92 }
93
94 static const char *inet_strfamily(int family)
95 {
96 switch (family) {
97 case PF_INET6: return "ipv6";
98 case PF_INET: return "ipv4";
99 case PF_UNIX: return "unix";
100 }
101 return "????";
102 }
103
104 static void inet_print_addrinfo(const char *tag, struct addrinfo *res)
105 {
106 struct addrinfo *e;
107 char uaddr[INET6_ADDRSTRLEN+1];
108 char uport[33];
109
110 for (e = res; e != NULL; e = e->ai_next) {
111 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
112 uaddr,INET6_ADDRSTRLEN,uport,32,
113 NI_NUMERICHOST | NI_NUMERICSERV);
114 fprintf(stderr,"%s: getaddrinfo: family %s, host %s, port %s\n",
115 tag, inet_strfamily(e->ai_family), uaddr, uport);
116 }
117 }
118
119 int inet_listen_opts(QemuOpts *opts, int port_offset)
120 {
121 struct addrinfo ai,*res,*e;
122 const char *addr;
123 char port[33];
124 char uaddr[INET6_ADDRSTRLEN+1];
125 char uport[33];
126 int slisten,rc,to,try_next;
127
128 memset(&ai,0, sizeof(ai));
129 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
130 ai.ai_family = PF_UNSPEC;
131 ai.ai_socktype = SOCK_STREAM;
132
133 if (qemu_opt_get(opts, "port") == NULL) {
134 fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__);
135 return -1;
136 }
137 pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
138 addr = qemu_opt_get(opts, "host");
139
140 to = qemu_opt_get_number(opts, "to", 0);
141 if (qemu_opt_get_bool(opts, "ipv4", 0))
142 ai.ai_family = PF_INET;
143 if (qemu_opt_get_bool(opts, "ipv6", 0))
144 ai.ai_family = PF_INET6;
145
146 /* lookup */
147 if (port_offset)
148 snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
149 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
150 if (rc != 0) {
151 fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
152 gai_strerror(rc));
153 return -1;
154 }
155 if (sockets_debug)
156 inet_print_addrinfo(__FUNCTION__, res);
157
158 /* create socket + bind */
159 for (e = res; e != NULL; e = e->ai_next) {
160 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
161 uaddr,INET6_ADDRSTRLEN,uport,32,
162 NI_NUMERICHOST | NI_NUMERICSERV);
163 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
164 if (slisten < 0) {
165 fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
166 inet_strfamily(e->ai_family), strerror(errno));
167 continue;
168 }
169
170 setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
171 #ifdef IPV6_V6ONLY
172 if (e->ai_family == PF_INET6) {
173 /* listen on both ipv4 and ipv6 */
174 setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
175 sizeof(off));
176 }
177 #endif
178
179 for (;;) {
180 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
181 if (sockets_debug)
182 fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
183 inet_strfamily(e->ai_family), uaddr, inet_getport(e));
184 goto listen;
185 }
186 try_next = to && (inet_getport(e) <= to + port_offset);
187 if (!try_next || sockets_debug)
188 fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__,
189 inet_strfamily(e->ai_family), uaddr, inet_getport(e),
190 strerror(errno));
191 if (try_next) {
192 inet_setport(e, inet_getport(e) + 1);
193 continue;
194 }
195 break;
196 }
197 closesocket(slisten);
198 }
199 fprintf(stderr, "%s: FAILED\n", __FUNCTION__);
200 freeaddrinfo(res);
201 return -1;
202
203 listen:
204 if (listen(slisten,1) != 0) {
205 perror("listen");
206 closesocket(slisten);
207 freeaddrinfo(res);
208 return -1;
209 }
210 snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
211 qemu_opt_set(opts, "host", uaddr);
212 qemu_opt_set(opts, "port", uport);
213 qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
214 qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
215 freeaddrinfo(res);
216 return slisten;
217 }
218
219 int inet_connect_opts(QemuOpts *opts)
220 {
221 struct addrinfo ai,*res,*e;
222 const char *addr;
223 const char *port;
224 char uaddr[INET6_ADDRSTRLEN+1];
225 char uport[33];
226 int sock,rc;
227
228 memset(&ai,0, sizeof(ai));
229 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
230 ai.ai_family = PF_UNSPEC;
231 ai.ai_socktype = SOCK_STREAM;
232
233 addr = qemu_opt_get(opts, "host");
234 port = qemu_opt_get(opts, "port");
235 if (addr == NULL || port == NULL) {
236 fprintf(stderr, "inet_connect: host and/or port not specified\n");
237 return -1;
238 }
239
240 if (qemu_opt_get_bool(opts, "ipv4", 0))
241 ai.ai_family = PF_INET;
242 if (qemu_opt_get_bool(opts, "ipv6", 0))
243 ai.ai_family = PF_INET6;
244
245 /* lookup */
246 if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) {
247 fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
248 gai_strerror(rc));
249 return -1;
250 }
251 if (sockets_debug)
252 inet_print_addrinfo(__FUNCTION__, res);
253
254 for (e = res; e != NULL; e = e->ai_next) {
255 if (getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
256 uaddr,INET6_ADDRSTRLEN,uport,32,
257 NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
258 fprintf(stderr,"%s: getnameinfo: oops\n", __FUNCTION__);
259 continue;
260 }
261 sock = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
262 if (sock < 0) {
263 fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
264 inet_strfamily(e->ai_family), strerror(errno));
265 continue;
266 }
267 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
268
269 /* connect to peer */
270 if (connect(sock,e->ai_addr,e->ai_addrlen) < 0) {
271 if (sockets_debug || NULL == e->ai_next)
272 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
273 inet_strfamily(e->ai_family),
274 e->ai_canonname, uaddr, uport, strerror(errno));
275 closesocket(sock);
276 continue;
277 }
278 if (sockets_debug)
279 fprintf(stderr, "%s: connect(%s,%s,%s,%s): OK\n", __FUNCTION__,
280 inet_strfamily(e->ai_family),
281 e->ai_canonname, uaddr, uport);
282 freeaddrinfo(res);
283 return sock;
284 }
285 freeaddrinfo(res);
286 return -1;
287 }
288
289 int inet_dgram_opts(QemuOpts *opts)
290 {
291 struct addrinfo ai, *peer = NULL, *local = NULL;
292 const char *addr;
293 const char *port;
294 char uaddr[INET6_ADDRSTRLEN+1];
295 char uport[33];
296 int sock = -1, rc;
297
298 /* lookup peer addr */
299 memset(&ai,0, sizeof(ai));
300 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
301 ai.ai_family = PF_UNSPEC;
302 ai.ai_socktype = SOCK_DGRAM;
303
304 addr = qemu_opt_get(opts, "host");
305 port = qemu_opt_get(opts, "port");
306 if (addr == NULL || strlen(addr) == 0) {
307 addr = "localhost";
308 }
309 if (port == NULL || strlen(port) == 0) {
310 fprintf(stderr, "inet_dgram: port not specified\n");
311 return -1;
312 }
313
314 if (qemu_opt_get_bool(opts, "ipv4", 0))
315 ai.ai_family = PF_INET;
316 if (qemu_opt_get_bool(opts, "ipv6", 0))
317 ai.ai_family = PF_INET6;
318
319 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
320 fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
321 gai_strerror(rc));
322 return -1;
323 }
324 if (sockets_debug) {
325 fprintf(stderr, "%s: peer (%s:%s)\n", __FUNCTION__, addr, port);
326 inet_print_addrinfo(__FUNCTION__, peer);
327 }
328
329 /* lookup local addr */
330 memset(&ai,0, sizeof(ai));
331 ai.ai_flags = AI_PASSIVE;
332 ai.ai_family = peer->ai_family;
333 ai.ai_socktype = SOCK_DGRAM;
334
335 addr = qemu_opt_get(opts, "localaddr");
336 port = qemu_opt_get(opts, "localport");
337 if (addr == NULL || strlen(addr) == 0) {
338 addr = NULL;
339 }
340 if (!port || strlen(port) == 0)
341 port = "0";
342
343 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
344 fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
345 gai_strerror(rc));
346 return -1;
347 }
348 if (sockets_debug) {
349 fprintf(stderr, "%s: local (%s:%s)\n", __FUNCTION__, addr, port);
350 inet_print_addrinfo(__FUNCTION__, local);
351 }
352
353 /* create socket */
354 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
355 if (sock < 0) {
356 fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
357 inet_strfamily(peer->ai_family), strerror(errno));
358 goto err;
359 }
360 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
361
362 /* bind socket */
363 if (getnameinfo((struct sockaddr*)local->ai_addr,local->ai_addrlen,
364 uaddr,INET6_ADDRSTRLEN,uport,32,
365 NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
366 fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
367 goto err;
368 }
369 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
370 fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
371 inet_strfamily(local->ai_family), uaddr, inet_getport(local));
372 goto err;
373 }
374
375 /* connect to peer */
376 if (getnameinfo((struct sockaddr*)peer->ai_addr, peer->ai_addrlen,
377 uaddr, INET6_ADDRSTRLEN, uport, 32,
378 NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
379 fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
380 goto err;
381 }
382 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
383 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
384 inet_strfamily(peer->ai_family),
385 peer->ai_canonname, uaddr, uport, strerror(errno));
386 goto err;
387 }
388
389 freeaddrinfo(local);
390 freeaddrinfo(peer);
391 return sock;
392
393 err:
394 if (-1 != sock)
395 closesocket(sock);
396 if (local)
397 freeaddrinfo(local);
398 if (peer)
399 freeaddrinfo(peer);
400 return -1;
401 }
402
403 /* compatibility wrapper */
404 static int inet_parse(QemuOpts *opts, const char *str)
405 {
406 const char *optstr, *h;
407 char addr[64];
408 char port[33];
409 int pos;
410
411 /* parse address */
412 if (str[0] == ':') {
413 /* no host given */
414 addr[0] = '\0';
415 if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
416 fprintf(stderr, "%s: portonly parse error (%s)\n",
417 __FUNCTION__, str);
418 return -1;
419 }
420 } else if (str[0] == '[') {
421 /* IPv6 addr */
422 if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
423 fprintf(stderr, "%s: ipv6 parse error (%s)\n",
424 __FUNCTION__, str);
425 return -1;
426 }
427 qemu_opt_set(opts, "ipv6", "yes");
428 } else if (qemu_isdigit(str[0])) {
429 /* IPv4 addr */
430 if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
431 fprintf(stderr, "%s: ipv4 parse error (%s)\n",
432 __FUNCTION__, str);
433 return -1;
434 }
435 qemu_opt_set(opts, "ipv4", "yes");
436 } else {
437 /* hostname */
438 if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
439 fprintf(stderr, "%s: hostname parse error (%s)\n",
440 __FUNCTION__, str);
441 return -1;
442 }
443 }
444 qemu_opt_set(opts, "host", addr);
445 qemu_opt_set(opts, "port", port);
446
447 /* parse options */
448 optstr = str + pos;
449 h = strstr(optstr, ",to=");
450 if (h)
451 qemu_opt_set(opts, "to", h+4);
452 if (strstr(optstr, ",ipv4"))
453 qemu_opt_set(opts, "ipv4", "yes");
454 if (strstr(optstr, ",ipv6"))
455 qemu_opt_set(opts, "ipv6", "yes");
456 return 0;
457 }
458
459 int inet_listen(const char *str, char *ostr, int olen,
460 int socktype, int port_offset)
461 {
462 QemuOpts *opts;
463 char *optstr;
464 int sock = -1;
465
466 opts = qemu_opts_create(&dummy_opts, NULL, 0);
467 if (inet_parse(opts, str) == 0) {
468 sock = inet_listen_opts(opts, port_offset);
469 if (sock != -1 && ostr) {
470 optstr = strchr(str, ',');
471 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
472 snprintf(ostr, olen, "[%s]:%s%s",
473 qemu_opt_get(opts, "host"),
474 qemu_opt_get(opts, "port"),
475 optstr ? optstr : "");
476 } else {
477 snprintf(ostr, olen, "%s:%s%s",
478 qemu_opt_get(opts, "host"),
479 qemu_opt_get(opts, "port"),
480 optstr ? optstr : "");
481 }
482 }
483 }
484 qemu_opts_del(opts);
485 return sock;
486 }
487
488 int inet_connect(const char *str, int socktype)
489 {
490 QemuOpts *opts;
491 int sock = -1;
492
493 opts = qemu_opts_create(&dummy_opts, NULL, 0);
494 if (inet_parse(opts, str) == 0)
495 sock = inet_connect_opts(opts);
496 qemu_opts_del(opts);
497 return sock;
498 }
499
500 #ifndef _WIN32
501
502 int unix_listen_opts(QemuOpts *opts)
503 {
504 struct sockaddr_un un;
505 const char *path = qemu_opt_get(opts, "path");
506 int sock, fd;
507
508 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
509 if (sock < 0) {
510 perror("socket(unix)");
511 return -1;
512 }
513
514 memset(&un, 0, sizeof(un));
515 un.sun_family = AF_UNIX;
516 if (path && strlen(path)) {
517 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
518 } else {
519 char *tmpdir = getenv("TMPDIR");
520 snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
521 tmpdir ? tmpdir : "/tmp");
522 /*
523 * This dummy fd usage silences the mktemp() unsecure warning.
524 * Using mkstemp() doesn't make things more secure here
525 * though. bind() complains about existing files, so we have
526 * to unlink first and thus re-open the race window. The
527 * worst case possible is bind() failing, i.e. a DoS attack.
528 */
529 fd = mkstemp(un.sun_path); close(fd);
530 qemu_opt_set(opts, "path", un.sun_path);
531 }
532
533 unlink(un.sun_path);
534 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
535 fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno));
536 goto err;
537 }
538 if (listen(sock, 1) < 0) {
539 fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno));
540 goto err;
541 }
542
543 if (sockets_debug)
544 fprintf(stderr, "bind(unix:%s): OK\n", un.sun_path);
545 return sock;
546
547 err:
548 closesocket(sock);
549 return -1;
550 }
551
552 int unix_connect_opts(QemuOpts *opts)
553 {
554 struct sockaddr_un un;
555 const char *path = qemu_opt_get(opts, "path");
556 int sock;
557
558 if (NULL == path) {
559 fprintf(stderr, "unix connect: no path specified\n");
560 return -1;
561 }
562
563 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
564 if (sock < 0) {
565 perror("socket(unix)");
566 return -1;
567 }
568
569 memset(&un, 0, sizeof(un));
570 un.sun_family = AF_UNIX;
571 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
572 if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
573 fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno));
574 return -1;
575 }
576
577 if (sockets_debug)
578 fprintf(stderr, "connect(unix:%s): OK\n", path);
579 return sock;
580 }
581
582 /* compatibility wrapper */
583 int unix_listen(const char *str, char *ostr, int olen)
584 {
585 QemuOpts *opts;
586 char *path, *optstr;
587 int sock, len;
588
589 opts = qemu_opts_create(&dummy_opts, NULL, 0);
590
591 optstr = strchr(str, ',');
592 if (optstr) {
593 len = optstr - str;
594 if (len) {
595 path = qemu_malloc(len+1);
596 snprintf(path, len+1, "%.*s", len, str);
597 qemu_opt_set(opts, "path", path);
598 qemu_free(path);
599 }
600 } else {
601 qemu_opt_set(opts, "path", str);
602 }
603
604 sock = unix_listen_opts(opts);
605
606 if (sock != -1 && ostr)
607 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
608 qemu_opts_del(opts);
609 return sock;
610 }
611
612 int unix_connect(const char *path)
613 {
614 QemuOpts *opts;
615 int sock;
616
617 opts = qemu_opts_create(&dummy_opts, NULL, 0);
618 qemu_opt_set(opts, "path", path);
619 sock = unix_connect_opts(opts);
620 qemu_opts_del(opts);
621 return sock;
622 }
623
624 #else
625
626 int unix_listen_opts(QemuOpts *opts)
627 {
628 fprintf(stderr, "unix sockets are not available on windows\n");
629 return -1;
630 }
631
632 int unix_connect_opts(QemuOpts *opts)
633 {
634 fprintf(stderr, "unix sockets are not available on windows\n");
635 return -1;
636 }
637
638 int unix_listen(const char *path, char *ostr, int olen)
639 {
640 fprintf(stderr, "unix sockets are not available on windows\n");
641 return -1;
642 }
643
644 int unix_connect(const char *path)
645 {
646 fprintf(stderr, "unix sockets are not available on windows\n");
647 return -1;
648 }
649
650 #endif