]> git.proxmox.com Git - mirror_qemu.git/blob - qemu-sockets.c
078f7c17c315c677e7543ab728c49a6725b15e28
[mirror_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 * Contributions after 2012-01-13 are licensed under the terms of the
16 * GNU GPL, version 2 or (at your option) any later version.
17 */
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <unistd.h>
24
25 #include "qemu_socket.h"
26 #include "qemu-common.h" /* for qemu_isdigit */
27 #include "main-loop.h"
28
29 #ifndef AI_ADDRCONFIG
30 # define AI_ADDRCONFIG 0
31 #endif
32
33 static const int on=1, off=0;
34
35 /* used temporarely until all users are converted to QemuOpts */
36 static QemuOptsList dummy_opts = {
37 .name = "dummy",
38 .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
39 .desc = {
40 {
41 .name = "path",
42 .type = QEMU_OPT_STRING,
43 },{
44 .name = "host",
45 .type = QEMU_OPT_STRING,
46 },{
47 .name = "port",
48 .type = QEMU_OPT_STRING,
49 },{
50 .name = "to",
51 .type = QEMU_OPT_NUMBER,
52 },{
53 .name = "ipv4",
54 .type = QEMU_OPT_BOOL,
55 },{
56 .name = "ipv6",
57 .type = QEMU_OPT_BOOL,
58 },
59 { /* end if list */ }
60 },
61 };
62
63 static int inet_getport(struct addrinfo *e)
64 {
65 struct sockaddr_in *i4;
66 struct sockaddr_in6 *i6;
67
68 switch (e->ai_family) {
69 case PF_INET6:
70 i6 = (void*)e->ai_addr;
71 return ntohs(i6->sin6_port);
72 case PF_INET:
73 i4 = (void*)e->ai_addr;
74 return ntohs(i4->sin_port);
75 default:
76 return 0;
77 }
78 }
79
80 static void inet_setport(struct addrinfo *e, int port)
81 {
82 struct sockaddr_in *i4;
83 struct sockaddr_in6 *i6;
84
85 switch (e->ai_family) {
86 case PF_INET6:
87 i6 = (void*)e->ai_addr;
88 i6->sin6_port = htons(port);
89 break;
90 case PF_INET:
91 i4 = (void*)e->ai_addr;
92 i4->sin_port = htons(port);
93 break;
94 }
95 }
96
97 const char *inet_strfamily(int family)
98 {
99 switch (family) {
100 case PF_INET6: return "ipv6";
101 case PF_INET: return "ipv4";
102 case PF_UNIX: return "unix";
103 }
104 return "unknown";
105 }
106
107 int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
108 {
109 struct addrinfo ai,*res,*e;
110 const char *addr;
111 char port[33];
112 char uaddr[INET6_ADDRSTRLEN+1];
113 char uport[33];
114 int slisten, rc, to, port_min, port_max, p;
115
116 memset(&ai,0, sizeof(ai));
117 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
118 ai.ai_family = PF_UNSPEC;
119 ai.ai_socktype = SOCK_STREAM;
120
121 if ((qemu_opt_get(opts, "host") == NULL) ||
122 (qemu_opt_get(opts, "port") == NULL)) {
123 error_setg(errp, "host and/or port not specified");
124 return -1;
125 }
126 pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
127 addr = qemu_opt_get(opts, "host");
128
129 to = qemu_opt_get_number(opts, "to", 0);
130 if (qemu_opt_get_bool(opts, "ipv4", 0))
131 ai.ai_family = PF_INET;
132 if (qemu_opt_get_bool(opts, "ipv6", 0))
133 ai.ai_family = PF_INET6;
134
135 /* lookup */
136 if (port_offset)
137 snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
138 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
139 if (rc != 0) {
140 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
141 gai_strerror(rc));
142 return -1;
143 }
144
145 /* create socket + bind */
146 for (e = res; e != NULL; e = e->ai_next) {
147 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
148 uaddr,INET6_ADDRSTRLEN,uport,32,
149 NI_NUMERICHOST | NI_NUMERICSERV);
150 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
151 if (slisten < 0) {
152 if (!e->ai_next) {
153 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
154 }
155 continue;
156 }
157
158 setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
159 #ifdef IPV6_V6ONLY
160 if (e->ai_family == PF_INET6) {
161 /* listen on both ipv4 and ipv6 */
162 setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
163 sizeof(off));
164 }
165 #endif
166
167 port_min = inet_getport(e);
168 port_max = to ? to + port_offset : port_min;
169 for (p = port_min; p <= port_max; p++) {
170 inet_setport(e, p);
171 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
172 goto listen;
173 }
174 if (p == port_max) {
175 if (!e->ai_next) {
176 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
177 }
178 }
179 }
180 closesocket(slisten);
181 }
182 freeaddrinfo(res);
183 return -1;
184
185 listen:
186 if (listen(slisten,1) != 0) {
187 error_set_errno(errp, errno, QERR_SOCKET_LISTEN_FAILED);
188 closesocket(slisten);
189 freeaddrinfo(res);
190 return -1;
191 }
192 snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
193 qemu_opt_set(opts, "host", uaddr);
194 qemu_opt_set(opts, "port", uport);
195 qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
196 qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
197 freeaddrinfo(res);
198 return slisten;
199 }
200
201 #ifdef _WIN32
202 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
203 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
204 #else
205 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
206 ((rc) == -EINPROGRESS)
207 #endif
208
209 /* Struct to store connect state for non blocking connect */
210 typedef struct ConnectState {
211 int fd;
212 struct addrinfo *addr_list;
213 struct addrinfo *current_addr;
214 NonBlockingConnectHandler *callback;
215 void *opaque;
216 } ConnectState;
217
218 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
219 ConnectState *connect_state, Error **errp);
220
221 static void wait_for_connect(void *opaque)
222 {
223 ConnectState *s = opaque;
224 int val = 0, rc = 0;
225 socklen_t valsize = sizeof(val);
226 bool in_progress;
227
228 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
229
230 do {
231 rc = getsockopt(s->fd, SOL_SOCKET, SO_ERROR, (void *) &val, &valsize);
232 } while (rc == -1 && socket_error() == EINTR);
233
234 /* update rc to contain error */
235 if (!rc && val) {
236 rc = -1;
237 }
238
239 /* connect error */
240 if (rc < 0) {
241 closesocket(s->fd);
242 s->fd = rc;
243 }
244
245 /* try to connect to the next address on the list */
246 if (s->current_addr) {
247 while (s->current_addr->ai_next != NULL && s->fd < 0) {
248 s->current_addr = s->current_addr->ai_next;
249 s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
250 /* connect in progress */
251 if (in_progress) {
252 return;
253 }
254 }
255
256 freeaddrinfo(s->addr_list);
257 }
258
259 if (s->callback) {
260 s->callback(s->fd, s->opaque);
261 }
262 g_free(s);
263 }
264
265 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
266 ConnectState *connect_state, Error **errp)
267 {
268 int sock, rc;
269
270 *in_progress = false;
271
272 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
273 if (sock < 0) {
274 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
275 return -1;
276 }
277 qemu_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
278 if (connect_state != NULL) {
279 socket_set_nonblock(sock);
280 }
281 /* connect to peer */
282 do {
283 rc = 0;
284 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
285 rc = -socket_error();
286 }
287 } while (rc == -EINTR);
288
289 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
290 connect_state->fd = sock;
291 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
292 connect_state);
293 *in_progress = true;
294 } else if (rc < 0) {
295 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED);
296 closesocket(sock);
297 return -1;
298 }
299 return sock;
300 }
301
302 static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
303 {
304 struct addrinfo ai, *res;
305 int rc;
306 const char *addr;
307 const char *port;
308
309 memset(&ai, 0, sizeof(ai));
310
311 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
312 ai.ai_family = PF_UNSPEC;
313 ai.ai_socktype = SOCK_STREAM;
314
315 addr = qemu_opt_get(opts, "host");
316 port = qemu_opt_get(opts, "port");
317 if (addr == NULL || port == NULL) {
318 error_setg(errp, "host and/or port not specified");
319 return NULL;
320 }
321
322 if (qemu_opt_get_bool(opts, "ipv4", 0)) {
323 ai.ai_family = PF_INET;
324 }
325 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
326 ai.ai_family = PF_INET6;
327 }
328
329 /* lookup */
330 rc = getaddrinfo(addr, port, &ai, &res);
331 if (rc != 0) {
332 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
333 gai_strerror(rc));
334 return NULL;
335 }
336 return res;
337 }
338
339 /**
340 * Create a socket and connect it to an address.
341 *
342 * @opts: QEMU options, recognized parameters strings "host" and "port",
343 * bools "ipv4" and "ipv6".
344 * @errp: set on error
345 * @callback: callback function for non-blocking connect
346 * @opaque: opaque for callback function
347 *
348 * Returns: -1 on error, file descriptor on success.
349 *
350 * If @callback is non-null, the connect is non-blocking. If this
351 * function succeeds, callback will be called when the connection
352 * completes, with the file descriptor on success, or -1 on error.
353 */
354 int inet_connect_opts(QemuOpts *opts, Error **errp,
355 NonBlockingConnectHandler *callback, void *opaque)
356 {
357 struct addrinfo *res, *e;
358 int sock = -1;
359 bool in_progress;
360 ConnectState *connect_state = NULL;
361
362 res = inet_parse_connect_opts(opts, errp);
363 if (!res) {
364 return -1;
365 }
366
367 if (callback != NULL) {
368 connect_state = g_malloc0(sizeof(*connect_state));
369 connect_state->addr_list = res;
370 connect_state->callback = callback;
371 connect_state->opaque = opaque;
372 }
373
374 for (e = res; e != NULL; e = e->ai_next) {
375 if (connect_state != NULL) {
376 connect_state->current_addr = e;
377 }
378 sock = inet_connect_addr(e, &in_progress, connect_state, errp);
379 if (in_progress) {
380 return sock;
381 } else if (sock >= 0) {
382 /* non blocking socket immediate success, call callback */
383 if (callback != NULL) {
384 callback(sock, opaque);
385 }
386 break;
387 }
388 }
389 g_free(connect_state);
390 freeaddrinfo(res);
391 return sock;
392 }
393
394 int inet_dgram_opts(QemuOpts *opts, Error **errp)
395 {
396 struct addrinfo ai, *peer = NULL, *local = NULL;
397 const char *addr;
398 const char *port;
399 int sock = -1, rc;
400
401 /* lookup peer addr */
402 memset(&ai,0, sizeof(ai));
403 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
404 ai.ai_family = PF_UNSPEC;
405 ai.ai_socktype = SOCK_DGRAM;
406
407 addr = qemu_opt_get(opts, "host");
408 port = qemu_opt_get(opts, "port");
409 if (addr == NULL || strlen(addr) == 0) {
410 addr = "localhost";
411 }
412 if (port == NULL || strlen(port) == 0) {
413 error_setg(errp, "remote port not specified");
414 return -1;
415 }
416
417 if (qemu_opt_get_bool(opts, "ipv4", 0))
418 ai.ai_family = PF_INET;
419 if (qemu_opt_get_bool(opts, "ipv6", 0))
420 ai.ai_family = PF_INET6;
421
422 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
423 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
424 gai_strerror(rc));
425 return -1;
426 }
427
428 /* lookup local addr */
429 memset(&ai,0, sizeof(ai));
430 ai.ai_flags = AI_PASSIVE;
431 ai.ai_family = peer->ai_family;
432 ai.ai_socktype = SOCK_DGRAM;
433
434 addr = qemu_opt_get(opts, "localaddr");
435 port = qemu_opt_get(opts, "localport");
436 if (addr == NULL || strlen(addr) == 0) {
437 addr = NULL;
438 }
439 if (!port || strlen(port) == 0)
440 port = "0";
441
442 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
443 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
444 gai_strerror(rc));
445 goto err;
446 }
447
448 /* create socket */
449 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
450 if (sock < 0) {
451 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
452 goto err;
453 }
454 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
455
456 /* bind socket */
457 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
458 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
459 goto err;
460 }
461
462 /* connect to peer */
463 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
464 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED);
465 goto err;
466 }
467
468 freeaddrinfo(local);
469 freeaddrinfo(peer);
470 return sock;
471
472 err:
473 if (-1 != sock)
474 closesocket(sock);
475 if (local)
476 freeaddrinfo(local);
477 if (peer)
478 freeaddrinfo(peer);
479 return -1;
480 }
481
482 /* compatibility wrapper */
483 static int inet_parse(QemuOpts *opts, const char *str)
484 {
485 const char *optstr, *h;
486 char addr[64];
487 char port[33];
488 int pos;
489
490 /* parse address */
491 if (str[0] == ':') {
492 /* no host given */
493 addr[0] = '\0';
494 if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
495 fprintf(stderr, "%s: portonly parse error (%s)\n",
496 __FUNCTION__, str);
497 return -1;
498 }
499 } else if (str[0] == '[') {
500 /* IPv6 addr */
501 if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
502 fprintf(stderr, "%s: ipv6 parse error (%s)\n",
503 __FUNCTION__, str);
504 return -1;
505 }
506 qemu_opt_set(opts, "ipv6", "on");
507 } else if (qemu_isdigit(str[0])) {
508 /* IPv4 addr */
509 if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
510 fprintf(stderr, "%s: ipv4 parse error (%s)\n",
511 __FUNCTION__, str);
512 return -1;
513 }
514 qemu_opt_set(opts, "ipv4", "on");
515 } else {
516 /* hostname */
517 if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
518 fprintf(stderr, "%s: hostname parse error (%s)\n",
519 __FUNCTION__, str);
520 return -1;
521 }
522 }
523 qemu_opt_set(opts, "host", addr);
524 qemu_opt_set(opts, "port", port);
525
526 /* parse options */
527 optstr = str + pos;
528 h = strstr(optstr, ",to=");
529 if (h)
530 qemu_opt_set(opts, "to", h+4);
531 if (strstr(optstr, ",ipv4"))
532 qemu_opt_set(opts, "ipv4", "on");
533 if (strstr(optstr, ",ipv6"))
534 qemu_opt_set(opts, "ipv6", "on");
535 return 0;
536 }
537
538 int inet_listen(const char *str, char *ostr, int olen,
539 int socktype, int port_offset, Error **errp)
540 {
541 QemuOpts *opts;
542 char *optstr;
543 int sock = -1;
544
545 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
546 if (inet_parse(opts, str) == 0) {
547 sock = inet_listen_opts(opts, port_offset, errp);
548 if (sock != -1 && ostr) {
549 optstr = strchr(str, ',');
550 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
551 snprintf(ostr, olen, "[%s]:%s%s",
552 qemu_opt_get(opts, "host"),
553 qemu_opt_get(opts, "port"),
554 optstr ? optstr : "");
555 } else {
556 snprintf(ostr, olen, "%s:%s%s",
557 qemu_opt_get(opts, "host"),
558 qemu_opt_get(opts, "port"),
559 optstr ? optstr : "");
560 }
561 }
562 } else {
563 error_set(errp, QERR_SOCKET_CREATE_FAILED);
564 }
565 qemu_opts_del(opts);
566 return sock;
567 }
568
569 /**
570 * Create a blocking socket and connect it to an address.
571 *
572 * @str: address string
573 * @errp: set in case of an error
574 *
575 * Returns -1 in case of error, file descriptor on success
576 **/
577 int inet_connect(const char *str, Error **errp)
578 {
579 QemuOpts *opts;
580 int sock = -1;
581
582 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
583 if (inet_parse(opts, str) == 0) {
584 sock = inet_connect_opts(opts, errp, NULL, NULL);
585 } else {
586 error_set(errp, QERR_SOCKET_CREATE_FAILED);
587 }
588 qemu_opts_del(opts);
589 return sock;
590 }
591
592 /**
593 * Create a non-blocking socket and connect it to an address.
594 * Calls the callback function with fd in case of success or -1 in case of
595 * error.
596 *
597 * @str: address string
598 * @callback: callback function that is called when connect completes,
599 * cannot be NULL.
600 * @opaque: opaque for callback function
601 * @errp: set in case of an error
602 *
603 * Returns: -1 on immediate error, file descriptor on success.
604 **/
605 int inet_nonblocking_connect(const char *str,
606 NonBlockingConnectHandler *callback,
607 void *opaque, Error **errp)
608 {
609 QemuOpts *opts;
610 int sock = -1;
611
612 g_assert(callback != NULL);
613
614 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
615 if (inet_parse(opts, str) == 0) {
616 sock = inet_connect_opts(opts, errp, callback, opaque);
617 } else {
618 error_set(errp, QERR_SOCKET_CREATE_FAILED);
619 }
620 qemu_opts_del(opts);
621 return sock;
622 }
623
624 #ifndef _WIN32
625
626 int unix_listen_opts(QemuOpts *opts, Error **errp)
627 {
628 struct sockaddr_un un;
629 const char *path = qemu_opt_get(opts, "path");
630 int sock, fd;
631
632 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
633 if (sock < 0) {
634 perror("socket(unix)");
635 return -1;
636 }
637
638 memset(&un, 0, sizeof(un));
639 un.sun_family = AF_UNIX;
640 if (path && strlen(path)) {
641 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
642 } else {
643 char *tmpdir = getenv("TMPDIR");
644 snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
645 tmpdir ? tmpdir : "/tmp");
646 /*
647 * This dummy fd usage silences the mktemp() unsecure warning.
648 * Using mkstemp() doesn't make things more secure here
649 * though. bind() complains about existing files, so we have
650 * to unlink first and thus re-open the race window. The
651 * worst case possible is bind() failing, i.e. a DoS attack.
652 */
653 fd = mkstemp(un.sun_path); close(fd);
654 qemu_opt_set(opts, "path", un.sun_path);
655 }
656
657 unlink(un.sun_path);
658 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
659 fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno));
660 goto err;
661 }
662 if (listen(sock, 1) < 0) {
663 fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno));
664 goto err;
665 }
666
667 return sock;
668
669 err:
670 closesocket(sock);
671 return -1;
672 }
673
674 int unix_connect_opts(QemuOpts *opts, Error **errp,
675 NonBlockingConnectHandler *callback, void *opaque)
676 {
677 struct sockaddr_un un;
678 const char *path = qemu_opt_get(opts, "path");
679 ConnectState *connect_state = NULL;
680 int sock, rc;
681
682 if (NULL == path) {
683 fprintf(stderr, "unix connect: no path specified\n");
684 return -1;
685 }
686
687 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
688 if (sock < 0) {
689 perror("socket(unix)");
690 return -1;
691 }
692 if (callback != NULL) {
693 connect_state = g_malloc0(sizeof(*connect_state));
694 connect_state->callback = callback;
695 connect_state->opaque = opaque;
696 socket_set_nonblock(sock);
697 }
698
699 memset(&un, 0, sizeof(un));
700 un.sun_family = AF_UNIX;
701 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
702
703 /* connect to peer */
704 do {
705 rc = 0;
706 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
707 rc = -socket_error();
708 }
709 } while (rc == -EINTR);
710
711 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
712 connect_state->fd = sock;
713 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
714 connect_state);
715 return sock;
716 } else if (rc >= 0) {
717 /* non blocking socket immediate success, call callback */
718 if (callback != NULL) {
719 callback(sock, opaque);
720 }
721 }
722
723 if (rc < 0) {
724 fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno));
725 close(sock);
726 sock = -1;
727 }
728
729 g_free(connect_state);
730 return sock;
731 }
732
733 #else
734
735 int unix_listen_opts(QemuOpts *opts, Error **errp)
736 {
737 fprintf(stderr, "unix sockets are not available on windows\n");
738 errno = ENOTSUP;
739 return -1;
740 }
741
742 int unix_connect_opts(QemuOpts *opts, Error **errp,
743 NonBlockingConnectHandler *callback, void *opaque)
744 {
745 fprintf(stderr, "unix sockets are not available on windows\n");
746 errno = ENOTSUP;
747 return -1;
748 }
749 #endif
750
751 /* compatibility wrapper */
752 int unix_listen(const char *str, char *ostr, int olen, Error **errp)
753 {
754 QemuOpts *opts;
755 char *path, *optstr;
756 int sock, len;
757
758 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
759
760 optstr = strchr(str, ',');
761 if (optstr) {
762 len = optstr - str;
763 if (len) {
764 path = g_malloc(len+1);
765 snprintf(path, len+1, "%.*s", len, str);
766 qemu_opt_set(opts, "path", path);
767 g_free(path);
768 }
769 } else {
770 qemu_opt_set(opts, "path", str);
771 }
772
773 sock = unix_listen_opts(opts, errp);
774
775 if (sock != -1 && ostr)
776 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
777 qemu_opts_del(opts);
778 return sock;
779 }
780
781 int unix_connect(const char *path, Error **errp)
782 {
783 QemuOpts *opts;
784 int sock;
785
786 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
787 qemu_opt_set(opts, "path", path);
788 sock = unix_connect_opts(opts, errp, NULL, NULL);
789 qemu_opts_del(opts);
790 return sock;
791 }
792
793
794 int unix_nonblocking_connect(const char *path,
795 NonBlockingConnectHandler *callback,
796 void *opaque, Error **errp)
797 {
798 QemuOpts *opts;
799 int sock = -1;
800
801 g_assert(callback != NULL);
802
803 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
804 qemu_opt_set(opts, "path", path);
805 sock = unix_connect_opts(opts, errp, callback, opaque);
806 qemu_opts_del(opts);
807 return sock;
808 }
809
810 #ifdef _WIN32
811 static void socket_cleanup(void)
812 {
813 WSACleanup();
814 }
815 #endif
816
817 int socket_init(void)
818 {
819 #ifdef _WIN32
820 WSADATA Data;
821 int ret, err;
822
823 ret = WSAStartup(MAKEWORD(2,2), &Data);
824 if (ret != 0) {
825 err = WSAGetLastError();
826 fprintf(stderr, "WSAStartup: %d\n", err);
827 return -1;
828 }
829 atexit(socket_cleanup);
830 #endif
831 return 0;
832 }