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 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19 #include <errno.h>
  20 #include <unistd.h>
  21
  22 #include "qemu_socket.h"
  23 #include "qemu-common.h" /* for qemu_isdigit */
  24
  25 #ifndef AI_ADDRCONFIG
  26 # define AI_ADDRCONFIG 0
  27 #endif
  28
  29 static int sockets_debug = 0;
  30 static const int on=1, off=0;
  31
  32 /* used temporarely until all users are converted to QemuOpts */
  33 static QemuOptsList dummy_opts = {
  34     .name = "dummy",
  35     .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
  36     .desc = {
  37         {
  38             .name = "path",
  39             .type = QEMU_OPT_STRING,
  40         },{
  41             .name = "host",
  42             .type = QEMU_OPT_STRING,
  43         },{
  44             .name = "port",
  45             .type = QEMU_OPT_STRING,
  46         },{
  47             .name = "to",
  48             .type = QEMU_OPT_NUMBER,
  49         },{
  50             .name = "ipv4",
  51             .type = QEMU_OPT_BOOL,
  52         },{
  53             .name = "ipv6",
  54             .type = QEMU_OPT_BOOL,
  55         },
  56         { /* end if list */ }
  57     },
  58 };
  59
  60 static int inet_getport(struct addrinfo *e)
  61 {
  62     struct sockaddr_in *i4;
  63     struct sockaddr_in6 *i6;
  64
  65     switch (e->ai_family) {
  66     case PF_INET6:
  67         i6 = (void*)e->ai_addr;
  68         return ntohs(i6->sin6_port);
  69     case PF_INET:
  70         i4 = (void*)e->ai_addr;
  71         return ntohs(i4->sin_port);
  72     default:
  73         return 0;
  74     }
  75 }
  76
  77 static void inet_setport(struct addrinfo *e, int port)
  78 {
  79     struct sockaddr_in *i4;
  80     struct sockaddr_in6 *i6;
  81
  82     switch (e->ai_family) {
  83     case PF_INET6:
  84         i6 = (void*)e->ai_addr;
  85         i6->sin6_port = htons(port);
  86         break;
  87     case PF_INET:
  88         i4 = (void*)e->ai_addr;
  89         i4->sin_port = htons(port);
  90         break;
  91     }
  92 }
  93
  94 const char *inet_strfamily(int family)
  95 {
  96     switch (family) {
  97     case PF_INET6: return "ipv6";
  98     case PF_INET:  return "ipv4";
  99     case PF_UNIX:  return "unix";
 100     }
 101     return "unknown";
 102 }
 103
 104 static void inet_print_addrinfo(const char *tag, struct addrinfo *res)
 105 {
 106     struct addrinfo *e;
 107     char uaddr[INET6_ADDRSTRLEN+1];
 108     char uport[33];
 109
 110     for (e = res; e != NULL; e = e->ai_next) {
 111         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
 112                     uaddr,INET6_ADDRSTRLEN,uport,32,
 113                     NI_NUMERICHOST | NI_NUMERICSERV);
 114         fprintf(stderr,"%s: getaddrinfo: family %s, host %s, port %s\n",
 115                 tag, inet_strfamily(e->ai_family), uaddr, uport);
 116     }
 117 }
 118
 119 int inet_listen_opts(QemuOpts *opts, int port_offset)
 120 {
 121     struct addrinfo ai,*res,*e;
 122     const char *addr;
 123     char port[33];
 124     char uaddr[INET6_ADDRSTRLEN+1];
 125     char uport[33];
 126     int slisten,rc,to,try_next;
 127
 128     memset(&ai,0, sizeof(ai));
 129     ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
 130     ai.ai_family = PF_UNSPEC;
 131     ai.ai_socktype = SOCK_STREAM;
 132
 133     if ((qemu_opt_get(opts, "host") == NULL) ||
 134         (qemu_opt_get(opts, "port") == NULL)) {
 135         fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__);
 136         return -1;
 137     }
 138     pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
 139     addr = qemu_opt_get(opts, "host");
 140
 141     to = qemu_opt_get_number(opts, "to", 0);
 142     if (qemu_opt_get_bool(opts, "ipv4", 0))
 143         ai.ai_family = PF_INET;
 144     if (qemu_opt_get_bool(opts, "ipv6", 0))
 145         ai.ai_family = PF_INET6;
 146
 147     /* lookup */
 148     if (port_offset)
 149         snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
 150     rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
 151     if (rc != 0) {
 152         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 153                 gai_strerror(rc));
 154         return -1;
 155     }
 156     if (sockets_debug)
 157         inet_print_addrinfo(__FUNCTION__, res);
 158
 159     /* create socket + bind */
 160     for (e = res; e != NULL; e = e->ai_next) {
 161         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
 162                         uaddr,INET6_ADDRSTRLEN,uport,32,
 163                         NI_NUMERICHOST | NI_NUMERICSERV);
 164         slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
 165         if (slisten < 0) {
 166             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
 167                     inet_strfamily(e->ai_family), strerror(errno));
 168             continue;
 169         }
 170
 171         setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
 172 #ifdef IPV6_V6ONLY
 173         if (e->ai_family == PF_INET6) {
 174             /* listen on both ipv4 and ipv6 */
 175             setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
 176                 sizeof(off));
 177         }
 178 #endif
 179
 180         for (;;) {
 181             if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
 182                 if (sockets_debug)
 183                     fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
 184                         inet_strfamily(e->ai_family), uaddr, inet_getport(e));
 185                 goto listen;
 186             }
 187             try_next = to && (inet_getport(e) <= to + port_offset);
 188             if (!try_next || sockets_debug)
 189                 fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__,
 190                         inet_strfamily(e->ai_family), uaddr, inet_getport(e),
 191                         strerror(errno));
 192             if (try_next) {
 193                 inet_setport(e, inet_getport(e) + 1);
 194                 continue;
 195             }
 196             break;
 197         }
 198         closesocket(slisten);
 199     }
 200     fprintf(stderr, "%s: FAILED\n", __FUNCTION__);
 201     freeaddrinfo(res);
 202     return -1;
 203
 204 listen:
 205     if (listen(slisten,1) != 0) {
 206         perror("listen");
 207         closesocket(slisten);
 208         freeaddrinfo(res);
 209         return -1;
 210     }
 211     snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
 212     qemu_opt_set(opts, "host", uaddr);
 213     qemu_opt_set(opts, "port", uport);
 214     qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
 215     qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
 216     freeaddrinfo(res);
 217     return slisten;
 218 }
 219
 220 int inet_connect_opts(QemuOpts *opts)
 221 {
 222     struct addrinfo ai,*res,*e;
 223     const char *addr;
 224     const char *port;
 225     char uaddr[INET6_ADDRSTRLEN+1];
 226     char uport[33];
 227     int sock,rc;
 228
 229     memset(&ai,0, sizeof(ai));
 230     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
 231     ai.ai_family = PF_UNSPEC;
 232     ai.ai_socktype = SOCK_STREAM;
 233
 234     addr = qemu_opt_get(opts, "host");
 235     port = qemu_opt_get(opts, "port");
 236     if (addr == NULL || port == NULL) {
 237         fprintf(stderr, "inet_connect: host and/or port not specified\n");
 238         return -1;
 239     }
 240
 241     if (qemu_opt_get_bool(opts, "ipv4", 0))
 242         ai.ai_family = PF_INET;
 243     if (qemu_opt_get_bool(opts, "ipv6", 0))
 244         ai.ai_family = PF_INET6;
 245
 246     /* lookup */
 247     if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) {
 248         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 249                 gai_strerror(rc));
 250         return -1;
 251     }
 252     if (sockets_debug)
 253         inet_print_addrinfo(__FUNCTION__, res);
 254
 255     for (e = res; e != NULL; e = e->ai_next) {
 256         if (getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
 257                             uaddr,INET6_ADDRSTRLEN,uport,32,
 258                             NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 259             fprintf(stderr,"%s: getnameinfo: oops\n", __FUNCTION__);
 260             continue;
 261         }
 262         sock = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
 263         if (sock < 0) {
 264             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
 265             inet_strfamily(e->ai_family), strerror(errno));
 266             continue;
 267         }
 268         setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
 269
 270         /* connect to peer */
 271         if (connect(sock,e->ai_addr,e->ai_addrlen) < 0) {
 272             if (sockets_debug || NULL == e->ai_next)
 273                 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
 274                         inet_strfamily(e->ai_family),
 275                         e->ai_canonname, uaddr, uport, strerror(errno));
 276             closesocket(sock);
 277             continue;
 278         }
 279         if (sockets_debug)
 280             fprintf(stderr, "%s: connect(%s,%s,%s,%s): OK\n", __FUNCTION__,
 281                     inet_strfamily(e->ai_family),
 282                     e->ai_canonname, uaddr, uport);
 283         freeaddrinfo(res);
 284         return sock;
 285     }
 286     freeaddrinfo(res);
 287     return -1;
 288 }
 289
 290 int inet_dgram_opts(QemuOpts *opts)
 291 {
 292     struct addrinfo ai, *peer = NULL, *local = NULL;
 293     const char *addr;
 294     const char *port;
 295     char uaddr[INET6_ADDRSTRLEN+1];
 296     char uport[33];
 297     int sock = -1, rc;
 298
 299     /* lookup peer addr */
 300     memset(&ai,0, sizeof(ai));
 301     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
 302     ai.ai_family = PF_UNSPEC;
 303     ai.ai_socktype = SOCK_DGRAM;
 304
 305     addr = qemu_opt_get(opts, "host");
 306     port = qemu_opt_get(opts, "port");
 307     if (addr == NULL || strlen(addr) == 0) {
 308         addr = "localhost";
 309     }
 310     if (port == NULL || strlen(port) == 0) {
 311         fprintf(stderr, "inet_dgram: port not specified\n");
 312         return -1;
 313     }
 314
 315     if (qemu_opt_get_bool(opts, "ipv4", 0))
 316         ai.ai_family = PF_INET;
 317     if (qemu_opt_get_bool(opts, "ipv6", 0))
 318         ai.ai_family = PF_INET6;
 319
 320     if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
 321         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 322                 gai_strerror(rc));
 323         return -1;
 324     }
 325     if (sockets_debug) {
 326         fprintf(stderr, "%s: peer (%s:%s)\n", __FUNCTION__, addr, port);
 327         inet_print_addrinfo(__FUNCTION__, peer);
 328     }
 329
 330     /* lookup local addr */
 331     memset(&ai,0, sizeof(ai));
 332     ai.ai_flags = AI_PASSIVE;
 333     ai.ai_family = peer->ai_family;
 334     ai.ai_socktype = SOCK_DGRAM;
 335
 336     addr = qemu_opt_get(opts, "localaddr");
 337     port = qemu_opt_get(opts, "localport");
 338     if (addr == NULL || strlen(addr) == 0) {
 339         addr = NULL;
 340     }
 341     if (!port || strlen(port) == 0)
 342         port = "0";
 343
 344     if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
 345         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 346                 gai_strerror(rc));
 347         return -1;
 348     }
 349     if (sockets_debug) {
 350         fprintf(stderr, "%s: local (%s:%s)\n", __FUNCTION__, addr, port);
 351         inet_print_addrinfo(__FUNCTION__, local);
 352     }
 353
 354     /* create socket */
 355     sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
 356     if (sock < 0) {
 357         fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
 358                 inet_strfamily(peer->ai_family), strerror(errno));
 359         goto err;
 360     }
 361     setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
 362
 363     /* bind socket */
 364     if (getnameinfo((struct sockaddr*)local->ai_addr,local->ai_addrlen,
 365                     uaddr,INET6_ADDRSTRLEN,uport,32,
 366                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 367         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
 368         goto err;
 369     }
 370     if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
 371         fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
 372                 inet_strfamily(local->ai_family), uaddr, inet_getport(local));
 373         goto err;
 374     }
 375
 376     /* connect to peer */
 377     if (getnameinfo((struct sockaddr*)peer->ai_addr, peer->ai_addrlen,
 378                     uaddr, INET6_ADDRSTRLEN, uport, 32,
 379                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 380         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
 381         goto err;
 382     }
 383     if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
 384         fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
 385                 inet_strfamily(peer->ai_family),
 386                 peer->ai_canonname, uaddr, uport, strerror(errno));
 387         goto err;
 388     }
 389
 390     freeaddrinfo(local);
 391     freeaddrinfo(peer);
 392     return sock;
 393
 394 err:
 395     if (-1 != sock)
 396         closesocket(sock);
 397     if (local)
 398         freeaddrinfo(local);
 399     if (peer)
 400         freeaddrinfo(peer);
 401     return -1;
 402 }
 403
 404 /* compatibility wrapper */
 405 static int inet_parse(QemuOpts *opts, const char *str)
 406 {
 407     const char *optstr, *h;
 408     char addr[64];
 409     char port[33];
 410     int pos;
 411
 412     /* parse address */
 413     if (str[0] == ':') {
 414         /* no host given */
 415         addr[0] = '\0';
 416         if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
 417             fprintf(stderr, "%s: portonly parse error (%s)\n",
 418                     __FUNCTION__, str);
 419             return -1;
 420         }
 421     } else if (str[0] == '[') {
 422         /* IPv6 addr */
 423         if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
 424             fprintf(stderr, "%s: ipv6 parse error (%s)\n",
 425                     __FUNCTION__, str);
 426             return -1;
 427         }
 428         qemu_opt_set(opts, "ipv6", "on");
 429     } else if (qemu_isdigit(str[0])) {
 430         /* IPv4 addr */
 431         if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
 432             fprintf(stderr, "%s: ipv4 parse error (%s)\n",
 433                     __FUNCTION__, str);
 434             return -1;
 435         }
 436         qemu_opt_set(opts, "ipv4", "on");
 437     } else {
 438         /* hostname */
 439         if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
 440             fprintf(stderr, "%s: hostname parse error (%s)\n",
 441                     __FUNCTION__, str);
 442             return -1;
 443         }
 444     }
 445     qemu_opt_set(opts, "host", addr);
 446     qemu_opt_set(opts, "port", port);
 447
 448     /* parse options */
 449     optstr = str + pos;
 450     h = strstr(optstr, ",to=");
 451     if (h)
 452         qemu_opt_set(opts, "to", h+4);
 453     if (strstr(optstr, ",ipv4"))
 454         qemu_opt_set(opts, "ipv4", "on");
 455     if (strstr(optstr, ",ipv6"))
 456         qemu_opt_set(opts, "ipv6", "on");
 457     return 0;
 458 }
 459
 460 int inet_listen(const char *str, char *ostr, int olen,
 461                 int socktype, int port_offset)
 462 {
 463     QemuOpts *opts;
 464     char *optstr;
 465     int sock = -1;
 466
 467     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 468     if (inet_parse(opts, str) == 0) {
 469         sock = inet_listen_opts(opts, port_offset);
 470         if (sock != -1 && ostr) {
 471             optstr = strchr(str, ',');
 472             if (qemu_opt_get_bool(opts, "ipv6", 0)) {
 473                 snprintf(ostr, olen, "[%s]:%s%s",
 474                          qemu_opt_get(opts, "host"),
 475                          qemu_opt_get(opts, "port"),
 476                          optstr ? optstr : "");
 477             } else {
 478                 snprintf(ostr, olen, "%s:%s%s",
 479                          qemu_opt_get(opts, "host"),
 480                          qemu_opt_get(opts, "port"),
 481                          optstr ? optstr : "");
 482             }
 483         }
 484     }
 485     qemu_opts_del(opts);
 486     return sock;
 487 }
 488
 489 int inet_connect(const char *str, int socktype)
 490 {
 491     QemuOpts *opts;
 492     int sock = -1;
 493
 494     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 495     if (inet_parse(opts, str) == 0)
 496         sock = inet_connect_opts(opts);
 497     qemu_opts_del(opts);
 498     return sock;
 499 }
 500
 501 #ifndef _WIN32
 502
 503 int unix_listen_opts(QemuOpts *opts)
 504 {
 505     struct sockaddr_un un;
 506     const char *path = qemu_opt_get(opts, "path");
 507     int sock, fd;
 508
 509     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 510     if (sock < 0) {
 511         perror("socket(unix)");
 512         return -1;
 513     }
 514
 515     memset(&un, 0, sizeof(un));
 516     un.sun_family = AF_UNIX;
 517     if (path && strlen(path)) {
 518         snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
 519     } else {
 520         char *tmpdir = getenv("TMPDIR");
 521         snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
 522                  tmpdir ? tmpdir : "/tmp");
 523         /*
 524          * This dummy fd usage silences the mktemp() unsecure warning.
 525          * Using mkstemp() doesn't make things more secure here
 526          * though.  bind() complains about existing files, so we have
 527          * to unlink first and thus re-open the race window.  The
 528          * worst case possible is bind() failing, i.e. a DoS attack.
 529          */
 530         fd = mkstemp(un.sun_path); close(fd);
 531         qemu_opt_set(opts, "path", un.sun_path);
 532     }
 533
 534     unlink(un.sun_path);
 535     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
 536         fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno));
 537         goto err;
 538     }
 539     if (listen(sock, 1) < 0) {
 540         fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno));
 541         goto err;
 542     }
 543
 544     if (sockets_debug)
 545         fprintf(stderr, "bind(unix:%s): OK\n", un.sun_path);
 546     return sock;
 547
 548 err:
 549     closesocket(sock);
 550     return -1;
 551 }
 552
 553 int unix_connect_opts(QemuOpts *opts)
 554 {
 555     struct sockaddr_un un;
 556     const char *path = qemu_opt_get(opts, "path");
 557     int sock;
 558
 559     if (NULL == path) {
 560         fprintf(stderr, "unix connect: no path specified\n");
 561         return -1;
 562     }
 563
 564     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 565     if (sock < 0) {
 566         perror("socket(unix)");
 567         return -1;
 568     }
 569
 570     memset(&un, 0, sizeof(un));
 571     un.sun_family = AF_UNIX;
 572     snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
 573     if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
 574         fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno));
 575         return -1;
 576     }
 577
 578     if (sockets_debug)
 579         fprintf(stderr, "connect(unix:%s): OK\n", path);
 580     return sock;
 581 }
 582
 583 /* compatibility wrapper */
 584 int unix_listen(const char *str, char *ostr, int olen)
 585 {
 586     QemuOpts *opts;
 587     char *path, *optstr;
 588     int sock, len;
 589
 590     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 591
 592     optstr = strchr(str, ',');
 593     if (optstr) {
 594         len = optstr - str;
 595         if (len) {
 596             path = g_malloc(len+1);
 597             snprintf(path, len+1, "%.*s", len, str);
 598             qemu_opt_set(opts, "path", path);
 599             g_free(path);
 600         }
 601     } else {
 602         qemu_opt_set(opts, "path", str);
 603     }
 604
 605     sock = unix_listen_opts(opts);
 606
 607     if (sock != -1 && ostr)
 608         snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
 609     qemu_opts_del(opts);
 610     return sock;
 611 }
 612
 613 int unix_connect(const char *path)
 614 {
 615     QemuOpts *opts;
 616     int sock;
 617
 618     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 619     qemu_opt_set(opts, "path", path);
 620     sock = unix_connect_opts(opts);
 621     qemu_opts_del(opts);
 622     return sock;
 623 }
 624
 625 #else
 626
 627 int unix_listen_opts(QemuOpts *opts)
 628 {
 629     fprintf(stderr, "unix sockets are not available on windows\n");
 630     errno = ENOTSUP;
 631     return -1;
 632 }
 633
 634 int unix_connect_opts(QemuOpts *opts)
 635 {
 636     fprintf(stderr, "unix sockets are not available on windows\n");
 637     errno = ENOTSUP;
 638     return -1;
 639 }
 640
 641 int unix_listen(const char *path, char *ostr, int olen)
 642 {
 643     fprintf(stderr, "unix sockets are not available on windows\n");
 644     errno = ENOTSUP;
 645     return -1;
 646 }
 647
 648 int unix_connect(const char *path)
 649 {
 650     fprintf(stderr, "unix sockets are not available on windows\n");
 651     errno = ENOTSUP;
 652     return -1;
 653 }
 654
 655 #endif
 656
 657 #ifdef _WIN32
 658 static void socket_cleanup(void)
 659 {
 660     WSACleanup();
 661 }
 662 #endif
 663
 664 int socket_init(void)
 665 {
 666 #ifdef _WIN32
 667     WSADATA Data;
 668     int ret, err;
 669
 670     ret = WSAStartup(MAKEWORD(2,2), &Data);
 671     if (ret != 0) {
 672         err = WSAGetLastError();
 673         fprintf(stderr, "WSAStartup: %d\n", err);
 674         return -1;
 675     }
 676     atexit(socket_cleanup);
 677 #endif
 678     return 0;
 679 }