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