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 InetSocketAddress *inet_parse(const char *str, Error **errp)
 582 {
 583     InetSocketAddress *addr;
 584     const char *optstr, *h;
 585     char host[65];
 586     char port[33];
 587     int to;
 588     int pos;
 589
 590     addr = g_new0(InetSocketAddress, 1);
 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             goto fail;
 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             goto fail;
 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             goto fail;
 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             goto fail;
 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 addr;
 641
 642 fail:
 643     qapi_free_InetSocketAddress(addr);
 644     return NULL;
 645 }
 646
 647
 648 /**
 649  * Create a blocking socket and connect it to an address.
 650  *
 651  * @str: address string
 652  * @errp: set in case of an error
 653  *
 654  * Returns -1 in case of error, file descriptor on success
 655  **/
 656 int inet_connect(const char *str, Error **errp)
 657 {
 658     int sock = -1;
 659     InetSocketAddress *addr;
 660
 661     addr = inet_parse(str, errp);
 662     if (addr != NULL) {
 663         sock = inet_connect_saddr(addr, NULL, NULL, errp);
 664         qapi_free_InetSocketAddress(addr);
 665     }
 666     return sock;
 667 }
 668
 669 #ifdef CONFIG_AF_VSOCK
 670 static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr,
 671                                           struct sockaddr_vm *svm,
 672                                           Error **errp)
 673 {
 674     unsigned long long val;
 675
 676     memset(svm, 0, sizeof(*svm));
 677     svm->svm_family = AF_VSOCK;
 678
 679     if (parse_uint_full(vaddr->cid, &val, 10) < 0 ||
 680         val > UINT32_MAX) {
 681         error_setg(errp, "Failed to parse cid '%s'", vaddr->cid);
 682         return false;
 683     }
 684     svm->svm_cid = val;
 685
 686     if (parse_uint_full(vaddr->port, &val, 10) < 0 ||
 687         val > UINT32_MAX) {
 688         error_setg(errp, "Failed to parse port '%s'", vaddr->port);
 689         return false;
 690     }
 691     svm->svm_port = val;
 692
 693     return true;
 694 }
 695
 696 static int vsock_connect_addr(const struct sockaddr_vm *svm, bool *in_progress,
 697                               ConnectState *connect_state, Error **errp)
 698 {
 699     int sock, rc;
 700
 701     *in_progress = false;
 702
 703     sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0);
 704     if (sock < 0) {
 705         error_setg_errno(errp, errno, "Failed to create socket");
 706         return -1;
 707     }
 708     if (connect_state != NULL) {
 709         qemu_set_nonblock(sock);
 710     }
 711     /* connect to peer */
 712     do {
 713         rc = 0;
 714         if (connect(sock, (const struct sockaddr *)svm, sizeof(*svm)) < 0) {
 715             rc = -errno;
 716         }
 717     } while (rc == -EINTR);
 718
 719     if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
 720         connect_state->fd = sock;
 721         qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
 722         *in_progress = true;
 723     } else if (rc < 0) {
 724         error_setg_errno(errp, errno, "Failed to connect socket");
 725         closesocket(sock);
 726         return -1;
 727     }
 728     return sock;
 729 }
 730
 731 static int vsock_connect_saddr(VsockSocketAddress *vaddr,
 732                                NonBlockingConnectHandler *callback,
 733                                void *opaque,
 734                                Error **errp)
 735 {
 736     struct sockaddr_vm svm;
 737     int sock = -1;
 738     bool in_progress;
 739     ConnectState *connect_state = NULL;
 740
 741     if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) {
 742         return -1;
 743     }
 744
 745     if (callback != NULL) {
 746         connect_state = g_malloc0(sizeof(*connect_state));
 747         connect_state->callback = callback;
 748         connect_state->opaque = opaque;
 749     }
 750
 751     sock = vsock_connect_addr(&svm, &in_progress, connect_state, errp);
 752     if (sock < 0) {
 753         /* do nothing */
 754     } else if (in_progress) {
 755         /* wait_for_connect() will do the rest */
 756         return sock;
 757     } else {
 758         if (callback) {
 759             callback(sock, NULL, opaque);
 760         }
 761     }
 762     g_free(connect_state);
 763     return sock;
 764 }
 765
 766 static int vsock_listen_saddr(VsockSocketAddress *vaddr,
 767                               Error **errp)
 768 {
 769     struct sockaddr_vm svm;
 770     int slisten;
 771
 772     if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) {
 773         return -1;
 774     }
 775
 776     slisten = qemu_socket(AF_VSOCK, SOCK_STREAM, 0);
 777     if (slisten < 0) {
 778         error_setg_errno(errp, errno, "Failed to create socket");
 779         return -1;
 780     }
 781
 782     if (bind(slisten, (const struct sockaddr *)&svm, sizeof(svm)) != 0) {
 783         error_setg_errno(errp, errno, "Failed to bind socket");
 784         closesocket(slisten);
 785         return -1;
 786     }
 787
 788     if (listen(slisten, 1) != 0) {
 789         error_setg_errno(errp, errno, "Failed to listen on socket");
 790         closesocket(slisten);
 791         return -1;
 792     }
 793     return slisten;
 794 }
 795
 796 static VsockSocketAddress *vsock_parse(const char *str, Error **errp)
 797 {
 798     VsockSocketAddress *addr = NULL;
 799     char cid[33];
 800     char port[33];
 801     int n;
 802
 803     if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) {
 804         error_setg(errp, "error parsing address '%s'", str);
 805         return NULL;
 806     }
 807     if (str[n] != '\0') {
 808         error_setg(errp, "trailing characters in address '%s'", str);
 809         return NULL;
 810     }
 811
 812     addr = g_new0(VsockSocketAddress, 1);
 813     addr->cid = g_strdup(cid);
 814     addr->port = g_strdup(port);
 815     return addr;
 816 }
 817 #else
 818 static void vsock_unsupported(Error **errp)
 819 {
 820     error_setg(errp, "socket family AF_VSOCK unsupported");
 821 }
 822
 823 static int vsock_connect_saddr(VsockSocketAddress *vaddr,
 824                                NonBlockingConnectHandler *callback,
 825                                void *opaque, Error **errp)
 826 {
 827     vsock_unsupported(errp);
 828     return -1;
 829 }
 830
 831 static int vsock_listen_saddr(VsockSocketAddress *vaddr,
 832                               Error **errp)
 833 {
 834     vsock_unsupported(errp);
 835     return -1;
 836 }
 837
 838 static VsockSocketAddress *vsock_parse(const char *str, Error **errp)
 839 {
 840     vsock_unsupported(errp);
 841     return NULL;
 842 }
 843 #endif /* CONFIG_AF_VSOCK */
 844
 845 #ifndef _WIN32
 846
 847 static int unix_listen_saddr(UnixSocketAddress *saddr,
 848                              bool update_addr,
 849                              Error **errp)
 850 {
 851     struct sockaddr_un un;
 852     int sock, fd;
 853
 854     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 855     if (sock < 0) {
 856         error_setg_errno(errp, errno, "Failed to create Unix socket");
 857         return -1;
 858     }
 859
 860     memset(&un, 0, sizeof(un));
 861     un.sun_family = AF_UNIX;
 862     if (saddr->path && strlen(saddr->path)) {
 863         snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
 864     } else {
 865         const char *tmpdir = getenv("TMPDIR");
 866         tmpdir = tmpdir ? tmpdir : "/tmp";
 867         if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
 868                      tmpdir) >= sizeof(un.sun_path)) {
 869             error_setg_errno(errp, errno,
 870                              "TMPDIR environment variable (%s) too large", tmpdir);
 871             goto err;
 872         }
 873
 874         /*
 875          * This dummy fd usage silences the mktemp() unsecure warning.
 876          * Using mkstemp() doesn't make things more secure here
 877          * though.  bind() complains about existing files, so we have
 878          * to unlink first and thus re-open the race window.  The
 879          * worst case possible is bind() failing, i.e. a DoS attack.
 880          */
 881         fd = mkstemp(un.sun_path);
 882         if (fd < 0) {
 883             error_setg_errno(errp, errno,
 884                              "Failed to make a temporary socket name in %s", tmpdir);
 885             goto err;
 886         }
 887         close(fd);
 888         if (update_addr) {
 889             g_free(saddr->path);
 890             saddr->path = g_strdup(un.sun_path);
 891         }
 892     }
 893
 894     if (unlink(un.sun_path) < 0 && errno != ENOENT) {
 895         error_setg_errno(errp, errno,
 896                          "Failed to unlink socket %s", un.sun_path);
 897         goto err;
 898     }
 899     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
 900         error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_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     return sock;
 909
 910 err:
 911     closesocket(sock);
 912     return -1;
 913 }
 914
 915 static int unix_connect_saddr(UnixSocketAddress *saddr,
 916                               NonBlockingConnectHandler *callback, void *opaque,
 917                               Error **errp)
 918 {
 919     struct sockaddr_un un;
 920     ConnectState *connect_state = NULL;
 921     int sock, rc;
 922
 923     if (saddr->path == NULL) {
 924         error_setg(errp, "unix connect: no path specified");
 925         return -1;
 926     }
 927
 928     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 929     if (sock < 0) {
 930         error_setg_errno(errp, errno, "Failed to create socket");
 931         return -1;
 932     }
 933     if (callback != NULL) {
 934         connect_state = g_malloc0(sizeof(*connect_state));
 935         connect_state->callback = callback;
 936         connect_state->opaque = opaque;
 937         qemu_set_nonblock(sock);
 938     }
 939
 940     memset(&un, 0, sizeof(un));
 941     un.sun_family = AF_UNIX;
 942     snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
 943
 944     /* connect to peer */
 945     do {
 946         rc = 0;
 947         if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
 948             rc = -errno;
 949         }
 950     } while (rc == -EINTR);
 951
 952     if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
 953         connect_state->fd = sock;
 954         qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
 955         return sock;
 956     } else if (rc >= 0) {
 957         /* non blocking socket immediate success, call callback */
 958         if (callback != NULL) {
 959             callback(sock, NULL, opaque);
 960         }
 961     }
 962
 963     if (rc < 0) {
 964         error_setg_errno(errp, -rc, "Failed to connect socket");
 965         close(sock);
 966         sock = -1;
 967     }
 968
 969     g_free(connect_state);
 970     return sock;
 971 }
 972
 973 #else
 974
 975 static int unix_listen_saddr(UnixSocketAddress *saddr,
 976                              bool update_addr,
 977                              Error **errp)
 978 {
 979     error_setg(errp, "unix sockets are not available on windows");
 980     errno = ENOTSUP;
 981     return -1;
 982 }
 983
 984 static int unix_connect_saddr(UnixSocketAddress *saddr,
 985                               NonBlockingConnectHandler *callback, void *opaque,
 986                               Error **errp)
 987 {
 988     error_setg(errp, "unix sockets are not available on windows");
 989     errno = ENOTSUP;
 990     return -1;
 991 }
 992 #endif
 993
 994 /* compatibility wrapper */
 995 int unix_listen(const char *str, char *ostr, int olen, Error **errp)
 996 {
 997     char *path, *optstr;
 998     int sock, len;
 999     UnixSocketAddress *saddr;
1000
1001     saddr = g_new0(UnixSocketAddress, 1);
1002
1003     optstr = strchr(str, ',');
1004     if (optstr) {
1005         len = optstr - str;
1006         if (len) {
1007             path = g_malloc(len+1);
1008             snprintf(path, len+1, "%.*s", len, str);
1009             saddr->path = path;
1010         }
1011     } else {
1012         saddr->path = g_strdup(str);
1013     }
1014
1015     sock = unix_listen_saddr(saddr, true, errp);
1016
1017     if (sock != -1 && ostr) {
1018         snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : "");
1019     }
1020
1021     qapi_free_UnixSocketAddress(saddr);
1022     return sock;
1023 }
1024
1025 int unix_connect(const char *path, Error **errp)
1026 {
1027     UnixSocketAddress *saddr;
1028     int sock;
1029
1030     saddr = g_new0(UnixSocketAddress, 1);
1031     saddr->path = g_strdup(path);
1032     sock = unix_connect_saddr(saddr, NULL, NULL, errp);
1033     qapi_free_UnixSocketAddress(saddr);
1034     return sock;
1035 }
1036
1037
1038 SocketAddress *socket_parse(const char *str, Error **errp)
1039 {
1040     SocketAddress *addr;
1041
1042     addr = g_new0(SocketAddress, 1);
1043     if (strstart(str, "unix:", NULL)) {
1044         if (str[5] == '\0') {
1045             error_setg(errp, "invalid Unix socket address");
1046             goto fail;
1047         } else {
1048             addr->type = SOCKET_ADDRESS_KIND_UNIX;
1049             addr->u.q_unix.data = g_new(UnixSocketAddress, 1);
1050             addr->u.q_unix.data->path = g_strdup(str + 5);
1051         }
1052     } else if (strstart(str, "fd:", NULL)) {
1053         if (str[3] == '\0') {
1054             error_setg(errp, "invalid file descriptor address");
1055             goto fail;
1056         } else {
1057             addr->type = SOCKET_ADDRESS_KIND_FD;
1058             addr->u.fd.data = g_new(String, 1);
1059             addr->u.fd.data->str = g_strdup(str + 3);
1060         }
1061     } else if (strstart(str, "vsock:", NULL)) {
1062         addr->type = SOCKET_ADDRESS_KIND_VSOCK;
1063         addr->u.vsock.data = vsock_parse(str + strlen("vsock:"), errp);
1064         if (addr->u.vsock.data == NULL) {
1065             goto fail;
1066         }
1067     } else {
1068         addr->type = SOCKET_ADDRESS_KIND_INET;
1069         addr->u.inet.data = inet_parse(str, errp);
1070         if (addr->u.inet.data == NULL) {
1071             goto fail;
1072         }
1073     }
1074     return addr;
1075
1076 fail:
1077     qapi_free_SocketAddress(addr);
1078     return NULL;
1079 }
1080
1081 int socket_connect(SocketAddress *addr, NonBlockingConnectHandler *callback,
1082                    void *opaque, Error **errp)
1083 {
1084     int fd;
1085
1086     switch (addr->type) {
1087     case SOCKET_ADDRESS_KIND_INET:
1088         fd = inet_connect_saddr(addr->u.inet.data, callback, opaque, errp);
1089         break;
1090
1091     case SOCKET_ADDRESS_KIND_UNIX:
1092         fd = unix_connect_saddr(addr->u.q_unix.data, callback, opaque, errp);
1093         break;
1094
1095     case SOCKET_ADDRESS_KIND_FD:
1096         fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
1097         if (fd >= 0 && callback) {
1098             qemu_set_nonblock(fd);
1099             callback(fd, NULL, opaque);
1100         }
1101         break;
1102
1103     case SOCKET_ADDRESS_KIND_VSOCK:
1104         fd = vsock_connect_saddr(addr->u.vsock.data, callback, opaque, errp);
1105         break;
1106
1107     default:
1108         abort();
1109     }
1110     return fd;
1111 }
1112
1113 int socket_listen(SocketAddress *addr, Error **errp)
1114 {
1115     int fd;
1116
1117     switch (addr->type) {
1118     case SOCKET_ADDRESS_KIND_INET:
1119         fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp);
1120         break;
1121
1122     case SOCKET_ADDRESS_KIND_UNIX:
1123         fd = unix_listen_saddr(addr->u.q_unix.data, false, errp);
1124         break;
1125
1126     case SOCKET_ADDRESS_KIND_FD:
1127         fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
1128         break;
1129
1130     case SOCKET_ADDRESS_KIND_VSOCK:
1131         fd = vsock_listen_saddr(addr->u.vsock.data, errp);
1132         break;
1133
1134     default:
1135         abort();
1136     }
1137     return fd;
1138 }
1139
1140 void socket_listen_cleanup(int fd, Error **errp)
1141 {
1142     SocketAddress *addr;
1143
1144     addr = socket_local_address(fd, errp);
1145
1146     if (addr->type == SOCKET_ADDRESS_KIND_UNIX
1147         && addr->u.q_unix.data->path) {
1148         if (unlink(addr->u.q_unix.data->path) < 0 && errno != ENOENT) {
1149             error_setg_errno(errp, errno,
1150                              "Failed to unlink socket %s",
1151                              addr->u.q_unix.data->path);
1152         }
1153     }
1154
1155     qapi_free_SocketAddress(addr);
1156 }
1157
1158 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
1159 {
1160     int fd;
1161
1162     /*
1163      * TODO SOCKET_ADDRESS_KIND_FD when fd is AF_INET or AF_INET6
1164      * (although other address families can do SOCK_DGRAM, too)
1165      */
1166     switch (remote->type) {
1167     case SOCKET_ADDRESS_KIND_INET:
1168         fd = inet_dgram_saddr(remote->u.inet.data,
1169                               local ? local->u.inet.data : NULL, errp);
1170         break;
1171
1172     default:
1173         error_setg(errp, "socket type unsupported for datagram");
1174         fd = -1;
1175     }
1176     return fd;
1177 }
1178
1179
1180 static SocketAddress *
1181 socket_sockaddr_to_address_inet(struct sockaddr_storage *sa,
1182                                 socklen_t salen,
1183                                 Error **errp)
1184 {
1185     char host[NI_MAXHOST];
1186     char serv[NI_MAXSERV];
1187     SocketAddress *addr;
1188     InetSocketAddress *inet;
1189     int ret;
1190
1191     ret = getnameinfo((struct sockaddr *)sa, salen,
1192                       host, sizeof(host),
1193                       serv, sizeof(serv),
1194                       NI_NUMERICHOST | NI_NUMERICSERV);
1195     if (ret != 0) {
1196         error_setg(errp, "Cannot format numeric socket address: %s",
1197                    gai_strerror(ret));
1198         return NULL;
1199     }
1200
1201     addr = g_new0(SocketAddress, 1);
1202     addr->type = SOCKET_ADDRESS_KIND_INET;
1203     inet = addr->u.inet.data = g_new0(InetSocketAddress, 1);
1204     inet->host = g_strdup(host);
1205     inet->port = g_strdup(serv);
1206     if (sa->ss_family == AF_INET) {
1207         inet->has_ipv4 = inet->ipv4 = true;
1208     } else {
1209         inet->has_ipv6 = inet->ipv6 = true;
1210     }
1211
1212     return addr;
1213 }
1214
1215
1216 #ifndef WIN32
1217 static SocketAddress *
1218 socket_sockaddr_to_address_unix(struct sockaddr_storage *sa,
1219                                 socklen_t salen,
1220                                 Error **errp)
1221 {
1222     SocketAddress *addr;
1223     struct sockaddr_un *su = (struct sockaddr_un *)sa;
1224
1225     addr = g_new0(SocketAddress, 1);
1226     addr->type = SOCKET_ADDRESS_KIND_UNIX;
1227     addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
1228     if (su->sun_path[0]) {
1229         addr->u.q_unix.data->path = g_strndup(su->sun_path,
1230                                               sizeof(su->sun_path));
1231     }
1232
1233     return addr;
1234 }
1235 #endif /* WIN32 */
1236
1237 #ifdef CONFIG_AF_VSOCK
1238 static SocketAddress *
1239 socket_sockaddr_to_address_vsock(struct sockaddr_storage *sa,
1240                                  socklen_t salen,
1241                                  Error **errp)
1242 {
1243     SocketAddress *addr;
1244     VsockSocketAddress *vaddr;
1245     struct sockaddr_vm *svm = (struct sockaddr_vm *)sa;
1246
1247     addr = g_new0(SocketAddress, 1);
1248     addr->type = SOCKET_ADDRESS_KIND_VSOCK;
1249     addr->u.vsock.data = vaddr = g_new0(VsockSocketAddress, 1);
1250     vaddr->cid = g_strdup_printf("%u", svm->svm_cid);
1251     vaddr->port = g_strdup_printf("%u", svm->svm_port);
1252
1253     return addr;
1254 }
1255 #endif /* CONFIG_AF_VSOCK */
1256
1257 SocketAddress *
1258 socket_sockaddr_to_address(struct sockaddr_storage *sa,
1259                            socklen_t salen,
1260                            Error **errp)
1261 {
1262     switch (sa->ss_family) {
1263     case AF_INET:
1264     case AF_INET6:
1265         return socket_sockaddr_to_address_inet(sa, salen, errp);
1266
1267 #ifndef WIN32
1268     case AF_UNIX:
1269         return socket_sockaddr_to_address_unix(sa, salen, errp);
1270 #endif /* WIN32 */
1271
1272 #ifdef CONFIG_AF_VSOCK
1273     case AF_VSOCK:
1274         return socket_sockaddr_to_address_vsock(sa, salen, errp);
1275 #endif
1276
1277     default:
1278         error_setg(errp, "socket family %d unsupported",
1279                    sa->ss_family);
1280         return NULL;
1281     }
1282     return 0;
1283 }
1284
1285
1286 SocketAddress *socket_local_address(int fd, Error **errp)
1287 {
1288     struct sockaddr_storage ss;
1289     socklen_t sslen = sizeof(ss);
1290
1291     if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) {
1292         error_setg_errno(errp, errno, "%s",
1293                          "Unable to query local socket address");
1294         return NULL;
1295     }
1296
1297     return socket_sockaddr_to_address(&ss, sslen, errp);
1298 }
1299
1300
1301 SocketAddress *socket_remote_address(int fd, Error **errp)
1302 {
1303     struct sockaddr_storage ss;
1304     socklen_t sslen = sizeof(ss);
1305
1306     if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) {
1307         error_setg_errno(errp, errno, "%s",
1308                          "Unable to query remote socket address");
1309         return NULL;
1310     }
1311
1312     return socket_sockaddr_to_address(&ss, sslen, errp);
1313 }
1314
1315 char *socket_address_to_string(struct SocketAddress *addr, Error **errp)
1316 {
1317     char *buf;
1318     InetSocketAddress *inet;
1319
1320     switch (addr->type) {
1321     case SOCKET_ADDRESS_KIND_INET:
1322         inet = addr->u.inet.data;
1323         if (strchr(inet->host, ':') == NULL) {
1324             buf = g_strdup_printf("%s:%s", inet->host, inet->port);
1325         } else {
1326             buf = g_strdup_printf("[%s]:%s", inet->host, inet->port);
1327         }
1328         break;
1329
1330     case SOCKET_ADDRESS_KIND_UNIX:
1331         buf = g_strdup(addr->u.q_unix.data->path);
1332         break;
1333
1334     case SOCKET_ADDRESS_KIND_FD:
1335         buf = g_strdup(addr->u.fd.data->str);
1336         break;
1337
1338     case SOCKET_ADDRESS_KIND_VSOCK:
1339         buf = g_strdup_printf("%s:%s",
1340                               addr->u.vsock.data->cid,
1341                               addr->u.vsock.data->port);
1342         break;
1343
1344     default:
1345         abort();
1346     }
1347     return buf;
1348 }
1349
1350 SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat)
1351 {
1352     SocketAddress *addr = g_new(SocketAddress, 1);
1353
1354     switch (addr_flat->type) {
1355     case SOCKET_ADDRESS_FLAT_TYPE_INET:
1356         addr->type = SOCKET_ADDRESS_KIND_INET;
1357         addr->u.inet.data = QAPI_CLONE(InetSocketAddress,
1358                                        &addr_flat->u.inet);
1359         break;
1360     case SOCKET_ADDRESS_FLAT_TYPE_UNIX:
1361         addr->type = SOCKET_ADDRESS_KIND_UNIX;
1362         addr->u.q_unix.data = QAPI_CLONE(UnixSocketAddress,
1363                                          &addr_flat->u.q_unix);
1364         break;
1365     case SOCKET_ADDRESS_FLAT_TYPE_VSOCK:
1366         addr->type = SOCKET_ADDRESS_KIND_VSOCK;
1367         addr->u.vsock.data = QAPI_CLONE(VsockSocketAddress,
1368                                         &addr_flat->u.vsock);
1369         break;
1370     case SOCKET_ADDRESS_FLAT_TYPE_FD:
1371         addr->type = SOCKET_ADDRESS_KIND_FD;
1372         addr->u.fd.data = QAPI_CLONE(String, &addr_flat->u.fd);
1373         break;
1374     default:
1375         abort();
1376     }
1377
1378     return addr;
1379 }