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