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