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