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