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