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