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