target-sparc: Revert setting cpu_dst to gen_dest_gpr
[qemu/pbrook.git] / qemu-sockets.c
blobcfed9c5a5bd9e14b68015a1be2f909eabfa73cc6
1 /*
2 * inet and unix socket functions for qemu
4 * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
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.
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.
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.
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <unistd.h>
25 #include "monitor.h"
26 #include "qemu_socket.h"
27 #include "qemu-common.h" /* for qemu_isdigit */
28 #include "main-loop.h"
30 #ifndef AI_ADDRCONFIG
31 # define AI_ADDRCONFIG 0
32 #endif
34 static const int on=1, off=0;
36 /* used temporarely until all users are converted to QemuOpts */
37 static QemuOptsList dummy_opts = {
38 .name = "dummy",
39 .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
40 .desc = {
42 .name = "path",
43 .type = QEMU_OPT_STRING,
44 },{
45 .name = "host",
46 .type = QEMU_OPT_STRING,
47 },{
48 .name = "port",
49 .type = QEMU_OPT_STRING,
50 },{
51 .name = "to",
52 .type = QEMU_OPT_NUMBER,
53 },{
54 .name = "ipv4",
55 .type = QEMU_OPT_BOOL,
56 },{
57 .name = "ipv6",
58 .type = QEMU_OPT_BOOL,
60 { /* end if list */ }
64 static int inet_getport(struct addrinfo *e)
66 struct sockaddr_in *i4;
67 struct sockaddr_in6 *i6;
69 switch (e->ai_family) {
70 case PF_INET6:
71 i6 = (void*)e->ai_addr;
72 return ntohs(i6->sin6_port);
73 case PF_INET:
74 i4 = (void*)e->ai_addr;
75 return ntohs(i4->sin_port);
76 default:
77 return 0;
81 static void inet_setport(struct addrinfo *e, int port)
83 struct sockaddr_in *i4;
84 struct sockaddr_in6 *i6;
86 switch (e->ai_family) {
87 case PF_INET6:
88 i6 = (void*)e->ai_addr;
89 i6->sin6_port = htons(port);
90 break;
91 case PF_INET:
92 i4 = (void*)e->ai_addr;
93 i4->sin_port = htons(port);
94 break;
98 const char *inet_strfamily(int family)
100 switch (family) {
101 case PF_INET6: return "ipv6";
102 case PF_INET: return "ipv4";
103 case PF_UNIX: return "unix";
105 return "unknown";
108 int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
110 struct addrinfo ai,*res,*e;
111 const char *addr;
112 char port[33];
113 char uaddr[INET6_ADDRSTRLEN+1];
114 char uport[33];
115 int slisten, rc, to, port_min, port_max, p;
117 memset(&ai,0, sizeof(ai));
118 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
119 ai.ai_family = PF_UNSPEC;
120 ai.ai_socktype = SOCK_STREAM;
122 if ((qemu_opt_get(opts, "host") == NULL) ||
123 (qemu_opt_get(opts, "port") == NULL)) {
124 error_setg(errp, "host and/or port not specified");
125 return -1;
127 pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
128 addr = qemu_opt_get(opts, "host");
130 to = qemu_opt_get_number(opts, "to", 0);
131 if (qemu_opt_get_bool(opts, "ipv4", 0))
132 ai.ai_family = PF_INET;
133 if (qemu_opt_get_bool(opts, "ipv6", 0))
134 ai.ai_family = PF_INET6;
136 /* lookup */
137 if (port_offset)
138 snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
139 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
140 if (rc != 0) {
141 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
142 gai_strerror(rc));
143 return -1;
146 /* create socket + bind */
147 for (e = res; e != NULL; e = e->ai_next) {
148 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
149 uaddr,INET6_ADDRSTRLEN,uport,32,
150 NI_NUMERICHOST | NI_NUMERICSERV);
151 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
152 if (slisten < 0) {
153 if (!e->ai_next) {
154 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
156 continue;
159 setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
160 #ifdef IPV6_V6ONLY
161 if (e->ai_family == PF_INET6) {
162 /* listen on both ipv4 and ipv6 */
163 setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
164 sizeof(off));
166 #endif
168 port_min = inet_getport(e);
169 port_max = to ? to + port_offset : port_min;
170 for (p = port_min; p <= port_max; p++) {
171 inet_setport(e, p);
172 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
173 goto listen;
175 if (p == port_max) {
176 if (!e->ai_next) {
177 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
181 closesocket(slisten);
183 freeaddrinfo(res);
184 return -1;
186 listen:
187 if (listen(slisten,1) != 0) {
188 error_set_errno(errp, errno, QERR_SOCKET_LISTEN_FAILED);
189 closesocket(slisten);
190 freeaddrinfo(res);
191 return -1;
193 snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
194 qemu_opt_set(opts, "host", uaddr);
195 qemu_opt_set(opts, "port", uport);
196 qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
197 qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
198 freeaddrinfo(res);
199 return slisten;
202 #ifdef _WIN32
203 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
204 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
205 #else
206 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
207 ((rc) == -EINPROGRESS)
208 #endif
210 /* Struct to store connect state for non blocking connect */
211 typedef struct ConnectState {
212 int fd;
213 struct addrinfo *addr_list;
214 struct addrinfo *current_addr;
215 NonBlockingConnectHandler *callback;
216 void *opaque;
217 } ConnectState;
219 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
220 ConnectState *connect_state, Error **errp);
222 static void wait_for_connect(void *opaque)
224 ConnectState *s = opaque;
225 int val = 0, rc = 0;
226 socklen_t valsize = sizeof(val);
227 bool in_progress;
229 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
231 do {
232 rc = getsockopt(s->fd, SOL_SOCKET, SO_ERROR, (void *) &val, &valsize);
233 } while (rc == -1 && socket_error() == EINTR);
235 /* update rc to contain error */
236 if (!rc && val) {
237 rc = -1;
240 /* connect error */
241 if (rc < 0) {
242 closesocket(s->fd);
243 s->fd = rc;
246 /* try to connect to the next address on the list */
247 if (s->current_addr) {
248 while (s->current_addr->ai_next != NULL && s->fd < 0) {
249 s->current_addr = s->current_addr->ai_next;
250 s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
251 /* connect in progress */
252 if (in_progress) {
253 return;
257 freeaddrinfo(s->addr_list);
260 if (s->callback) {
261 s->callback(s->fd, s->opaque);
263 g_free(s);
266 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
267 ConnectState *connect_state, Error **errp)
269 int sock, rc;
271 *in_progress = false;
273 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
274 if (sock < 0) {
275 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
276 return -1;
278 qemu_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
279 if (connect_state != NULL) {
280 socket_set_nonblock(sock);
282 /* connect to peer */
283 do {
284 rc = 0;
285 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
286 rc = -socket_error();
288 } while (rc == -EINTR);
290 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
291 connect_state->fd = sock;
292 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
293 connect_state);
294 *in_progress = true;
295 } else if (rc < 0) {
296 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED);
297 closesocket(sock);
298 return -1;
300 return sock;
303 static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
305 struct addrinfo ai, *res;
306 int rc;
307 const char *addr;
308 const char *port;
310 memset(&ai, 0, sizeof(ai));
312 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
313 ai.ai_family = PF_UNSPEC;
314 ai.ai_socktype = SOCK_STREAM;
316 addr = qemu_opt_get(opts, "host");
317 port = qemu_opt_get(opts, "port");
318 if (addr == NULL || port == NULL) {
319 error_setg(errp, "host and/or port not specified");
320 return NULL;
323 if (qemu_opt_get_bool(opts, "ipv4", 0)) {
324 ai.ai_family = PF_INET;
326 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
327 ai.ai_family = PF_INET6;
330 /* lookup */
331 rc = getaddrinfo(addr, port, &ai, &res);
332 if (rc != 0) {
333 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
334 gai_strerror(rc));
335 return NULL;
337 return res;
341 * Create a socket and connect it to an address.
343 * @opts: QEMU options, recognized parameters strings "host" and "port",
344 * bools "ipv4" and "ipv6".
345 * @errp: set on error
346 * @callback: callback function for non-blocking connect
347 * @opaque: opaque for callback function
349 * Returns: -1 on error, file descriptor on success.
351 * If @callback is non-null, the connect is non-blocking. If this
352 * function succeeds, callback will be called when the connection
353 * completes, with the file descriptor on success, or -1 on error.
355 int inet_connect_opts(QemuOpts *opts, Error **errp,
356 NonBlockingConnectHandler *callback, void *opaque)
358 struct addrinfo *res, *e;
359 int sock = -1;
360 bool in_progress;
361 ConnectState *connect_state = NULL;
363 res = inet_parse_connect_opts(opts, errp);
364 if (!res) {
365 return -1;
368 if (callback != NULL) {
369 connect_state = g_malloc0(sizeof(*connect_state));
370 connect_state->addr_list = res;
371 connect_state->callback = callback;
372 connect_state->opaque = opaque;
375 for (e = res; e != NULL; e = e->ai_next) {
376 if (connect_state != NULL) {
377 connect_state->current_addr = e;
379 sock = inet_connect_addr(e, &in_progress, connect_state, errp);
380 if (in_progress) {
381 return sock;
382 } else if (sock >= 0) {
383 /* non blocking socket immediate success, call callback */
384 if (callback != NULL) {
385 callback(sock, opaque);
387 break;
390 g_free(connect_state);
391 freeaddrinfo(res);
392 return sock;
395 int inet_dgram_opts(QemuOpts *opts, Error **errp)
397 struct addrinfo ai, *peer = NULL, *local = NULL;
398 const char *addr;
399 const char *port;
400 int sock = -1, rc;
402 /* lookup peer addr */
403 memset(&ai,0, sizeof(ai));
404 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
405 ai.ai_family = PF_UNSPEC;
406 ai.ai_socktype = SOCK_DGRAM;
408 addr = qemu_opt_get(opts, "host");
409 port = qemu_opt_get(opts, "port");
410 if (addr == NULL || strlen(addr) == 0) {
411 addr = "localhost";
413 if (port == NULL || strlen(port) == 0) {
414 error_setg(errp, "remote port not specified");
415 return -1;
418 if (qemu_opt_get_bool(opts, "ipv4", 0))
419 ai.ai_family = PF_INET;
420 if (qemu_opt_get_bool(opts, "ipv6", 0))
421 ai.ai_family = PF_INET6;
423 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
424 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
425 gai_strerror(rc));
426 return -1;
429 /* lookup local addr */
430 memset(&ai,0, sizeof(ai));
431 ai.ai_flags = AI_PASSIVE;
432 ai.ai_family = peer->ai_family;
433 ai.ai_socktype = SOCK_DGRAM;
435 addr = qemu_opt_get(opts, "localaddr");
436 port = qemu_opt_get(opts, "localport");
437 if (addr == NULL || strlen(addr) == 0) {
438 addr = NULL;
440 if (!port || strlen(port) == 0)
441 port = "0";
443 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
444 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
445 gai_strerror(rc));
446 goto err;
449 /* create socket */
450 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
451 if (sock < 0) {
452 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
453 goto err;
455 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
457 /* bind socket */
458 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
459 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
460 goto err;
463 /* connect to peer */
464 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
465 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED);
466 goto err;
469 freeaddrinfo(local);
470 freeaddrinfo(peer);
471 return sock;
473 err:
474 if (-1 != sock)
475 closesocket(sock);
476 if (local)
477 freeaddrinfo(local);
478 if (peer)
479 freeaddrinfo(peer);
480 return -1;
483 /* compatibility wrapper */
484 static InetSocketAddress *inet_parse(const char *str, Error **errp)
486 InetSocketAddress *addr;
487 const char *optstr, *h;
488 char host[64];
489 char port[33];
490 int to;
491 int pos;
493 addr = g_new0(InetSocketAddress, 1);
495 /* parse address */
496 if (str[0] == ':') {
497 /* no host given */
498 host[0] = '\0';
499 if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
500 error_setg(errp, "error parsing port in address '%s'", str);
501 goto fail;
503 } else if (str[0] == '[') {
504 /* IPv6 addr */
505 if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
506 error_setg(errp, "error parsing IPv6 address '%s'", str);
507 goto fail;
509 addr->ipv6 = addr->has_ipv6 = true;
510 } else if (qemu_isdigit(str[0])) {
511 /* IPv4 addr */
512 if (2 != sscanf(str, "%64[0-9.]:%32[^,]%n", host, port, &pos)) {
513 error_setg(errp, "error parsing IPv4 address '%s'", str);
514 goto fail;
516 addr->ipv4 = addr->has_ipv4 = true;
517 } else {
518 /* hostname */
519 if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
520 error_setg(errp, "error parsing address '%s'", str);
521 goto fail;
525 addr->host = g_strdup(host);
526 addr->port = g_strdup(port);
528 /* parse options */
529 optstr = str + pos;
530 h = strstr(optstr, ",to=");
531 if (h) {
532 if (1 != sscanf(str, "%d%n", &to, &pos) ||
533 (str[pos] != '\0' && str[pos] != ',')) {
534 error_setg(errp, "error parsing to= argument");
535 goto fail;
537 addr->has_to = true;
538 addr->to = to;
540 if (strstr(optstr, ",ipv4")) {
541 addr->ipv4 = addr->has_ipv4 = true;
543 if (strstr(optstr, ",ipv6")) {
544 addr->ipv6 = addr->has_ipv6 = true;
546 return addr;
548 fail:
549 qapi_free_InetSocketAddress(addr);
550 return NULL;
553 static void inet_addr_to_opts(QemuOpts *opts, InetSocketAddress *addr)
555 bool ipv4 = addr->ipv4 || !addr->has_ipv4;
556 bool ipv6 = addr->ipv6 || !addr->has_ipv6;
558 if (!ipv4 || !ipv6) {
559 qemu_opt_set_bool(opts, "ipv4", ipv4);
560 qemu_opt_set_bool(opts, "ipv6", ipv6);
562 if (addr->has_to) {
563 char to[20];
564 snprintf(to, sizeof(to), "%d", addr->to);
565 qemu_opt_set(opts, "to", to);
567 qemu_opt_set(opts, "host", addr->host);
568 qemu_opt_set(opts, "port", addr->port);
571 int inet_listen(const char *str, char *ostr, int olen,
572 int socktype, int port_offset, Error **errp)
574 QemuOpts *opts;
575 char *optstr;
576 int sock = -1;
577 InetSocketAddress *addr;
579 addr = inet_parse(str, errp);
580 if (addr != NULL) {
581 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
582 inet_addr_to_opts(opts, addr);
583 qapi_free_InetSocketAddress(addr);
584 sock = inet_listen_opts(opts, port_offset, errp);
585 if (sock != -1 && ostr) {
586 optstr = strchr(str, ',');
587 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
588 snprintf(ostr, olen, "[%s]:%s%s",
589 qemu_opt_get(opts, "host"),
590 qemu_opt_get(opts, "port"),
591 optstr ? optstr : "");
592 } else {
593 snprintf(ostr, olen, "%s:%s%s",
594 qemu_opt_get(opts, "host"),
595 qemu_opt_get(opts, "port"),
596 optstr ? optstr : "");
599 qemu_opts_del(opts);
601 return sock;
605 * Create a blocking socket and connect it to an address.
607 * @str: address string
608 * @errp: set in case of an error
610 * Returns -1 in case of error, file descriptor on success
612 int inet_connect(const char *str, Error **errp)
614 QemuOpts *opts;
615 int sock = -1;
616 InetSocketAddress *addr;
618 addr = inet_parse(str, errp);
619 if (addr != NULL) {
620 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
621 inet_addr_to_opts(opts, addr);
622 qapi_free_InetSocketAddress(addr);
623 sock = inet_connect_opts(opts, errp, NULL, NULL);
624 qemu_opts_del(opts);
626 return sock;
630 * Create a non-blocking socket and connect it to an address.
631 * Calls the callback function with fd in case of success or -1 in case of
632 * error.
634 * @str: address string
635 * @callback: callback function that is called when connect completes,
636 * cannot be NULL.
637 * @opaque: opaque for callback function
638 * @errp: set in case of an error
640 * Returns: -1 on immediate error, file descriptor on success.
642 int inet_nonblocking_connect(const char *str,
643 NonBlockingConnectHandler *callback,
644 void *opaque, Error **errp)
646 QemuOpts *opts;
647 int sock = -1;
648 InetSocketAddress *addr;
650 g_assert(callback != NULL);
652 addr = inet_parse(str, errp);
653 if (addr != NULL) {
654 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
655 inet_addr_to_opts(opts, addr);
656 qapi_free_InetSocketAddress(addr);
657 sock = inet_connect_opts(opts, errp, callback, opaque);
658 qemu_opts_del(opts);
660 return sock;
663 #ifndef _WIN32
665 int unix_listen_opts(QemuOpts *opts, Error **errp)
667 struct sockaddr_un un;
668 const char *path = qemu_opt_get(opts, "path");
669 int sock, fd;
671 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
672 if (sock < 0) {
673 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
674 return -1;
677 memset(&un, 0, sizeof(un));
678 un.sun_family = AF_UNIX;
679 if (path && strlen(path)) {
680 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
681 } else {
682 char *tmpdir = getenv("TMPDIR");
683 snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
684 tmpdir ? tmpdir : "/tmp");
686 * This dummy fd usage silences the mktemp() unsecure warning.
687 * Using mkstemp() doesn't make things more secure here
688 * though. bind() complains about existing files, so we have
689 * to unlink first and thus re-open the race window. The
690 * worst case possible is bind() failing, i.e. a DoS attack.
692 fd = mkstemp(un.sun_path); close(fd);
693 qemu_opt_set(opts, "path", un.sun_path);
696 unlink(un.sun_path);
697 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
698 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
699 goto err;
701 if (listen(sock, 1) < 0) {
702 error_set_errno(errp, errno, QERR_SOCKET_LISTEN_FAILED);
703 goto err;
706 return sock;
708 err:
709 closesocket(sock);
710 return -1;
713 int unix_connect_opts(QemuOpts *opts, Error **errp,
714 NonBlockingConnectHandler *callback, void *opaque)
716 struct sockaddr_un un;
717 const char *path = qemu_opt_get(opts, "path");
718 ConnectState *connect_state = NULL;
719 int sock, rc;
721 if (NULL == path) {
722 error_setg(errp, "unix connect: no path specified\n");
723 return -1;
726 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
727 if (sock < 0) {
728 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
729 return -1;
731 if (callback != NULL) {
732 connect_state = g_malloc0(sizeof(*connect_state));
733 connect_state->callback = callback;
734 connect_state->opaque = opaque;
735 socket_set_nonblock(sock);
738 memset(&un, 0, sizeof(un));
739 un.sun_family = AF_UNIX;
740 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
742 /* connect to peer */
743 do {
744 rc = 0;
745 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
746 rc = -socket_error();
748 } while (rc == -EINTR);
750 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
751 connect_state->fd = sock;
752 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
753 connect_state);
754 return sock;
755 } else if (rc >= 0) {
756 /* non blocking socket immediate success, call callback */
757 if (callback != NULL) {
758 callback(sock, opaque);
762 if (rc < 0) {
763 error_set_errno(errp, -rc, QERR_SOCKET_CONNECT_FAILED);
764 close(sock);
765 sock = -1;
768 g_free(connect_state);
769 return sock;
772 #else
774 int unix_listen_opts(QemuOpts *opts, Error **errp)
776 error_setg(errp, "unix sockets are not available on windows");
777 errno = ENOTSUP;
778 return -1;
781 int unix_connect_opts(QemuOpts *opts, Error **errp,
782 NonBlockingConnectHandler *callback, void *opaque)
784 error_setg(errp, "unix sockets are not available on windows");
785 errno = ENOTSUP;
786 return -1;
788 #endif
790 /* compatibility wrapper */
791 int unix_listen(const char *str, char *ostr, int olen, Error **errp)
793 QemuOpts *opts;
794 char *path, *optstr;
795 int sock, len;
797 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
799 optstr = strchr(str, ',');
800 if (optstr) {
801 len = optstr - str;
802 if (len) {
803 path = g_malloc(len+1);
804 snprintf(path, len+1, "%.*s", len, str);
805 qemu_opt_set(opts, "path", path);
806 g_free(path);
808 } else {
809 qemu_opt_set(opts, "path", str);
812 sock = unix_listen_opts(opts, errp);
814 if (sock != -1 && ostr)
815 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
816 qemu_opts_del(opts);
817 return sock;
820 int unix_connect(const char *path, Error **errp)
822 QemuOpts *opts;
823 int sock;
825 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
826 qemu_opt_set(opts, "path", path);
827 sock = unix_connect_opts(opts, errp, NULL, NULL);
828 qemu_opts_del(opts);
829 return sock;
833 int unix_nonblocking_connect(const char *path,
834 NonBlockingConnectHandler *callback,
835 void *opaque, Error **errp)
837 QemuOpts *opts;
838 int sock = -1;
840 g_assert(callback != NULL);
842 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
843 qemu_opt_set(opts, "path", path);
844 sock = unix_connect_opts(opts, errp, callback, opaque);
845 qemu_opts_del(opts);
846 return sock;
849 SocketAddress *socket_parse(const char *str, Error **errp)
851 SocketAddress *addr = NULL;
853 addr = g_new(SocketAddress, 1);
854 if (strstart(str, "unix:", NULL)) {
855 if (str[5] == '\0') {
856 error_setg(errp, "invalid Unix socket address\n");
857 goto fail;
858 } else {
859 addr->kind = SOCKET_ADDRESS_KIND_UNIX;
860 addr->q_unix = g_new(UnixSocketAddress, 1);
861 addr->q_unix->path = g_strdup(str + 5);
863 } else if (strstart(str, "fd:", NULL)) {
864 if (str[3] == '\0') {
865 error_setg(errp, "invalid file descriptor address\n");
866 goto fail;
867 } else {
868 addr->kind = SOCKET_ADDRESS_KIND_FD;
869 addr->fd = g_new(String, 1);
870 addr->fd->str = g_strdup(str + 3);
872 } else {
873 addr->kind = SOCKET_ADDRESS_KIND_INET;
874 addr->inet = g_new(InetSocketAddress, 1);
875 addr->inet = inet_parse(str, errp);
876 if (addr->inet == NULL) {
877 goto fail;
880 return addr;
882 fail:
883 qapi_free_SocketAddress(addr);
884 return NULL;
887 int socket_connect(SocketAddress *addr, Error **errp,
888 NonBlockingConnectHandler *callback, void *opaque)
890 QemuOpts *opts;
891 int fd;
893 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
894 switch (addr->kind) {
895 case SOCKET_ADDRESS_KIND_INET:
896 inet_addr_to_opts(opts, addr->inet);
897 fd = inet_connect_opts(opts, errp, callback, opaque);
898 break;
900 case SOCKET_ADDRESS_KIND_UNIX:
901 qemu_opt_set(opts, "path", addr->q_unix->path);
902 fd = unix_connect_opts(opts, errp, callback, opaque);
903 break;
905 case SOCKET_ADDRESS_KIND_FD:
906 fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
907 if (callback) {
908 callback(fd, opaque);
910 break;
912 default:
913 abort();
915 qemu_opts_del(opts);
916 return fd;
919 int socket_listen(SocketAddress *addr, Error **errp)
921 QemuOpts *opts;
922 int fd;
924 opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
925 switch (addr->kind) {
926 case SOCKET_ADDRESS_KIND_INET:
927 inet_addr_to_opts(opts, addr->inet);
928 fd = inet_listen_opts(opts, 0, errp);
929 break;
931 case SOCKET_ADDRESS_KIND_UNIX:
932 qemu_opt_set(opts, "path", addr->q_unix->path);
933 fd = unix_listen_opts(opts, errp);
934 break;
936 case SOCKET_ADDRESS_KIND_FD:
937 fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
938 break;
940 default:
941 abort();
943 qemu_opts_del(opts);
944 return fd;
947 #ifdef _WIN32
948 static void socket_cleanup(void)
950 WSACleanup();
952 #endif
954 int socket_init(void)
956 #ifdef _WIN32
957 WSADATA Data;
958 int ret, err;
960 ret = WSAStartup(MAKEWORD(2,2), &Data);
961 if (ret != 0) {
962 err = WSAGetLastError();
963 fprintf(stderr, "WSAStartup: %d\n", err);
964 return -1;
966 atexit(socket_cleanup);
967 #endif
968 return 0;