util/qemu-sockets.c

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