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