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