block: document block-stream in qmp-commands.hx
[qemu/ar7.git] / util / qemu-sockets.c
blob87c9bc6c68fb5a9064445d69459f4d25393b4ae0
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/monitor.h"
26 #include "qemu/sockets.h"
27 #include "qemu/main-loop.h"
29 #ifndef AI_ADDRCONFIG
30 # define AI_ADDRCONFIG 0
31 #endif
33 /* used temporarily until all users are converted to QemuOpts */
34 QemuOptsList socket_optslist = {
35 .name = "socket",
36 .head = QTAILQ_HEAD_INITIALIZER(socket_optslist.head),
37 .desc = {
39 .name = "path",
40 .type = QEMU_OPT_STRING,
41 },{
42 .name = "host",
43 .type = QEMU_OPT_STRING,
44 },{
45 .name = "port",
46 .type = QEMU_OPT_STRING,
47 },{
48 .name = "to",
49 .type = QEMU_OPT_NUMBER,
50 },{
51 .name = "ipv4",
52 .type = QEMU_OPT_BOOL,
53 },{
54 .name = "ipv6",
55 .type = QEMU_OPT_BOOL,
57 { /* end if list */ }
61 static int inet_getport(struct addrinfo *e)
63 struct sockaddr_in *i4;
64 struct sockaddr_in6 *i6;
66 switch (e->ai_family) {
67 case PF_INET6:
68 i6 = (void*)e->ai_addr;
69 return ntohs(i6->sin6_port);
70 case PF_INET:
71 i4 = (void*)e->ai_addr;
72 return ntohs(i4->sin_port);
73 default:
74 return 0;
78 static void inet_setport(struct addrinfo *e, int port)
80 struct sockaddr_in *i4;
81 struct sockaddr_in6 *i6;
83 switch (e->ai_family) {
84 case PF_INET6:
85 i6 = (void*)e->ai_addr;
86 i6->sin6_port = htons(port);
87 break;
88 case PF_INET:
89 i4 = (void*)e->ai_addr;
90 i4->sin_port = htons(port);
91 break;
95 NetworkAddressFamily inet_netfamily(int family)
97 switch (family) {
98 case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6;
99 case PF_INET: return NETWORK_ADDRESS_FAMILY_IPV4;
100 case PF_UNIX: return NETWORK_ADDRESS_FAMILY_UNIX;
102 return NETWORK_ADDRESS_FAMILY_UNKNOWN;
105 int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
107 struct addrinfo ai,*res,*e;
108 const char *addr;
109 char port[33];
110 char uaddr[INET6_ADDRSTRLEN+1];
111 char uport[33];
112 int slisten, rc, to, port_min, port_max, p;
114 memset(&ai,0, sizeof(ai));
115 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
116 ai.ai_family = PF_UNSPEC;
117 ai.ai_socktype = SOCK_STREAM;
119 if ((qemu_opt_get(opts, "host") == NULL) ||
120 (qemu_opt_get(opts, "port") == NULL)) {
121 error_setg(errp, "host and/or port not specified");
122 return -1;
124 pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
125 addr = qemu_opt_get(opts, "host");
127 to = qemu_opt_get_number(opts, "to", 0);
128 if (qemu_opt_get_bool(opts, "ipv4", 0))
129 ai.ai_family = PF_INET;
130 if (qemu_opt_get_bool(opts, "ipv6", 0))
131 ai.ai_family = PF_INET6;
133 /* lookup */
134 if (port_offset) {
135 unsigned long long baseport;
136 if (parse_uint_full(port, &baseport, 10) < 0) {
137 error_setg(errp, "can't convert to a number: %s", port);
138 return -1;
140 if (baseport > 65535 ||
141 baseport + port_offset > 65535) {
142 error_setg(errp, "port %s out of range", port);
143 return -1;
145 snprintf(port, sizeof(port), "%d", (int)baseport + port_offset);
147 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
148 if (rc != 0) {
149 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
150 gai_strerror(rc));
151 return -1;
154 /* create socket + bind */
155 for (e = res; e != NULL; e = e->ai_next) {
156 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
157 uaddr,INET6_ADDRSTRLEN,uport,32,
158 NI_NUMERICHOST | NI_NUMERICSERV);
159 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
160 if (slisten < 0) {
161 if (!e->ai_next) {
162 error_setg_errno(errp, errno, "Failed to create socket");
164 continue;
167 socket_set_fast_reuse(slisten);
168 #ifdef IPV6_V6ONLY
169 if (e->ai_family == PF_INET6) {
170 /* listen on both ipv4 and ipv6 */
171 const int off = 0;
172 qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off,
173 sizeof(off));
175 #endif
177 port_min = inet_getport(e);
178 port_max = to ? to + port_offset : port_min;
179 for (p = port_min; p <= port_max; p++) {
180 inet_setport(e, p);
181 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
182 goto listen;
184 if (p == port_max) {
185 if (!e->ai_next) {
186 error_setg_errno(errp, errno, "Failed to bind socket");
190 closesocket(slisten);
192 freeaddrinfo(res);
193 return -1;
195 listen:
196 if (listen(slisten,1) != 0) {
197 error_setg_errno(errp, errno, "Failed to listen on socket");
198 closesocket(slisten);
199 freeaddrinfo(res);
200 return -1;
202 qemu_opt_set(opts, "host", uaddr, &error_abort);
203 qemu_opt_set_number(opts, "port", inet_getport(e) - port_offset,
204 &error_abort);
205 qemu_opt_set_bool(opts, "ipv6", e->ai_family == PF_INET6,
206 &error_abort);
207 qemu_opt_set_bool(opts, "ipv4", e->ai_family != PF_INET6,
208 &error_abort);
209 freeaddrinfo(res);
210 return slisten;
213 #ifdef _WIN32
214 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
215 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
216 #else
217 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
218 ((rc) == -EINPROGRESS)
219 #endif
221 /* Struct to store connect state for non blocking connect */
222 typedef struct ConnectState {
223 int fd;
224 struct addrinfo *addr_list;
225 struct addrinfo *current_addr;
226 NonBlockingConnectHandler *callback;
227 void *opaque;
228 } ConnectState;
230 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
231 ConnectState *connect_state, Error **errp);
233 static void wait_for_connect(void *opaque)
235 ConnectState *s = opaque;
236 int val = 0, rc = 0;
237 socklen_t valsize = sizeof(val);
238 bool in_progress;
239 Error *err = NULL;
241 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
243 do {
244 rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
245 } while (rc == -1 && socket_error() == EINTR);
247 /* update rc to contain error */
248 if (!rc && val) {
249 rc = -1;
250 errno = val;
253 /* connect error */
254 if (rc < 0) {
255 error_setg_errno(&err, errno, "Error connecting to socket");
256 closesocket(s->fd);
257 s->fd = rc;
260 /* try to connect to the next address on the list */
261 if (s->current_addr) {
262 while (s->current_addr->ai_next != NULL && s->fd < 0) {
263 s->current_addr = s->current_addr->ai_next;
264 s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
265 if (s->fd < 0) {
266 error_free(err);
267 err = NULL;
268 error_setg_errno(&err, errno, "Unable to start socket connect");
270 /* connect in progress */
271 if (in_progress) {
272 goto out;
276 freeaddrinfo(s->addr_list);
279 if (s->callback) {
280 s->callback(s->fd, err, s->opaque);
282 g_free(s);
283 out:
284 error_free(err);
287 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
288 ConnectState *connect_state, Error **errp)
290 int sock, rc;
292 *in_progress = false;
294 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
295 if (sock < 0) {
296 error_setg_errno(errp, errno, "Failed to create socket");
297 return -1;
299 socket_set_fast_reuse(sock);
300 if (connect_state != NULL) {
301 qemu_set_nonblock(sock);
303 /* connect to peer */
304 do {
305 rc = 0;
306 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
307 rc = -socket_error();
309 } while (rc == -EINTR);
311 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
312 connect_state->fd = sock;
313 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
314 connect_state);
315 *in_progress = true;
316 } else if (rc < 0) {
317 error_setg_errno(errp, errno, "Failed to connect socket");
318 closesocket(sock);
319 return -1;
321 return sock;
324 static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
326 struct addrinfo ai, *res;
327 int rc;
328 const char *addr;
329 const char *port;
331 memset(&ai, 0, sizeof(ai));
333 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
334 ai.ai_family = PF_UNSPEC;
335 ai.ai_socktype = SOCK_STREAM;
337 addr = qemu_opt_get(opts, "host");
338 port = qemu_opt_get(opts, "port");
339 if (addr == NULL || port == NULL) {
340 error_setg(errp, "host and/or port not specified");
341 return NULL;
344 if (qemu_opt_get_bool(opts, "ipv4", 0)) {
345 ai.ai_family = PF_INET;
347 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
348 ai.ai_family = PF_INET6;
351 /* lookup */
352 rc = getaddrinfo(addr, port, &ai, &res);
353 if (rc != 0) {
354 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
355 gai_strerror(rc));
356 return NULL;
358 return res;
362 * Create a socket and connect it to an address.
364 * @opts: QEMU options, recognized parameters strings "host" and "port",
365 * bools "ipv4" and "ipv6".
366 * @errp: set on error
367 * @callback: callback function for non-blocking connect
368 * @opaque: opaque for callback function
370 * Returns: -1 on error, file descriptor on success.
372 * If @callback is non-null, the connect is non-blocking. If this
373 * function succeeds, callback will be called when the connection
374 * completes, with the file descriptor on success, or -1 on error.
376 int inet_connect_opts(QemuOpts *opts, Error **errp,
377 NonBlockingConnectHandler *callback, void *opaque)
379 Error *local_err = NULL;
380 struct addrinfo *res, *e;
381 int sock = -1;
382 bool in_progress;
383 ConnectState *connect_state = NULL;
385 res = inet_parse_connect_opts(opts, errp);
386 if (!res) {
387 return -1;
390 if (callback != NULL) {
391 connect_state = g_malloc0(sizeof(*connect_state));
392 connect_state->addr_list = res;
393 connect_state->callback = callback;
394 connect_state->opaque = opaque;
397 for (e = res; e != NULL; e = e->ai_next) {
398 error_free(local_err);
399 local_err = NULL;
400 if (connect_state != NULL) {
401 connect_state->current_addr = e;
403 sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
404 if (sock >= 0) {
405 break;
409 if (sock < 0) {
410 error_propagate(errp, local_err);
411 } else if (in_progress) {
412 /* wait_for_connect() will do the rest */
413 return sock;
414 } else {
415 if (callback) {
416 callback(sock, NULL, opaque);
419 g_free(connect_state);
420 freeaddrinfo(res);
421 return sock;
424 int inet_dgram_opts(QemuOpts *opts, Error **errp)
426 struct addrinfo ai, *peer = NULL, *local = NULL;
427 const char *addr;
428 const char *port;
429 int sock = -1, rc;
431 /* lookup peer addr */
432 memset(&ai,0, sizeof(ai));
433 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
434 ai.ai_family = PF_UNSPEC;
435 ai.ai_socktype = SOCK_DGRAM;
437 addr = qemu_opt_get(opts, "host");
438 port = qemu_opt_get(opts, "port");
439 if (addr == NULL || strlen(addr) == 0) {
440 addr = "localhost";
442 if (port == NULL || strlen(port) == 0) {
443 error_setg(errp, "remote port not specified");
444 return -1;
447 if (qemu_opt_get_bool(opts, "ipv4", 0))
448 ai.ai_family = PF_INET;
449 if (qemu_opt_get_bool(opts, "ipv6", 0))
450 ai.ai_family = PF_INET6;
452 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
453 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
454 gai_strerror(rc));
455 return -1;
458 /* lookup local addr */
459 memset(&ai,0, sizeof(ai));
460 ai.ai_flags = AI_PASSIVE;
461 ai.ai_family = peer->ai_family;
462 ai.ai_socktype = SOCK_DGRAM;
464 addr = qemu_opt_get(opts, "localaddr");
465 port = qemu_opt_get(opts, "localport");
466 if (addr == NULL || strlen(addr) == 0) {
467 addr = NULL;
469 if (!port || strlen(port) == 0)
470 port = "0";
472 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
473 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
474 gai_strerror(rc));
475 goto err;
478 /* create socket */
479 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
480 if (sock < 0) {
481 error_setg_errno(errp, errno, "Failed to create socket");
482 goto err;
484 socket_set_fast_reuse(sock);
486 /* bind socket */
487 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
488 error_setg_errno(errp, errno, "Failed to bind socket");
489 goto err;
492 /* connect to peer */
493 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
494 error_setg_errno(errp, errno, "Failed to connect socket");
495 goto err;
498 freeaddrinfo(local);
499 freeaddrinfo(peer);
500 return sock;
502 err:
503 if (-1 != sock)
504 closesocket(sock);
505 if (local)
506 freeaddrinfo(local);
507 if (peer)
508 freeaddrinfo(peer);
509 return -1;
512 /* compatibility wrapper */
513 InetSocketAddress *inet_parse(const char *str, Error **errp)
515 InetSocketAddress *addr;
516 const char *optstr, *h;
517 char host[65];
518 char port[33];
519 int to;
520 int pos;
522 addr = g_new0(InetSocketAddress, 1);
524 /* parse address */
525 if (str[0] == ':') {
526 /* no host given */
527 host[0] = '\0';
528 if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
529 error_setg(errp, "error parsing port in address '%s'", str);
530 goto fail;
532 } else if (str[0] == '[') {
533 /* IPv6 addr */
534 if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
535 error_setg(errp, "error parsing IPv6 address '%s'", str);
536 goto fail;
538 addr->ipv6 = addr->has_ipv6 = true;
539 } else {
540 /* hostname or IPv4 addr */
541 if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
542 error_setg(errp, "error parsing address '%s'", str);
543 goto fail;
545 if (host[strspn(host, "0123456789.")] == '\0') {
546 addr->ipv4 = addr->has_ipv4 = true;
550 addr->host = g_strdup(host);
551 addr->port = g_strdup(port);
553 /* parse options */
554 optstr = str + pos;
555 h = strstr(optstr, ",to=");
556 if (h) {
557 h += 4;
558 if (sscanf(h, "%d%n", &to, &pos) != 1 ||
559 (h[pos] != '\0' && h[pos] != ',')) {
560 error_setg(errp, "error parsing to= argument");
561 goto fail;
563 addr->has_to = true;
564 addr->to = to;
566 if (strstr(optstr, ",ipv4")) {
567 addr->ipv4 = addr->has_ipv4 = true;
569 if (strstr(optstr, ",ipv6")) {
570 addr->ipv6 = addr->has_ipv6 = true;
572 return addr;
574 fail:
575 qapi_free_InetSocketAddress(addr);
576 return NULL;
579 static void inet_addr_to_opts(QemuOpts *opts, const InetSocketAddress *addr)
581 bool ipv4 = addr->ipv4 || !addr->has_ipv4;
582 bool ipv6 = addr->ipv6 || !addr->has_ipv6;
584 if (!ipv4 || !ipv6) {
585 qemu_opt_set_bool(opts, "ipv4", ipv4, &error_abort);
586 qemu_opt_set_bool(opts, "ipv6", ipv6, &error_abort);
588 if (addr->has_to) {
589 qemu_opt_set_number(opts, "to", addr->to, &error_abort);
591 qemu_opt_set(opts, "host", addr->host, &error_abort);
592 qemu_opt_set(opts, "port", addr->port, &error_abort);
595 int inet_listen(const char *str, char *ostr, int olen,
596 int socktype, int port_offset, Error **errp)
598 QemuOpts *opts;
599 char *optstr;
600 int sock = -1;
601 InetSocketAddress *addr;
603 addr = inet_parse(str, errp);
604 if (addr != NULL) {
605 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
606 inet_addr_to_opts(opts, addr);
607 qapi_free_InetSocketAddress(addr);
608 sock = inet_listen_opts(opts, port_offset, errp);
609 if (sock != -1 && ostr) {
610 optstr = strchr(str, ',');
611 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
612 snprintf(ostr, olen, "[%s]:%s%s",
613 qemu_opt_get(opts, "host"),
614 qemu_opt_get(opts, "port"),
615 optstr ? optstr : "");
616 } else {
617 snprintf(ostr, olen, "%s:%s%s",
618 qemu_opt_get(opts, "host"),
619 qemu_opt_get(opts, "port"),
620 optstr ? optstr : "");
623 qemu_opts_del(opts);
625 return sock;
629 * Create a blocking socket and connect it to an address.
631 * @str: address string
632 * @errp: set in case of an error
634 * Returns -1 in case of error, file descriptor on success
636 int inet_connect(const char *str, Error **errp)
638 QemuOpts *opts;
639 int sock = -1;
640 InetSocketAddress *addr;
642 addr = inet_parse(str, errp);
643 if (addr != NULL) {
644 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
645 inet_addr_to_opts(opts, addr);
646 qapi_free_InetSocketAddress(addr);
647 sock = inet_connect_opts(opts, errp, NULL, NULL);
648 qemu_opts_del(opts);
650 return sock;
654 * Create a non-blocking socket and connect it to an address.
655 * Calls the callback function with fd in case of success or -1 in case of
656 * error.
658 * @str: address string
659 * @callback: callback function that is called when connect completes,
660 * cannot be NULL.
661 * @opaque: opaque for callback function
662 * @errp: set in case of an error
664 * Returns: -1 on immediate error, file descriptor on success.
666 int inet_nonblocking_connect(const char *str,
667 NonBlockingConnectHandler *callback,
668 void *opaque, Error **errp)
670 QemuOpts *opts;
671 int sock = -1;
672 InetSocketAddress *addr;
674 g_assert(callback != NULL);
676 addr = inet_parse(str, errp);
677 if (addr != NULL) {
678 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
679 inet_addr_to_opts(opts, addr);
680 qapi_free_InetSocketAddress(addr);
681 sock = inet_connect_opts(opts, errp, callback, opaque);
682 qemu_opts_del(opts);
684 return sock;
687 #ifndef _WIN32
689 int unix_listen_opts(QemuOpts *opts, Error **errp)
691 struct sockaddr_un un;
692 const char *path = qemu_opt_get(opts, "path");
693 int sock, fd;
695 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
696 if (sock < 0) {
697 error_setg_errno(errp, errno, "Failed to create Unix socket");
698 return -1;
701 memset(&un, 0, sizeof(un));
702 un.sun_family = AF_UNIX;
703 if (path && strlen(path)) {
704 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
705 } else {
706 const char *tmpdir = getenv("TMPDIR");
707 tmpdir = tmpdir ? tmpdir : "/tmp";
708 if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
709 tmpdir) >= sizeof(un.sun_path)) {
710 error_setg_errno(errp, errno,
711 "TMPDIR environment variable (%s) too large", tmpdir);
712 goto err;
716 * This dummy fd usage silences the mktemp() unsecure warning.
717 * Using mkstemp() doesn't make things more secure here
718 * though. bind() complains about existing files, so we have
719 * to unlink first and thus re-open the race window. The
720 * worst case possible is bind() failing, i.e. a DoS attack.
722 fd = mkstemp(un.sun_path);
723 if (fd < 0) {
724 error_setg_errno(errp, errno,
725 "Failed to make a temporary socket name in %s", tmpdir);
726 goto err;
728 close(fd);
729 qemu_opt_set(opts, "path", un.sun_path, &error_abort);
732 unlink(un.sun_path);
733 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
734 error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path);
735 goto err;
737 if (listen(sock, 1) < 0) {
738 error_setg_errno(errp, errno, "Failed to listen on socket");
739 goto err;
742 return sock;
744 err:
745 closesocket(sock);
746 return -1;
749 int unix_connect_opts(QemuOpts *opts, Error **errp,
750 NonBlockingConnectHandler *callback, void *opaque)
752 struct sockaddr_un un;
753 const char *path = qemu_opt_get(opts, "path");
754 ConnectState *connect_state = NULL;
755 int sock, rc;
757 if (path == NULL) {
758 error_setg(errp, "unix connect: no path specified");
759 return -1;
762 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
763 if (sock < 0) {
764 error_setg_errno(errp, errno, "Failed to create socket");
765 return -1;
767 if (callback != NULL) {
768 connect_state = g_malloc0(sizeof(*connect_state));
769 connect_state->callback = callback;
770 connect_state->opaque = opaque;
771 qemu_set_nonblock(sock);
774 memset(&un, 0, sizeof(un));
775 un.sun_family = AF_UNIX;
776 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
778 /* connect to peer */
779 do {
780 rc = 0;
781 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
782 rc = -socket_error();
784 } while (rc == -EINTR);
786 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
787 connect_state->fd = sock;
788 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
789 connect_state);
790 return sock;
791 } else if (rc >= 0) {
792 /* non blocking socket immediate success, call callback */
793 if (callback != NULL) {
794 callback(sock, NULL, opaque);
798 if (rc < 0) {
799 error_setg_errno(errp, -rc, "Failed to connect socket");
800 close(sock);
801 sock = -1;
804 g_free(connect_state);
805 return sock;
808 #else
810 int unix_listen_opts(QemuOpts *opts, Error **errp)
812 error_setg(errp, "unix sockets are not available on windows");
813 errno = ENOTSUP;
814 return -1;
817 int unix_connect_opts(QemuOpts *opts, Error **errp,
818 NonBlockingConnectHandler *callback, void *opaque)
820 error_setg(errp, "unix sockets are not available on windows");
821 errno = ENOTSUP;
822 return -1;
824 #endif
826 /* compatibility wrapper */
827 int unix_listen(const char *str, char *ostr, int olen, Error **errp)
829 QemuOpts *opts;
830 char *path, *optstr;
831 int sock, len;
833 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
835 optstr = strchr(str, ',');
836 if (optstr) {
837 len = optstr - str;
838 if (len) {
839 path = g_malloc(len+1);
840 snprintf(path, len+1, "%.*s", len, str);
841 qemu_opt_set(opts, "path", path, &error_abort);
842 g_free(path);
844 } else {
845 qemu_opt_set(opts, "path", str, &error_abort);
848 sock = unix_listen_opts(opts, errp);
850 if (sock != -1 && ostr)
851 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
852 qemu_opts_del(opts);
853 return sock;
856 int unix_connect(const char *path, Error **errp)
858 QemuOpts *opts;
859 int sock;
861 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
862 qemu_opt_set(opts, "path", path, &error_abort);
863 sock = unix_connect_opts(opts, errp, NULL, NULL);
864 qemu_opts_del(opts);
865 return sock;
869 int unix_nonblocking_connect(const char *path,
870 NonBlockingConnectHandler *callback,
871 void *opaque, Error **errp)
873 QemuOpts *opts;
874 int sock = -1;
876 g_assert(callback != NULL);
878 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
879 qemu_opt_set(opts, "path", path, &error_abort);
880 sock = unix_connect_opts(opts, errp, callback, opaque);
881 qemu_opts_del(opts);
882 return sock;
885 SocketAddress *socket_parse(const char *str, Error **errp)
887 SocketAddress *addr;
889 addr = g_new0(SocketAddress, 1);
890 if (strstart(str, "unix:", NULL)) {
891 if (str[5] == '\0') {
892 error_setg(errp, "invalid Unix socket address");
893 goto fail;
894 } else {
895 addr->kind = SOCKET_ADDRESS_KIND_UNIX;
896 addr->q_unix = g_new(UnixSocketAddress, 1);
897 addr->q_unix->path = g_strdup(str + 5);
899 } else if (strstart(str, "fd:", NULL)) {
900 if (str[3] == '\0') {
901 error_setg(errp, "invalid file descriptor address");
902 goto fail;
903 } else {
904 addr->kind = SOCKET_ADDRESS_KIND_FD;
905 addr->fd = g_new(String, 1);
906 addr->fd->str = g_strdup(str + 3);
908 } else {
909 addr->kind = SOCKET_ADDRESS_KIND_INET;
910 addr->inet = inet_parse(str, errp);
911 if (addr->inet == NULL) {
912 goto fail;
915 return addr;
917 fail:
918 qapi_free_SocketAddress(addr);
919 return NULL;
922 int socket_connect(SocketAddress *addr, Error **errp,
923 NonBlockingConnectHandler *callback, void *opaque)
925 QemuOpts *opts;
926 int fd;
928 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
929 switch (addr->kind) {
930 case SOCKET_ADDRESS_KIND_INET:
931 inet_addr_to_opts(opts, addr->inet);
932 fd = inet_connect_opts(opts, errp, callback, opaque);
933 break;
935 case SOCKET_ADDRESS_KIND_UNIX:
936 qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort);
937 fd = unix_connect_opts(opts, errp, callback, opaque);
938 break;
940 case SOCKET_ADDRESS_KIND_FD:
941 fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
942 if (fd >= 0 && callback) {
943 qemu_set_nonblock(fd);
944 callback(fd, NULL, opaque);
946 break;
948 default:
949 abort();
951 qemu_opts_del(opts);
952 return fd;
955 int socket_listen(SocketAddress *addr, Error **errp)
957 QemuOpts *opts;
958 int fd;
960 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
961 switch (addr->kind) {
962 case SOCKET_ADDRESS_KIND_INET:
963 inet_addr_to_opts(opts, addr->inet);
964 fd = inet_listen_opts(opts, 0, errp);
965 break;
967 case SOCKET_ADDRESS_KIND_UNIX:
968 qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort);
969 fd = unix_listen_opts(opts, errp);
970 break;
972 case SOCKET_ADDRESS_KIND_FD:
973 fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
974 break;
976 default:
977 abort();
979 qemu_opts_del(opts);
980 return fd;
983 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
985 QemuOpts *opts;
986 int fd;
988 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
989 switch (remote->kind) {
990 case SOCKET_ADDRESS_KIND_INET:
991 inet_addr_to_opts(opts, remote->inet);
992 if (local) {
993 qemu_opt_set(opts, "localaddr", local->inet->host, &error_abort);
994 qemu_opt_set(opts, "localport", local->inet->port, &error_abort);
996 fd = inet_dgram_opts(opts, errp);
997 break;
999 default:
1000 error_setg(errp, "socket type unsupported for datagram");
1001 fd = -1;
1003 qemu_opts_del(opts);
1004 return fd;