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