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