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