xref: /openbmc/qemu/util/qemu-sockets.c (revision bcd82a96)
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 "qemu/osdep.h"
19 
20 #include "monitor/monitor.h"
21 #include "qapi/error.h"
22 #include "qemu/sockets.h"
23 #include "qemu/main-loop.h"
24 #include "qapi/qmp-input-visitor.h"
25 #include "qapi/qmp-output-visitor.h"
26 #include "qapi-visit.h"
27 #include "qemu/cutils.h"
28 
29 #ifndef AI_ADDRCONFIG
30 # define AI_ADDRCONFIG 0
31 #endif
32 
33 #ifndef AI_V4MAPPED
34 # define AI_V4MAPPED 0
35 #endif
36 
37 
38 static int inet_getport(struct addrinfo *e)
39 {
40     struct sockaddr_in *i4;
41     struct sockaddr_in6 *i6;
42 
43     switch (e->ai_family) {
44     case PF_INET6:
45         i6 = (void*)e->ai_addr;
46         return ntohs(i6->sin6_port);
47     case PF_INET:
48         i4 = (void*)e->ai_addr;
49         return ntohs(i4->sin_port);
50     default:
51         return 0;
52     }
53 }
54 
55 static void inet_setport(struct addrinfo *e, int port)
56 {
57     struct sockaddr_in *i4;
58     struct sockaddr_in6 *i6;
59 
60     switch (e->ai_family) {
61     case PF_INET6:
62         i6 = (void*)e->ai_addr;
63         i6->sin6_port = htons(port);
64         break;
65     case PF_INET:
66         i4 = (void*)e->ai_addr;
67         i4->sin_port = htons(port);
68         break;
69     }
70 }
71 
72 NetworkAddressFamily inet_netfamily(int family)
73 {
74     switch (family) {
75     case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6;
76     case PF_INET:  return NETWORK_ADDRESS_FAMILY_IPV4;
77     case PF_UNIX:  return NETWORK_ADDRESS_FAMILY_UNIX;
78     }
79     return NETWORK_ADDRESS_FAMILY_UNKNOWN;
80 }
81 
82 /*
83  * Matrix we're trying to apply
84  *
85  *  ipv4  ipv6   family
86  *   -     -       PF_UNSPEC
87  *   -     f       PF_INET
88  *   -     t       PF_INET6
89  *   f     -       PF_INET6
90  *   f     f       <error>
91  *   f     t       PF_INET6
92  *   t     -       PF_INET
93  *   t     f       PF_INET
94  *   t     t       PF_INET6
95  *
96  * NB, this matrix is only about getting the neccessary results
97  * from getaddrinfo(). Some of the cases require further work
98  * after reading results from getaddrinfo in order to fully
99  * apply the logic the end user wants. eg with the last case
100  * ipv4=t + ipv6=t + PF_INET6, getaddrinfo alone can only
101  * guarantee the ipv6=t part of the request - we need more
102  * checks to provide ipv4=t part of the guarantee. This is
103  * outside scope of this method and not currently handled by
104  * callers at all.
105  */
106 static int inet_ai_family_from_address(InetSocketAddress *addr,
107                                        Error **errp)
108 {
109     if (addr->has_ipv6 && addr->has_ipv4 &&
110         !addr->ipv6 && !addr->ipv4) {
111         error_setg(errp, "Cannot disable IPv4 and IPv6 at same time");
112         return PF_UNSPEC;
113     }
114     if ((addr->has_ipv6 && addr->ipv6) || (addr->has_ipv4 && !addr->ipv4)) {
115         return PF_INET6;
116     }
117     if ((addr->has_ipv4 && addr->ipv4) || (addr->has_ipv6 && !addr->ipv6)) {
118         return PF_INET;
119     }
120     return PF_UNSPEC;
121 }
122 
123 static int inet_listen_saddr(InetSocketAddress *saddr,
124                              int port_offset,
125                              bool update_addr,
126                              Error **errp)
127 {
128     struct addrinfo ai,*res,*e;
129     char port[33];
130     char uaddr[INET6_ADDRSTRLEN+1];
131     char uport[33];
132     int slisten, rc, port_min, port_max, p;
133     Error *err = NULL;
134 
135     memset(&ai,0, sizeof(ai));
136     ai.ai_flags = AI_PASSIVE;
137     ai.ai_family = inet_ai_family_from_address(saddr, &err);
138     ai.ai_socktype = SOCK_STREAM;
139 
140     if (err) {
141         error_propagate(errp, err);
142         return -1;
143     }
144 
145     if (saddr->host == NULL) {
146         error_setg(errp, "host not specified");
147         return -1;
148     }
149     if (saddr->port != NULL) {
150         pstrcpy(port, sizeof(port), saddr->port);
151     } else {
152         port[0] = '\0';
153     }
154 
155     /* lookup */
156     if (port_offset) {
157         unsigned long long baseport;
158         if (strlen(port) == 0) {
159             error_setg(errp, "port not specified");
160             return -1;
161         }
162         if (parse_uint_full(port, &baseport, 10) < 0) {
163             error_setg(errp, "can't convert to a number: %s", port);
164             return -1;
165         }
166         if (baseport > 65535 ||
167             baseport + port_offset > 65535) {
168             error_setg(errp, "port %s out of range", port);
169             return -1;
170         }
171         snprintf(port, sizeof(port), "%d", (int)baseport + port_offset);
172     }
173     rc = getaddrinfo(strlen(saddr->host) ? saddr->host : NULL,
174                      strlen(port) ? port : NULL, &ai, &res);
175     if (rc != 0) {
176         error_setg(errp, "address resolution failed for %s:%s: %s",
177                    saddr->host, port, gai_strerror(rc));
178         return -1;
179     }
180 
181     /* create socket + bind */
182     for (e = res; e != NULL; e = e->ai_next) {
183         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
184 		        uaddr,INET6_ADDRSTRLEN,uport,32,
185 		        NI_NUMERICHOST | NI_NUMERICSERV);
186         slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
187         if (slisten < 0) {
188             if (!e->ai_next) {
189                 error_setg_errno(errp, errno, "Failed to create socket");
190             }
191             continue;
192         }
193 
194         socket_set_fast_reuse(slisten);
195 #ifdef IPV6_V6ONLY
196         if (e->ai_family == PF_INET6) {
197             /* listen on both ipv4 and ipv6 */
198             const int off = 0;
199             qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off,
200                             sizeof(off));
201         }
202 #endif
203 
204         port_min = inet_getport(e);
205         port_max = saddr->has_to ? saddr->to + port_offset : port_min;
206         for (p = port_min; p <= port_max; p++) {
207             inet_setport(e, p);
208             if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
209                 goto listen;
210             }
211             if (p == port_max) {
212                 if (!e->ai_next) {
213                     error_setg_errno(errp, errno, "Failed to bind socket");
214                 }
215             }
216         }
217         closesocket(slisten);
218     }
219     freeaddrinfo(res);
220     return -1;
221 
222 listen:
223     if (listen(slisten,1) != 0) {
224         error_setg_errno(errp, errno, "Failed to listen on socket");
225         closesocket(slisten);
226         freeaddrinfo(res);
227         return -1;
228     }
229     if (update_addr) {
230         g_free(saddr->host);
231         saddr->host = g_strdup(uaddr);
232         g_free(saddr->port);
233         saddr->port = g_strdup_printf("%d",
234                                       inet_getport(e) - port_offset);
235         saddr->has_ipv6 = saddr->ipv6 = e->ai_family == PF_INET6;
236         saddr->has_ipv4 = saddr->ipv4 = e->ai_family != PF_INET6;
237     }
238     freeaddrinfo(res);
239     return slisten;
240 }
241 
242 #ifdef _WIN32
243 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
244     ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
245 #else
246 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
247     ((rc) == -EINPROGRESS)
248 #endif
249 
250 /* Struct to store connect state for non blocking connect */
251 typedef struct ConnectState {
252     int fd;
253     struct addrinfo *addr_list;
254     struct addrinfo *current_addr;
255     NonBlockingConnectHandler *callback;
256     void *opaque;
257 } ConnectState;
258 
259 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
260                              ConnectState *connect_state, Error **errp);
261 
262 static void wait_for_connect(void *opaque)
263 {
264     ConnectState *s = opaque;
265     int val = 0, rc = 0;
266     socklen_t valsize = sizeof(val);
267     bool in_progress;
268     Error *err = NULL;
269 
270     qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
271 
272     do {
273         rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
274     } while (rc == -1 && errno == EINTR);
275 
276     /* update rc to contain error */
277     if (!rc && val) {
278         rc = -1;
279         errno = val;
280     }
281 
282     /* connect error */
283     if (rc < 0) {
284         error_setg_errno(&err, errno, "Error connecting to socket");
285         closesocket(s->fd);
286         s->fd = rc;
287     }
288 
289     /* try to connect to the next address on the list */
290     if (s->current_addr) {
291         while (s->current_addr->ai_next != NULL && s->fd < 0) {
292             s->current_addr = s->current_addr->ai_next;
293             s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
294             if (s->fd < 0) {
295                 error_free(err);
296                 err = NULL;
297                 error_setg_errno(&err, errno, "Unable to start socket connect");
298             }
299             /* connect in progress */
300             if (in_progress) {
301                 goto out;
302             }
303         }
304 
305         freeaddrinfo(s->addr_list);
306     }
307 
308     if (s->callback) {
309         s->callback(s->fd, err, s->opaque);
310     }
311     g_free(s);
312 out:
313     error_free(err);
314 }
315 
316 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
317                              ConnectState *connect_state, Error **errp)
318 {
319     int sock, rc;
320 
321     *in_progress = false;
322 
323     sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
324     if (sock < 0) {
325         error_setg_errno(errp, errno, "Failed to create socket");
326         return -1;
327     }
328     socket_set_fast_reuse(sock);
329     if (connect_state != NULL) {
330         qemu_set_nonblock(sock);
331     }
332     /* connect to peer */
333     do {
334         rc = 0;
335         if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
336             rc = -errno;
337         }
338     } while (rc == -EINTR);
339 
340     if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
341         connect_state->fd = sock;
342         qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
343         *in_progress = true;
344     } else if (rc < 0) {
345         error_setg_errno(errp, errno, "Failed to connect socket");
346         closesocket(sock);
347         return -1;
348     }
349     return sock;
350 }
351 
352 static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr,
353                                                  Error **errp)
354 {
355     struct addrinfo ai, *res;
356     int rc;
357     Error *err = NULL;
358     static int useV4Mapped = 1;
359 
360     memset(&ai, 0, sizeof(ai));
361 
362     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
363     if (atomic_read(&useV4Mapped)) {
364         ai.ai_flags |= AI_V4MAPPED;
365     }
366     ai.ai_family = inet_ai_family_from_address(saddr, &err);
367     ai.ai_socktype = SOCK_STREAM;
368 
369     if (err) {
370         error_propagate(errp, err);
371         return NULL;
372     }
373 
374     if (saddr->host == NULL || saddr->port == NULL) {
375         error_setg(errp, "host and/or port not specified");
376         return NULL;
377     }
378 
379     /* lookup */
380     rc = getaddrinfo(saddr->host, saddr->port, &ai, &res);
381 
382     /* At least FreeBSD and OS-X 10.6 declare AI_V4MAPPED but
383      * then don't implement it in their getaddrinfo(). Detect
384      * this and retry without the flag since that's preferrable
385      * to a fatal error
386      */
387     if (rc == EAI_BADFLAGS &&
388         (ai.ai_flags & AI_V4MAPPED)) {
389         atomic_set(&useV4Mapped, 0);
390         ai.ai_flags &= ~AI_V4MAPPED;
391         rc = getaddrinfo(saddr->host, saddr->port, &ai, &res);
392     }
393     if (rc != 0) {
394         error_setg(errp, "address resolution failed for %s:%s: %s",
395                    saddr->host, saddr->port, gai_strerror(rc));
396         return NULL;
397     }
398     return res;
399 }
400 
401 /**
402  * Create a socket and connect it to an address.
403  *
404  * @saddr: Inet socket address specification
405  * @errp: set on error
406  * @callback: callback function for non-blocking connect
407  * @opaque: opaque for callback function
408  *
409  * Returns: -1 on error, file descriptor on success.
410  *
411  * If @callback is non-null, the connect is non-blocking.  If this
412  * function succeeds, callback will be called when the connection
413  * completes, with the file descriptor on success, or -1 on error.
414  */
415 static int inet_connect_saddr(InetSocketAddress *saddr, Error **errp,
416                               NonBlockingConnectHandler *callback, void *opaque)
417 {
418     Error *local_err = NULL;
419     struct addrinfo *res, *e;
420     int sock = -1;
421     bool in_progress;
422     ConnectState *connect_state = NULL;
423 
424     res = inet_parse_connect_saddr(saddr, errp);
425     if (!res) {
426         return -1;
427     }
428 
429     if (callback != NULL) {
430         connect_state = g_malloc0(sizeof(*connect_state));
431         connect_state->addr_list = res;
432         connect_state->callback = callback;
433         connect_state->opaque = opaque;
434     }
435 
436     for (e = res; e != NULL; e = e->ai_next) {
437         error_free(local_err);
438         local_err = NULL;
439         if (connect_state != NULL) {
440             connect_state->current_addr = e;
441         }
442         sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
443         if (sock >= 0) {
444             break;
445         }
446     }
447 
448     if (sock < 0) {
449         error_propagate(errp, local_err);
450     } else if (in_progress) {
451         /* wait_for_connect() will do the rest */
452         return sock;
453     } else {
454         if (callback) {
455             callback(sock, NULL, opaque);
456         }
457     }
458     g_free(connect_state);
459     freeaddrinfo(res);
460     return sock;
461 }
462 
463 static int inet_dgram_saddr(InetSocketAddress *sraddr,
464                             InetSocketAddress *sladdr,
465                             Error **errp)
466 {
467     struct addrinfo ai, *peer = NULL, *local = NULL;
468     const char *addr;
469     const char *port;
470     int sock = -1, rc;
471     Error *err = NULL;
472 
473     /* lookup peer addr */
474     memset(&ai,0, sizeof(ai));
475     ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG;
476     ai.ai_family = inet_ai_family_from_address(sraddr, &err);
477     ai.ai_socktype = SOCK_DGRAM;
478 
479     if (err) {
480         error_propagate(errp, err);
481         goto err;
482     }
483 
484     addr = sraddr->host;
485     port = sraddr->port;
486     if (addr == NULL || strlen(addr) == 0) {
487         addr = "localhost";
488     }
489     if (port == NULL || strlen(port) == 0) {
490         error_setg(errp, "remote port not specified");
491         goto err;
492     }
493 
494     if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
495         error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
496                    gai_strerror(rc));
497 	goto err;
498     }
499 
500     /* lookup local addr */
501     memset(&ai,0, sizeof(ai));
502     ai.ai_flags = AI_PASSIVE;
503     ai.ai_family = peer->ai_family;
504     ai.ai_socktype = SOCK_DGRAM;
505 
506     if (sladdr) {
507         addr = sladdr->host;
508         port = sladdr->port;
509         if (addr == NULL || strlen(addr) == 0) {
510             addr = NULL;
511         }
512         if (!port || strlen(port) == 0) {
513             port = "0";
514         }
515     } else {
516         addr = NULL;
517         port = "0";
518     }
519 
520     if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
521         error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
522                    gai_strerror(rc));
523         goto err;
524     }
525 
526     /* create socket */
527     sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
528     if (sock < 0) {
529         error_setg_errno(errp, errno, "Failed to create socket");
530         goto err;
531     }
532     socket_set_fast_reuse(sock);
533 
534     /* bind socket */
535     if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
536         error_setg_errno(errp, errno, "Failed to bind socket");
537         goto err;
538     }
539 
540     /* connect to peer */
541     if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
542         error_setg_errno(errp, errno, "Failed to connect socket");
543         goto err;
544     }
545 
546     freeaddrinfo(local);
547     freeaddrinfo(peer);
548     return sock;
549 
550 err:
551     if (-1 != sock)
552         closesocket(sock);
553     if (local)
554         freeaddrinfo(local);
555     if (peer)
556         freeaddrinfo(peer);
557     return -1;
558 }
559 
560 /* compatibility wrapper */
561 InetSocketAddress *inet_parse(const char *str, Error **errp)
562 {
563     InetSocketAddress *addr;
564     const char *optstr, *h;
565     char host[65];
566     char port[33];
567     int to;
568     int pos;
569 
570     addr = g_new0(InetSocketAddress, 1);
571 
572     /* parse address */
573     if (str[0] == ':') {
574         /* no host given */
575         host[0] = '\0';
576         if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
577             error_setg(errp, "error parsing port in address '%s'", str);
578             goto fail;
579         }
580     } else if (str[0] == '[') {
581         /* IPv6 addr */
582         if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
583             error_setg(errp, "error parsing IPv6 address '%s'", str);
584             goto fail;
585         }
586         addr->ipv6 = addr->has_ipv6 = true;
587     } else {
588         /* hostname or IPv4 addr */
589         if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
590             error_setg(errp, "error parsing address '%s'", str);
591             goto fail;
592         }
593         if (host[strspn(host, "0123456789.")] == '\0') {
594             addr->ipv4 = addr->has_ipv4 = true;
595         }
596     }
597 
598     addr->host = g_strdup(host);
599     addr->port = g_strdup(port);
600 
601     /* parse options */
602     optstr = str + pos;
603     h = strstr(optstr, ",to=");
604     if (h) {
605         h += 4;
606         if (sscanf(h, "%d%n", &to, &pos) != 1 ||
607             (h[pos] != '\0' && h[pos] != ',')) {
608             error_setg(errp, "error parsing to= argument");
609             goto fail;
610         }
611         addr->has_to = true;
612         addr->to = to;
613     }
614     if (strstr(optstr, ",ipv4")) {
615         addr->ipv4 = addr->has_ipv4 = true;
616     }
617     if (strstr(optstr, ",ipv6")) {
618         addr->ipv6 = addr->has_ipv6 = true;
619     }
620     return addr;
621 
622 fail:
623     qapi_free_InetSocketAddress(addr);
624     return NULL;
625 }
626 
627 int inet_listen(const char *str, char *ostr, int olen,
628                 int socktype, int port_offset, Error **errp)
629 {
630     char *optstr;
631     int sock = -1;
632     InetSocketAddress *addr;
633 
634     addr = inet_parse(str, errp);
635     if (addr != NULL) {
636         sock = inet_listen_saddr(addr, port_offset, true, errp);
637         if (sock != -1 && ostr) {
638             optstr = strchr(str, ',');
639             if (addr->ipv6) {
640                 snprintf(ostr, olen, "[%s]:%s%s",
641                          addr->host,
642                          addr->port,
643                          optstr ? optstr : "");
644             } else {
645                 snprintf(ostr, olen, "%s:%s%s",
646                          addr->host,
647                          addr->port,
648                          optstr ? optstr : "");
649             }
650         }
651         qapi_free_InetSocketAddress(addr);
652     }
653     return sock;
654 }
655 
656 /**
657  * Create a blocking socket and connect it to an address.
658  *
659  * @str: address string
660  * @errp: set in case of an error
661  *
662  * Returns -1 in case of error, file descriptor on success
663  **/
664 int inet_connect(const char *str, Error **errp)
665 {
666     int sock = -1;
667     InetSocketAddress *addr;
668 
669     addr = inet_parse(str, errp);
670     if (addr != NULL) {
671         sock = inet_connect_saddr(addr, errp, NULL, NULL);
672         qapi_free_InetSocketAddress(addr);
673     }
674     return sock;
675 }
676 
677 /**
678  * Create a non-blocking socket and connect it to an address.
679  * Calls the callback function with fd in case of success or -1 in case of
680  * error.
681  *
682  * @str: address string
683  * @callback: callback function that is called when connect completes,
684  *            cannot be NULL.
685  * @opaque: opaque for callback function
686  * @errp: set in case of an error
687  *
688  * Returns: -1 on immediate error, file descriptor on success.
689  **/
690 int inet_nonblocking_connect(const char *str,
691                              NonBlockingConnectHandler *callback,
692                              void *opaque, Error **errp)
693 {
694     int sock = -1;
695     InetSocketAddress *addr;
696 
697     g_assert(callback != NULL);
698 
699     addr = inet_parse(str, errp);
700     if (addr != NULL) {
701         sock = inet_connect_saddr(addr, errp, callback, opaque);
702         qapi_free_InetSocketAddress(addr);
703     }
704     return sock;
705 }
706 
707 #ifndef _WIN32
708 
709 static int unix_listen_saddr(UnixSocketAddress *saddr,
710                              bool update_addr,
711                              Error **errp)
712 {
713     struct sockaddr_un un;
714     int sock, fd;
715 
716     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
717     if (sock < 0) {
718         error_setg_errno(errp, errno, "Failed to create Unix socket");
719         return -1;
720     }
721 
722     memset(&un, 0, sizeof(un));
723     un.sun_family = AF_UNIX;
724     if (saddr->path && strlen(saddr->path)) {
725         snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
726     } else {
727         const char *tmpdir = getenv("TMPDIR");
728         tmpdir = tmpdir ? tmpdir : "/tmp";
729         if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
730                      tmpdir) >= sizeof(un.sun_path)) {
731             error_setg_errno(errp, errno,
732                              "TMPDIR environment variable (%s) too large", tmpdir);
733             goto err;
734         }
735 
736         /*
737          * This dummy fd usage silences the mktemp() unsecure warning.
738          * Using mkstemp() doesn't make things more secure here
739          * though.  bind() complains about existing files, so we have
740          * to unlink first and thus re-open the race window.  The
741          * worst case possible is bind() failing, i.e. a DoS attack.
742          */
743         fd = mkstemp(un.sun_path);
744         if (fd < 0) {
745             error_setg_errno(errp, errno,
746                              "Failed to make a temporary socket name in %s", tmpdir);
747             goto err;
748         }
749         close(fd);
750         if (update_addr) {
751             g_free(saddr->path);
752             saddr->path = g_strdup(un.sun_path);
753         }
754     }
755 
756     if (unlink(un.sun_path) < 0 && errno != ENOENT) {
757         error_setg_errno(errp, errno,
758                          "Failed to unlink socket %s", un.sun_path);
759         goto err;
760     }
761     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
762         error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path);
763         goto err;
764     }
765     if (listen(sock, 1) < 0) {
766         error_setg_errno(errp, errno, "Failed to listen on socket");
767         goto err;
768     }
769 
770     return sock;
771 
772 err:
773     closesocket(sock);
774     return -1;
775 }
776 
777 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp,
778                               NonBlockingConnectHandler *callback, void *opaque)
779 {
780     struct sockaddr_un un;
781     ConnectState *connect_state = NULL;
782     int sock, rc;
783 
784     if (saddr->path == NULL) {
785         error_setg(errp, "unix connect: no path specified");
786         return -1;
787     }
788 
789     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
790     if (sock < 0) {
791         error_setg_errno(errp, errno, "Failed to create socket");
792         return -1;
793     }
794     if (callback != NULL) {
795         connect_state = g_malloc0(sizeof(*connect_state));
796         connect_state->callback = callback;
797         connect_state->opaque = opaque;
798         qemu_set_nonblock(sock);
799     }
800 
801     memset(&un, 0, sizeof(un));
802     un.sun_family = AF_UNIX;
803     snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
804 
805     /* connect to peer */
806     do {
807         rc = 0;
808         if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
809             rc = -errno;
810         }
811     } while (rc == -EINTR);
812 
813     if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
814         connect_state->fd = sock;
815         qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
816         return sock;
817     } else if (rc >= 0) {
818         /* non blocking socket immediate success, call callback */
819         if (callback != NULL) {
820             callback(sock, NULL, opaque);
821         }
822     }
823 
824     if (rc < 0) {
825         error_setg_errno(errp, -rc, "Failed to connect socket");
826         close(sock);
827         sock = -1;
828     }
829 
830     g_free(connect_state);
831     return sock;
832 }
833 
834 #else
835 
836 static int unix_listen_saddr(UnixSocketAddress *saddr,
837                              bool update_addr,
838                              Error **errp)
839 {
840     error_setg(errp, "unix sockets are not available on windows");
841     errno = ENOTSUP;
842     return -1;
843 }
844 
845 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp,
846                               NonBlockingConnectHandler *callback, void *opaque)
847 {
848     error_setg(errp, "unix sockets are not available on windows");
849     errno = ENOTSUP;
850     return -1;
851 }
852 #endif
853 
854 /* compatibility wrapper */
855 int unix_listen(const char *str, char *ostr, int olen, Error **errp)
856 {
857     char *path, *optstr;
858     int sock, len;
859     UnixSocketAddress *saddr;
860 
861     saddr = g_new0(UnixSocketAddress, 1);
862 
863     optstr = strchr(str, ',');
864     if (optstr) {
865         len = optstr - str;
866         if (len) {
867             path = g_malloc(len+1);
868             snprintf(path, len+1, "%.*s", len, str);
869             saddr->path = path;
870         }
871     } else {
872         saddr->path = g_strdup(str);
873     }
874 
875     sock = unix_listen_saddr(saddr, true, errp);
876 
877     if (sock != -1 && ostr)
878         snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : "");
879     qapi_free_UnixSocketAddress(saddr);
880     return sock;
881 }
882 
883 int unix_connect(const char *path, Error **errp)
884 {
885     UnixSocketAddress *saddr;
886     int sock;
887 
888     saddr = g_new0(UnixSocketAddress, 1);
889     saddr->path = g_strdup(path);
890     sock = unix_connect_saddr(saddr, errp, NULL, NULL);
891     qapi_free_UnixSocketAddress(saddr);
892     return sock;
893 }
894 
895 
896 int unix_nonblocking_connect(const char *path,
897                              NonBlockingConnectHandler *callback,
898                              void *opaque, Error **errp)
899 {
900     UnixSocketAddress *saddr;
901     int sock = -1;
902 
903     g_assert(callback != NULL);
904 
905     saddr = g_new0(UnixSocketAddress, 1);
906     saddr->path = g_strdup(path);
907     sock = unix_connect_saddr(saddr, errp, callback, opaque);
908     qapi_free_UnixSocketAddress(saddr);
909     return sock;
910 }
911 
912 SocketAddress *socket_parse(const char *str, Error **errp)
913 {
914     SocketAddress *addr;
915 
916     addr = g_new0(SocketAddress, 1);
917     if (strstart(str, "unix:", NULL)) {
918         if (str[5] == '\0') {
919             error_setg(errp, "invalid Unix socket address");
920             goto fail;
921         } else {
922             addr->type = SOCKET_ADDRESS_KIND_UNIX;
923             addr->u.q_unix.data = g_new(UnixSocketAddress, 1);
924             addr->u.q_unix.data->path = g_strdup(str + 5);
925         }
926     } else if (strstart(str, "fd:", NULL)) {
927         if (str[3] == '\0') {
928             error_setg(errp, "invalid file descriptor address");
929             goto fail;
930         } else {
931             addr->type = SOCKET_ADDRESS_KIND_FD;
932             addr->u.fd.data = g_new(String, 1);
933             addr->u.fd.data->str = g_strdup(str + 3);
934         }
935     } else {
936         addr->type = SOCKET_ADDRESS_KIND_INET;
937         addr->u.inet.data = inet_parse(str, errp);
938         if (addr->u.inet.data == NULL) {
939             goto fail;
940         }
941     }
942     return addr;
943 
944 fail:
945     qapi_free_SocketAddress(addr);
946     return NULL;
947 }
948 
949 int socket_connect(SocketAddress *addr, Error **errp,
950                    NonBlockingConnectHandler *callback, void *opaque)
951 {
952     int fd;
953 
954     switch (addr->type) {
955     case SOCKET_ADDRESS_KIND_INET:
956         fd = inet_connect_saddr(addr->u.inet.data, errp, callback, opaque);
957         break;
958 
959     case SOCKET_ADDRESS_KIND_UNIX:
960         fd = unix_connect_saddr(addr->u.q_unix.data, errp, callback, opaque);
961         break;
962 
963     case SOCKET_ADDRESS_KIND_FD:
964         fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
965         if (fd >= 0 && callback) {
966             qemu_set_nonblock(fd);
967             callback(fd, NULL, opaque);
968         }
969         break;
970 
971     default:
972         abort();
973     }
974     return fd;
975 }
976 
977 int socket_listen(SocketAddress *addr, Error **errp)
978 {
979     int fd;
980 
981     switch (addr->type) {
982     case SOCKET_ADDRESS_KIND_INET:
983         fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp);
984         break;
985 
986     case SOCKET_ADDRESS_KIND_UNIX:
987         fd = unix_listen_saddr(addr->u.q_unix.data, false, errp);
988         break;
989 
990     case SOCKET_ADDRESS_KIND_FD:
991         fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
992         break;
993 
994     default:
995         abort();
996     }
997     return fd;
998 }
999 
1000 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
1001 {
1002     int fd;
1003 
1004     switch (remote->type) {
1005     case SOCKET_ADDRESS_KIND_INET:
1006         fd = inet_dgram_saddr(remote->u.inet.data,
1007                               local ? local->u.inet.data : NULL, errp);
1008         break;
1009 
1010     default:
1011         error_setg(errp, "socket type unsupported for datagram");
1012         fd = -1;
1013     }
1014     return fd;
1015 }
1016 
1017 
1018 static SocketAddress *
1019 socket_sockaddr_to_address_inet(struct sockaddr_storage *sa,
1020                                 socklen_t salen,
1021                                 Error **errp)
1022 {
1023     char host[NI_MAXHOST];
1024     char serv[NI_MAXSERV];
1025     SocketAddress *addr;
1026     InetSocketAddress *inet;
1027     int ret;
1028 
1029     ret = getnameinfo((struct sockaddr *)sa, salen,
1030                       host, sizeof(host),
1031                       serv, sizeof(serv),
1032                       NI_NUMERICHOST | NI_NUMERICSERV);
1033     if (ret != 0) {
1034         error_setg(errp, "Cannot format numeric socket address: %s",
1035                    gai_strerror(ret));
1036         return NULL;
1037     }
1038 
1039     addr = g_new0(SocketAddress, 1);
1040     addr->type = SOCKET_ADDRESS_KIND_INET;
1041     inet = addr->u.inet.data = g_new0(InetSocketAddress, 1);
1042     inet->host = g_strdup(host);
1043     inet->port = g_strdup(serv);
1044     if (sa->ss_family == AF_INET) {
1045         inet->has_ipv4 = inet->ipv4 = true;
1046     } else {
1047         inet->has_ipv6 = inet->ipv6 = true;
1048     }
1049 
1050     return addr;
1051 }
1052 
1053 
1054 #ifndef WIN32
1055 static SocketAddress *
1056 socket_sockaddr_to_address_unix(struct sockaddr_storage *sa,
1057                                 socklen_t salen,
1058                                 Error **errp)
1059 {
1060     SocketAddress *addr;
1061     struct sockaddr_un *su = (struct sockaddr_un *)sa;
1062 
1063     addr = g_new0(SocketAddress, 1);
1064     addr->type = SOCKET_ADDRESS_KIND_UNIX;
1065     addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
1066     if (su->sun_path[0]) {
1067         addr->u.q_unix.data->path = g_strndup(su->sun_path,
1068                                               sizeof(su->sun_path));
1069     }
1070 
1071     return addr;
1072 }
1073 #endif /* WIN32 */
1074 
1075 SocketAddress *
1076 socket_sockaddr_to_address(struct sockaddr_storage *sa,
1077                            socklen_t salen,
1078                            Error **errp)
1079 {
1080     switch (sa->ss_family) {
1081     case AF_INET:
1082     case AF_INET6:
1083         return socket_sockaddr_to_address_inet(sa, salen, errp);
1084 
1085 #ifndef WIN32
1086     case AF_UNIX:
1087         return socket_sockaddr_to_address_unix(sa, salen, errp);
1088 #endif /* WIN32 */
1089 
1090     default:
1091         error_setg(errp, "socket family %d unsupported",
1092                    sa->ss_family);
1093         return NULL;
1094     }
1095     return 0;
1096 }
1097 
1098 
1099 SocketAddress *socket_local_address(int fd, Error **errp)
1100 {
1101     struct sockaddr_storage ss;
1102     socklen_t sslen = sizeof(ss);
1103 
1104     if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) {
1105         error_setg_errno(errp, errno, "%s",
1106                          "Unable to query local socket address");
1107         return NULL;
1108     }
1109 
1110     return socket_sockaddr_to_address(&ss, sslen, errp);
1111 }
1112 
1113 
1114 SocketAddress *socket_remote_address(int fd, Error **errp)
1115 {
1116     struct sockaddr_storage ss;
1117     socklen_t sslen = sizeof(ss);
1118 
1119     if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) {
1120         error_setg_errno(errp, errno, "%s",
1121                          "Unable to query remote socket address");
1122         return NULL;
1123     }
1124 
1125     return socket_sockaddr_to_address(&ss, sslen, errp);
1126 }
1127 
1128 
1129 void qapi_copy_SocketAddress(SocketAddress **p_dest,
1130                              SocketAddress *src)
1131 {
1132     QmpOutputVisitor *qov;
1133     QmpInputVisitor *qiv;
1134     Visitor *ov, *iv;
1135     QObject *obj;
1136 
1137     *p_dest = NULL;
1138 
1139     qov = qmp_output_visitor_new();
1140     ov = qmp_output_get_visitor(qov);
1141     visit_type_SocketAddress(ov, NULL, &src, &error_abort);
1142     obj = qmp_output_get_qobject(qov);
1143     qmp_output_visitor_cleanup(qov);
1144     if (!obj) {
1145         return;
1146     }
1147 
1148     qiv = qmp_input_visitor_new(obj);
1149     iv = qmp_input_get_visitor(qiv);
1150     visit_type_SocketAddress(iv, NULL, p_dest, &error_abort);
1151     qmp_input_visitor_cleanup(qiv);
1152     qobject_decref(obj);
1153 }
1154