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
  29 #ifndef AI_ADDRCONFIG
  30 # define AI_ADDRCONFIG 0
  31 #endif
  32
  33 /* used temporarily until all users are converted to QemuOpts */
  34 QemuOptsList socket_optslist = {
  35     .name = "socket",
  36     .head = QTAILQ_HEAD_INITIALIZER(socket_optslist.head),
  37     .desc = {
  38         {
  39             .name = "path",
  40             .type = QEMU_OPT_STRING,
  41         },{
  42             .name = "host",
  43             .type = QEMU_OPT_STRING,
  44         },{
  45             .name = "port",
  46             .type = QEMU_OPT_STRING,
  47         },{
  48             .name = "to",
  49             .type = QEMU_OPT_NUMBER,
  50         },{
  51             .name = "ipv4",
  52             .type = QEMU_OPT_BOOL,
  53         },{
  54             .name = "ipv6",
  55             .type = QEMU_OPT_BOOL,
  56         },
  57         { /* end if list */ }
  58     },
  59 };
  60
  61 static int inet_getport(struct addrinfo *e)
  62 {
  63     struct sockaddr_in *i4;
  64     struct sockaddr_in6 *i6;
  65
  66     switch (e->ai_family) {
  67     case PF_INET6:
  68         i6 = (void*)e->ai_addr;
  69         return ntohs(i6->sin6_port);
  70     case PF_INET:
  71         i4 = (void*)e->ai_addr;
  72         return ntohs(i4->sin_port);
  73     default:
  74         return 0;
  75     }
  76 }
  77
  78 static void inet_setport(struct addrinfo *e, int port)
  79 {
  80     struct sockaddr_in *i4;
  81     struct sockaddr_in6 *i6;
  82
  83     switch (e->ai_family) {
  84     case PF_INET6:
  85         i6 = (void*)e->ai_addr;
  86         i6->sin6_port = htons(port);
  87         break;
  88     case PF_INET:
  89         i4 = (void*)e->ai_addr;
  90         i4->sin_port = htons(port);
  91         break;
  92     }
  93 }
  94
  95 NetworkAddressFamily inet_netfamily(int family)
  96 {
  97     switch (family) {
  98     case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6;
  99     case PF_INET:  return NETWORK_ADDRESS_FAMILY_IPV4;
 100     case PF_UNIX:  return NETWORK_ADDRESS_FAMILY_UNIX;
 101     }
 102     return NETWORK_ADDRESS_FAMILY_UNKNOWN;
 103 }
 104
 105 int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
 106 {
 107     struct addrinfo ai,*res,*e;
 108     const char *addr;
 109     char port[33];
 110     char uaddr[INET6_ADDRSTRLEN+1];
 111     char uport[33];
 112     int slisten, rc, to, port_min, port_max, p;
 113
 114     memset(&ai,0, sizeof(ai));
 115     ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
 116     ai.ai_family = PF_UNSPEC;
 117     ai.ai_socktype = SOCK_STREAM;
 118
 119     if ((qemu_opt_get(opts, "host") == NULL) ||
 120         (qemu_opt_get(opts, "port") == NULL)) {
 121         error_setg(errp, "host and/or port not specified");
 122         return -1;
 123     }
 124     pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
 125     addr = qemu_opt_get(opts, "host");
 126
 127     to = qemu_opt_get_number(opts, "to", 0);
 128     if (qemu_opt_get_bool(opts, "ipv4", 0))
 129         ai.ai_family = PF_INET;
 130     if (qemu_opt_get_bool(opts, "ipv6", 0))
 131         ai.ai_family = PF_INET6;
 132
 133     /* lookup */
 134     if (port_offset) {
 135         unsigned long long baseport;
 136         if (parse_uint_full(port, &baseport, 10) < 0) {
 137             error_setg(errp, "can't convert to a number: %s", port);
 138             return -1;
 139         }
 140         if (baseport > 65535 ||
 141             baseport + port_offset > 65535) {
 142             error_setg(errp, "port %s out of range", port);
 143             return -1;
 144         }
 145         snprintf(port, sizeof(port), "%d", (int)baseport + port_offset);
 146     }
 147     rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
 148     if (rc != 0) {
 149         error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
 150                    gai_strerror(rc));
 151         return -1;
 152     }
 153
 154     /* create socket + bind */
 155     for (e = res; e != NULL; e = e->ai_next) {
 156         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
 157                         uaddr,INET6_ADDRSTRLEN,uport,32,
 158                         NI_NUMERICHOST | NI_NUMERICSERV);
 159         slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
 160         if (slisten < 0) {
 161             if (!e->ai_next) {
 162                 error_setg_errno(errp, errno, "Failed to create socket");
 163             }
 164             continue;
 165         }
 166
 167         socket_set_fast_reuse(slisten);
 168 #ifdef IPV6_V6ONLY
 169         if (e->ai_family == PF_INET6) {
 170             /* listen on both ipv4 and ipv6 */
 171             const int off = 0;
 172             qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off,
 173                             sizeof(off));
 174         }
 175 #endif
 176
 177         port_min = inet_getport(e);
 178         port_max = to ? to + port_offset : port_min;
 179         for (p = port_min; p <= port_max; p++) {
 180             inet_setport(e, p);
 181             if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
 182                 goto listen;
 183             }
 184             if (p == port_max) {
 185                 if (!e->ai_next) {
 186                     error_setg_errno(errp, errno, "Failed to bind socket");
 187                 }
 188             }
 189         }
 190         closesocket(slisten);
 191     }
 192     freeaddrinfo(res);
 193     return -1;
 194
 195 listen:
 196     if (listen(slisten,1) != 0) {
 197         error_setg_errno(errp, errno, "Failed to listen on socket");
 198         closesocket(slisten);
 199         freeaddrinfo(res);
 200         return -1;
 201     }
 202     snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
 203     qemu_opt_set(opts, "host", uaddr);
 204     qemu_opt_set(opts, "port", uport);
 205     qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
 206     qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
 207     freeaddrinfo(res);
 208     return slisten;
 209 }
 210
 211 #ifdef _WIN32
 212 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
 213     ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
 214 #else
 215 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
 216     ((rc) == -EINPROGRESS)
 217 #endif
 218
 219 /* Struct to store connect state for non blocking connect */
 220 typedef struct ConnectState {
 221     int fd;
 222     struct addrinfo *addr_list;
 223     struct addrinfo *current_addr;
 224     NonBlockingConnectHandler *callback;
 225     void *opaque;
 226 } ConnectState;
 227
 228 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
 229                              ConnectState *connect_state, Error **errp);
 230
 231 static void wait_for_connect(void *opaque)
 232 {
 233     ConnectState *s = opaque;
 234     int val = 0, rc = 0;
 235     socklen_t valsize = sizeof(val);
 236     bool in_progress;
 237     Error *err = NULL;
 238
 239     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 240
 241     do {
 242         rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
 243     } while (rc == -1 && socket_error() == EINTR);
 244
 245     /* update rc to contain error */
 246     if (!rc && val) {
 247         rc = -1;
 248         errno = val;
 249     }
 250
 251     /* connect error */
 252     if (rc < 0) {
 253         error_setg_errno(&err, errno, "Error connecting to socket");
 254         closesocket(s->fd);
 255         s->fd = rc;
 256     }
 257
 258     /* try to connect to the next address on the list */
 259     if (s->current_addr) {
 260         while (s->current_addr->ai_next != NULL && s->fd < 0) {
 261             s->current_addr = s->current_addr->ai_next;
 262             s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
 263             if (s->fd < 0) {
 264                 error_free(err);
 265                 err = NULL;
 266                 error_setg_errno(&err, errno, "Unable to start socket connect");
 267             }
 268             /* connect in progress */
 269             if (in_progress) {
 270                 goto out;
 271             }
 272         }
 273
 274         freeaddrinfo(s->addr_list);
 275     }
 276
 277     if (s->callback) {
 278         s->callback(s->fd, err, s->opaque);
 279     }
 280     g_free(s);
 281 out:
 282     error_free(err);
 283 }
 284
 285 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
 286                              ConnectState *connect_state, Error **errp)
 287 {
 288     int sock, rc;
 289
 290     *in_progress = false;
 291
 292     sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
 293     if (sock < 0) {
 294         error_setg_errno(errp, errno, "Failed to create socket");
 295         return -1;
 296     }
 297     socket_set_fast_reuse(sock);
 298     if (connect_state != NULL) {
 299         qemu_set_nonblock(sock);
 300     }
 301     /* connect to peer */
 302     do {
 303         rc = 0;
 304         if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
 305             rc = -socket_error();
 306         }
 307     } while (rc == -EINTR);
 308
 309     if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
 310         connect_state->fd = sock;
 311         qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
 312                              connect_state);
 313         *in_progress = true;
 314     } else if (rc < 0) {
 315         error_setg_errno(errp, errno, "Failed to connect socket");
 316         closesocket(sock);
 317         return -1;
 318     }
 319     return sock;
 320 }
 321
 322 static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
 323 {
 324     struct addrinfo ai, *res;
 325     int rc;
 326     const char *addr;
 327     const char *port;
 328
 329     memset(&ai, 0, sizeof(ai));
 330
 331     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
 332     ai.ai_family = PF_UNSPEC;
 333     ai.ai_socktype = SOCK_STREAM;
 334
 335     addr = qemu_opt_get(opts, "host");
 336     port = qemu_opt_get(opts, "port");
 337     if (addr == NULL || port == NULL) {
 338         error_setg(errp, "host and/or port not specified");
 339         return NULL;
 340     }
 341
 342     if (qemu_opt_get_bool(opts, "ipv4", 0)) {
 343         ai.ai_family = PF_INET;
 344     }
 345     if (qemu_opt_get_bool(opts, "ipv6", 0)) {
 346         ai.ai_family = PF_INET6;
 347     }
 348
 349     /* lookup */
 350     rc = getaddrinfo(addr, port, &ai, &res);
 351     if (rc != 0) {
 352         error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
 353                    gai_strerror(rc));
 354         return NULL;
 355     }
 356     return res;
 357 }
 358
 359 /**
 360  * Create a socket and connect it to an address.
 361  *
 362  * @opts: QEMU options, recognized parameters strings "host" and "port",
 363  *        bools "ipv4" and "ipv6".
 364  * @errp: set on error
 365  * @callback: callback function for non-blocking connect
 366  * @opaque: opaque for callback function
 367  *
 368  * Returns: -1 on error, file descriptor on success.
 369  *
 370  * If @callback is non-null, the connect is non-blocking.  If this
 371  * function succeeds, callback will be called when the connection
 372  * completes, with the file descriptor on success, or -1 on error.
 373  */
 374 int inet_connect_opts(QemuOpts *opts, Error **errp,
 375                       NonBlockingConnectHandler *callback, void *opaque)
 376 {
 377     Error *local_err = NULL;
 378     struct addrinfo *res, *e;
 379     int sock = -1;
 380     bool in_progress;
 381     ConnectState *connect_state = NULL;
 382
 383     res = inet_parse_connect_opts(opts, errp);
 384     if (!res) {
 385         return -1;
 386     }
 387
 388     if (callback != NULL) {
 389         connect_state = g_malloc0(sizeof(*connect_state));
 390         connect_state->addr_list = res;
 391         connect_state->callback = callback;
 392         connect_state->opaque = opaque;
 393     }
 394
 395     for (e = res; e != NULL; e = e->ai_next) {
 396         error_free(local_err);
 397         local_err = NULL;
 398         if (connect_state != NULL) {
 399             connect_state->current_addr = e;
 400         }
 401         sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
 402         if (sock >= 0) {
 403             break;
 404         }
 405     }
 406
 407     if (sock < 0) {
 408         error_propagate(errp, local_err);
 409     } else if (in_progress) {
 410         /* wait_for_connect() will do the rest */
 411         return sock;
 412     } else {
 413         if (callback) {
 414             callback(sock, NULL, opaque);
 415         }
 416     }
 417     g_free(connect_state);
 418     freeaddrinfo(res);
 419     return sock;
 420 }
 421
 422 int inet_dgram_opts(QemuOpts *opts, Error **errp)
 423 {
 424     struct addrinfo ai, *peer = NULL, *local = NULL;
 425     const char *addr;
 426     const char *port;
 427     int sock = -1, rc;
 428
 429     /* lookup peer addr */
 430     memset(&ai,0, sizeof(ai));
 431     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
 432     ai.ai_family = PF_UNSPEC;
 433     ai.ai_socktype = SOCK_DGRAM;
 434
 435     addr = qemu_opt_get(opts, "host");
 436     port = qemu_opt_get(opts, "port");
 437     if (addr == NULL || strlen(addr) == 0) {
 438         addr = "localhost";
 439     }
 440     if (port == NULL || strlen(port) == 0) {
 441         error_setg(errp, "remote port not specified");
 442         return -1;
 443     }
 444
 445     if (qemu_opt_get_bool(opts, "ipv4", 0))
 446         ai.ai_family = PF_INET;
 447     if (qemu_opt_get_bool(opts, "ipv6", 0))
 448         ai.ai_family = PF_INET6;
 449
 450     if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
 451         error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
 452                    gai_strerror(rc));
 453         return -1;
 454     }
 455
 456     /* lookup local addr */
 457     memset(&ai,0, sizeof(ai));
 458     ai.ai_flags = AI_PASSIVE;
 459     ai.ai_family = peer->ai_family;
 460     ai.ai_socktype = SOCK_DGRAM;
 461
 462     addr = qemu_opt_get(opts, "localaddr");
 463     port = qemu_opt_get(opts, "localport");
 464     if (addr == NULL || strlen(addr) == 0) {
 465         addr = NULL;
 466     }
 467     if (!port || strlen(port) == 0)
 468         port = "0";
 469
 470     if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
 471         error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
 472                    gai_strerror(rc));
 473         goto err;
 474     }
 475
 476     /* create socket */
 477     sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
 478     if (sock < 0) {
 479         error_setg_errno(errp, errno, "Failed to create socket");
 480         goto err;
 481     }
 482     socket_set_fast_reuse(sock);
 483
 484     /* bind socket */
 485     if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
 486         error_setg_errno(errp, errno, "Failed to bind socket");
 487         goto err;
 488     }
 489
 490     /* connect to peer */
 491     if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
 492         error_setg_errno(errp, errno, "Failed to connect socket");
 493         goto err;
 494     }
 495
 496     freeaddrinfo(local);
 497     freeaddrinfo(peer);
 498     return sock;
 499
 500 err:
 501     if (-1 != sock)
 502         closesocket(sock);
 503     if (local)
 504         freeaddrinfo(local);
 505     if (peer)
 506         freeaddrinfo(peer);
 507     return -1;
 508 }
 509
 510 /* compatibility wrapper */
 511 InetSocketAddress *inet_parse(const char *str, Error **errp)
 512 {
 513     InetSocketAddress *addr;
 514     const char *optstr, *h;
 515     char host[64];
 516     char port[33];
 517     int to;
 518     int pos;
 519
 520     addr = g_new0(InetSocketAddress, 1);
 521
 522     /* parse address */
 523     if (str[0] == ':') {
 524         /* no host given */
 525         host[0] = '\0';
 526         if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
 527             error_setg(errp, "error parsing port in address '%s'", str);
 528             goto fail;
 529         }
 530     } else if (str[0] == '[') {
 531         /* IPv6 addr */
 532         if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
 533             error_setg(errp, "error parsing IPv6 address '%s'", str);
 534             goto fail;
 535         }
 536         addr->ipv6 = addr->has_ipv6 = true;
 537     } else {
 538         /* hostname or IPv4 addr */
 539         if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
 540             error_setg(errp, "error parsing address '%s'", str);
 541             goto fail;
 542         }
 543         if (host[strspn(host, "0123456789.")] == '\0') {
 544             addr->ipv4 = addr->has_ipv4 = true;
 545         }
 546     }
 547
 548     addr->host = g_strdup(host);
 549     addr->port = g_strdup(port);
 550
 551     /* parse options */
 552     optstr = str + pos;
 553     h = strstr(optstr, ",to=");
 554     if (h) {
 555         h += 4;
 556         if (sscanf(h, "%d%n", &to, &pos) != 1 ||
 557             (h[pos] != '\0' && h[pos] != ',')) {
 558             error_setg(errp, "error parsing to= argument");
 559             goto fail;
 560         }
 561         addr->has_to = true;
 562         addr->to = to;
 563     }
 564     if (strstr(optstr, ",ipv4")) {
 565         addr->ipv4 = addr->has_ipv4 = true;
 566     }
 567     if (strstr(optstr, ",ipv6")) {
 568         addr->ipv6 = addr->has_ipv6 = true;
 569     }
 570     return addr;
 571
 572 fail:
 573     qapi_free_InetSocketAddress(addr);
 574     return NULL;
 575 }
 576
 577 static void inet_addr_to_opts(QemuOpts *opts, const InetSocketAddress *addr)
 578 {
 579     bool ipv4 = addr->ipv4 || !addr->has_ipv4;
 580     bool ipv6 = addr->ipv6 || !addr->has_ipv6;
 581
 582     if (!ipv4 || !ipv6) {
 583         qemu_opt_set_bool(opts, "ipv4", ipv4);
 584         qemu_opt_set_bool(opts, "ipv6", ipv6);
 585     }
 586     if (addr->has_to) {
 587         char to[20];
 588         snprintf(to, sizeof(to), "%d", addr->to);
 589         qemu_opt_set(opts, "to", to);
 590     }
 591     qemu_opt_set(opts, "host", addr->host);
 592     qemu_opt_set(opts, "port", addr->port);
 593 }
 594
 595 int inet_listen(const char *str, char *ostr, int olen,
 596                 int socktype, int port_offset, Error **errp)
 597 {
 598     QemuOpts *opts;
 599     char *optstr;
 600     int sock = -1;
 601     InetSocketAddress *addr;
 602
 603     addr = inet_parse(str, errp);
 604     if (addr != NULL) {
 605         opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 606         inet_addr_to_opts(opts, addr);
 607         qapi_free_InetSocketAddress(addr);
 608         sock = inet_listen_opts(opts, port_offset, errp);
 609         if (sock != -1 && ostr) {
 610             optstr = strchr(str, ',');
 611             if (qemu_opt_get_bool(opts, "ipv6", 0)) {
 612                 snprintf(ostr, olen, "[%s]:%s%s",
 613                          qemu_opt_get(opts, "host"),
 614                          qemu_opt_get(opts, "port"),
 615                          optstr ? optstr : "");
 616             } else {
 617                 snprintf(ostr, olen, "%s:%s%s",
 618                          qemu_opt_get(opts, "host"),
 619                          qemu_opt_get(opts, "port"),
 620                          optstr ? optstr : "");
 621             }
 622         }
 623         qemu_opts_del(opts);
 624     }
 625     return sock;
 626 }
 627
 628 /**
 629  * Create a blocking socket and connect it to an address.
 630  *
 631  * @str: address string
 632  * @errp: set in case of an error
 633  *
 634  * Returns -1 in case of error, file descriptor on success
 635  **/
 636 int inet_connect(const char *str, Error **errp)
 637 {
 638     QemuOpts *opts;
 639     int sock = -1;
 640     InetSocketAddress *addr;
 641
 642     addr = inet_parse(str, errp);
 643     if (addr != NULL) {
 644         opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 645         inet_addr_to_opts(opts, addr);
 646         qapi_free_InetSocketAddress(addr);
 647         sock = inet_connect_opts(opts, errp, NULL, NULL);
 648         qemu_opts_del(opts);
 649     }
 650     return sock;
 651 }
 652
 653 /**
 654  * Create a non-blocking socket and connect it to an address.
 655  * Calls the callback function with fd in case of success or -1 in case of
 656  * error.
 657  *
 658  * @str: address string
 659  * @callback: callback function that is called when connect completes,
 660  *            cannot be NULL.
 661  * @opaque: opaque for callback function
 662  * @errp: set in case of an error
 663  *
 664  * Returns: -1 on immediate error, file descriptor on success.
 665  **/
 666 int inet_nonblocking_connect(const char *str,
 667                              NonBlockingConnectHandler *callback,
 668                              void *opaque, Error **errp)
 669 {
 670     QemuOpts *opts;
 671     int sock = -1;
 672     InetSocketAddress *addr;
 673
 674     g_assert(callback != NULL);
 675
 676     addr = inet_parse(str, errp);
 677     if (addr != NULL) {
 678         opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 679         inet_addr_to_opts(opts, addr);
 680         qapi_free_InetSocketAddress(addr);
 681         sock = inet_connect_opts(opts, errp, callback, opaque);
 682         qemu_opts_del(opts);
 683     }
 684     return sock;
 685 }
 686
 687 #ifndef _WIN32
 688
 689 int unix_listen_opts(QemuOpts *opts, Error **errp)
 690 {
 691     struct sockaddr_un un;
 692     const char *path = qemu_opt_get(opts, "path");
 693     int sock, fd;
 694
 695     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 696     if (sock < 0) {
 697         error_setg_errno(errp, errno, "Failed to create socket");
 698         return -1;
 699     }
 700
 701     memset(&un, 0, sizeof(un));
 702     un.sun_family = AF_UNIX;
 703     if (path && strlen(path)) {
 704         snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
 705     } else {
 706         char *tmpdir = getenv("TMPDIR");
 707         snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
 708                  tmpdir ? tmpdir : "/tmp");
 709         /*
 710          * This dummy fd usage silences the mktemp() unsecure warning.
 711          * Using mkstemp() doesn't make things more secure here
 712          * though.  bind() complains about existing files, so we have
 713          * to unlink first and thus re-open the race window.  The
 714          * worst case possible is bind() failing, i.e. a DoS attack.
 715          */
 716         fd = mkstemp(un.sun_path); close(fd);
 717         qemu_opt_set(opts, "path", un.sun_path);
 718     }
 719
 720     unlink(un.sun_path);
 721     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
 722         error_setg_errno(errp, errno, "Failed to bind socket");
 723         goto err;
 724     }
 725     if (listen(sock, 1) < 0) {
 726         error_setg_errno(errp, errno, "Failed to listen on socket");
 727         goto err;
 728     }
 729
 730     return sock;
 731
 732 err:
 733     closesocket(sock);
 734     return -1;
 735 }
 736
 737 int unix_connect_opts(QemuOpts *opts, Error **errp,
 738                       NonBlockingConnectHandler *callback, void *opaque)
 739 {
 740     struct sockaddr_un un;
 741     const char *path = qemu_opt_get(opts, "path");
 742     ConnectState *connect_state = NULL;
 743     int sock, rc;
 744
 745     if (path == NULL) {
 746         error_setg(errp, "unix connect: no path specified");
 747         return -1;
 748     }
 749
 750     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 751     if (sock < 0) {
 752         error_setg_errno(errp, errno, "Failed to create socket");
 753         return -1;
 754     }
 755     if (callback != NULL) {
 756         connect_state = g_malloc0(sizeof(*connect_state));
 757         connect_state->callback = callback;
 758         connect_state->opaque = opaque;
 759         qemu_set_nonblock(sock);
 760     }
 761
 762     memset(&un, 0, sizeof(un));
 763     un.sun_family = AF_UNIX;
 764     snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
 765
 766     /* connect to peer */
 767     do {
 768         rc = 0;
 769         if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
 770             rc = -socket_error();
 771         }
 772     } while (rc == -EINTR);
 773
 774     if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
 775         connect_state->fd = sock;
 776         qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
 777                              connect_state);
 778         return sock;
 779     } else if (rc >= 0) {
 780         /* non blocking socket immediate success, call callback */
 781         if (callback != NULL) {
 782             callback(sock, NULL, opaque);
 783         }
 784     }
 785
 786     if (rc < 0) {
 787         error_setg_errno(errp, -rc, "Failed to connect socket");
 788         close(sock);
 789         sock = -1;
 790     }
 791
 792     g_free(connect_state);
 793     return sock;
 794 }
 795
 796 #else
 797
 798 int unix_listen_opts(QemuOpts *opts, Error **errp)
 799 {
 800     error_setg(errp, "unix sockets are not available on windows");
 801     errno = ENOTSUP;
 802     return -1;
 803 }
 804
 805 int unix_connect_opts(QemuOpts *opts, Error **errp,
 806                       NonBlockingConnectHandler *callback, void *opaque)
 807 {
 808     error_setg(errp, "unix sockets are not available on windows");
 809     errno = ENOTSUP;
 810     return -1;
 811 }
 812 #endif
 813
 814 /* compatibility wrapper */
 815 int unix_listen(const char *str, char *ostr, int olen, Error **errp)
 816 {
 817     QemuOpts *opts;
 818     char *path, *optstr;
 819     int sock, len;
 820
 821     opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 822
 823     optstr = strchr(str, ',');
 824     if (optstr) {
 825         len = optstr - str;
 826         if (len) {
 827             path = g_malloc(len+1);
 828             snprintf(path, len+1, "%.*s", len, str);
 829             qemu_opt_set(opts, "path", path);
 830             g_free(path);
 831         }
 832     } else {
 833         qemu_opt_set(opts, "path", str);
 834     }
 835
 836     sock = unix_listen_opts(opts, errp);
 837
 838     if (sock != -1 && ostr)
 839         snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
 840     qemu_opts_del(opts);
 841     return sock;
 842 }
 843
 844 int unix_connect(const char *path, Error **errp)
 845 {
 846     QemuOpts *opts;
 847     int sock;
 848
 849     opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 850     qemu_opt_set(opts, "path", path);
 851     sock = unix_connect_opts(opts, errp, NULL, NULL);
 852     qemu_opts_del(opts);
 853     return sock;
 854 }
 855
 856
 857 int unix_nonblocking_connect(const char *path,
 858                              NonBlockingConnectHandler *callback,
 859                              void *opaque, Error **errp)
 860 {
 861     QemuOpts *opts;
 862     int sock = -1;
 863
 864     g_assert(callback != NULL);
 865
 866     opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 867     qemu_opt_set(opts, "path", path);
 868     sock = unix_connect_opts(opts, errp, callback, opaque);
 869     qemu_opts_del(opts);
 870     return sock;
 871 }
 872
 873 SocketAddress *socket_parse(const char *str, Error **errp)
 874 {
 875     SocketAddress *addr;
 876
 877     addr = g_new0(SocketAddress, 1);
 878     if (strstart(str, "unix:", NULL)) {
 879         if (str[5] == '\0') {
 880             error_setg(errp, "invalid Unix socket address");
 881             goto fail;
 882         } else {
 883             addr->kind = SOCKET_ADDRESS_KIND_UNIX;
 884             addr->q_unix = g_new(UnixSocketAddress, 1);
 885             addr->q_unix->path = g_strdup(str + 5);
 886         }
 887     } else if (strstart(str, "fd:", NULL)) {
 888         if (str[3] == '\0') {
 889             error_setg(errp, "invalid file descriptor address");
 890             goto fail;
 891         } else {
 892             addr->kind = SOCKET_ADDRESS_KIND_FD;
 893             addr->fd = g_new(String, 1);
 894             addr->fd->str = g_strdup(str + 3);
 895         }
 896     } else {
 897         addr->kind = SOCKET_ADDRESS_KIND_INET;
 898         addr->inet = inet_parse(str, errp);
 899         if (addr->inet == NULL) {
 900             goto fail;
 901         }
 902     }
 903     return addr;
 904
 905 fail:
 906     qapi_free_SocketAddress(addr);
 907     return NULL;
 908 }
 909
 910 int socket_connect(SocketAddress *addr, Error **errp,
 911                    NonBlockingConnectHandler *callback, void *opaque)
 912 {
 913     QemuOpts *opts;
 914     int fd;
 915
 916     opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 917     switch (addr->kind) {
 918     case SOCKET_ADDRESS_KIND_INET:
 919         inet_addr_to_opts(opts, addr->inet);
 920         fd = inet_connect_opts(opts, errp, callback, opaque);
 921         break;
 922
 923     case SOCKET_ADDRESS_KIND_UNIX:
 924         qemu_opt_set(opts, "path", addr->q_unix->path);
 925         fd = unix_connect_opts(opts, errp, callback, opaque);
 926         break;
 927
 928     case SOCKET_ADDRESS_KIND_FD:
 929         fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
 930         if (fd >= 0 && callback) {
 931             qemu_set_nonblock(fd);
 932             callback(fd, NULL, opaque);
 933         }
 934         break;
 935
 936     default:
 937         abort();
 938     }
 939     qemu_opts_del(opts);
 940     return fd;
 941 }
 942
 943 int socket_listen(SocketAddress *addr, Error **errp)
 944 {
 945     QemuOpts *opts;
 946     int fd;
 947
 948     opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 949     switch (addr->kind) {
 950     case SOCKET_ADDRESS_KIND_INET:
 951         inet_addr_to_opts(opts, addr->inet);
 952         fd = inet_listen_opts(opts, 0, errp);
 953         break;
 954
 955     case SOCKET_ADDRESS_KIND_UNIX:
 956         qemu_opt_set(opts, "path", addr->q_unix->path);
 957         fd = unix_listen_opts(opts, errp);
 958         break;
 959
 960     case SOCKET_ADDRESS_KIND_FD:
 961         fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
 962         break;
 963
 964     default:
 965         abort();
 966     }
 967     qemu_opts_del(opts);
 968     return fd;
 969 }
 970
 971 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
 972 {
 973     QemuOpts *opts;
 974     int fd;
 975
 976     opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
 977     switch (remote->kind) {
 978     case SOCKET_ADDRESS_KIND_INET:
 979         inet_addr_to_opts(opts, remote->inet);
 980         if (local) {
 981             qemu_opt_set(opts, "localaddr", local->inet->host);
 982             qemu_opt_set(opts, "localport", local->inet->port);
 983         }
 984         fd = inet_dgram_opts(opts, errp);
 985         break;
 986
 987     default:
 988         error_setg(errp, "socket type unsupported for datagram");
 989         fd = -1;
 990     }
 991     qemu_opts_del(opts);
 992     return fd;
 993 }