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 static 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 "????";
 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, "port") == NULL) {
 134         fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__);
 135         return -1;
 136     }
 137     pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
 138     addr = qemu_opt_get(opts, "host");
 139
 140     to = qemu_opt_get_number(opts, "to", 0);
 141     if (qemu_opt_get_bool(opts, "ipv4", 0))
 142         ai.ai_family = PF_INET;
 143     if (qemu_opt_get_bool(opts, "ipv6", 0))
 144         ai.ai_family = PF_INET6;
 145
 146     /* lookup */
 147     if (port_offset)
 148         snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
 149     rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
 150     if (rc != 0) {
 151         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 152                 gai_strerror(rc));
 153         return -1;
 154     }
 155     if (sockets_debug)
 156         inet_print_addrinfo(__FUNCTION__, res);
 157
 158     /* create socket + bind */
 159     for (e = res; e != NULL; e = e->ai_next) {
 160         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
 161                         uaddr,INET6_ADDRSTRLEN,uport,32,
 162                         NI_NUMERICHOST | NI_NUMERICSERV);
 163         slisten = socket(e->ai_family, e->ai_socktype, e->ai_protocol);
 164         if (slisten < 0) {
 165             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
 166                     inet_strfamily(e->ai_family), strerror(errno));
 167             continue;
 168         }
 169
 170         setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
 171 #ifdef IPV6_V6ONLY
 172         if (e->ai_family == PF_INET6) {
 173             /* listen on both ipv4 and ipv6 */
 174             setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
 175                 sizeof(off));
 176         }
 177 #endif
 178
 179         for (;;) {
 180             if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
 181                 if (sockets_debug)
 182                     fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
 183                         inet_strfamily(e->ai_family), uaddr, inet_getport(e));
 184                 goto listen;
 185             }
 186             try_next = to && (inet_getport(e) <= to + port_offset);
 187             if (!try_next || sockets_debug)
 188                 fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__,
 189                         inet_strfamily(e->ai_family), uaddr, inet_getport(e),
 190                         strerror(errno));
 191             if (try_next) {
 192                 inet_setport(e, inet_getport(e) + 1);
 193                 continue;
 194             }
 195             break;
 196         }
 197         closesocket(slisten);
 198     }
 199     fprintf(stderr, "%s: FAILED\n", __FUNCTION__);
 200     freeaddrinfo(res);
 201     return -1;
 202
 203 listen:
 204     if (listen(slisten,1) != 0) {
 205         perror("listen");
 206         closesocket(slisten);
 207         freeaddrinfo(res);
 208         return -1;
 209     }
 210     snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
 211     qemu_opt_set(opts, "host", uaddr);
 212     qemu_opt_set(opts, "port", uport);
 213     qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
 214     qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
 215     freeaddrinfo(res);
 216     return slisten;
 217 }
 218
 219 int inet_connect_opts(QemuOpts *opts)
 220 {
 221     struct addrinfo ai,*res,*e;
 222     const char *addr;
 223     const char *port;
 224     char uaddr[INET6_ADDRSTRLEN+1];
 225     char uport[33];
 226     int sock,rc;
 227
 228     memset(&ai,0, sizeof(ai));
 229     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
 230     ai.ai_family = PF_UNSPEC;
 231     ai.ai_socktype = SOCK_STREAM;
 232
 233     addr = qemu_opt_get(opts, "host");
 234     port = qemu_opt_get(opts, "port");
 235     if (addr == NULL || port == NULL) {
 236         fprintf(stderr, "inet_connect: host and/or port not specified\n");
 237         return -1;
 238     }
 239
 240     if (qemu_opt_get_bool(opts, "ipv4", 0))
 241         ai.ai_family = PF_INET;
 242     if (qemu_opt_get_bool(opts, "ipv6", 0))
 243         ai.ai_family = PF_INET6;
 244
 245     /* lookup */
 246     if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) {
 247         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 248                 gai_strerror(rc));
 249         return -1;
 250     }
 251     if (sockets_debug)
 252         inet_print_addrinfo(__FUNCTION__, res);
 253
 254     for (e = res; e != NULL; e = e->ai_next) {
 255         if (getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
 256                             uaddr,INET6_ADDRSTRLEN,uport,32,
 257                             NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 258             fprintf(stderr,"%s: getnameinfo: oops\n", __FUNCTION__);
 259             continue;
 260         }
 261         sock = socket(e->ai_family, e->ai_socktype, e->ai_protocol);
 262         if (sock < 0) {
 263             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
 264             inet_strfamily(e->ai_family), strerror(errno));
 265             continue;
 266         }
 267         setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
 268
 269         /* connect to peer */
 270         if (connect(sock,e->ai_addr,e->ai_addrlen) < 0) {
 271             if (sockets_debug || NULL == e->ai_next)
 272                 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
 273                         inet_strfamily(e->ai_family),
 274                         e->ai_canonname, uaddr, uport, strerror(errno));
 275             closesocket(sock);
 276             continue;
 277         }
 278         if (sockets_debug)
 279             fprintf(stderr, "%s: connect(%s,%s,%s,%s): OK\n", __FUNCTION__,
 280                     inet_strfamily(e->ai_family),
 281                     e->ai_canonname, uaddr, uport);
 282         freeaddrinfo(res);
 283         return sock;
 284     }
 285     freeaddrinfo(res);
 286     return -1;
 287 }
 288
 289 int inet_dgram_opts(QemuOpts *opts)
 290 {
 291     struct addrinfo ai, *peer = NULL, *local = NULL;
 292     const char *addr;
 293     const char *port;
 294     char uaddr[INET6_ADDRSTRLEN+1];
 295     char uport[33];
 296     int sock = -1, rc;
 297
 298     /* lookup peer addr */
 299     memset(&ai,0, sizeof(ai));
 300     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
 301     ai.ai_family = PF_UNSPEC;
 302     ai.ai_socktype = SOCK_DGRAM;
 303
 304     addr = qemu_opt_get(opts, "host");
 305     port = qemu_opt_get(opts, "port");
 306     if (addr == NULL || strlen(addr) == 0) {
 307         addr = "localhost";
 308     }
 309     if (port == NULL || strlen(port) == 0) {
 310         fprintf(stderr, "inet_dgram: port not specified\n");
 311         return -1;
 312     }
 313
 314     if (qemu_opt_get_bool(opts, "ipv4", 0))
 315         ai.ai_family = PF_INET;
 316     if (qemu_opt_get_bool(opts, "ipv6", 0))
 317         ai.ai_family = PF_INET6;
 318
 319     if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
 320         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 321                 gai_strerror(rc));
 322         return -1;
 323     }
 324     if (sockets_debug) {
 325         fprintf(stderr, "%s: peer (%s:%s)\n", __FUNCTION__, addr, port);
 326         inet_print_addrinfo(__FUNCTION__, peer);
 327     }
 328
 329     /* lookup local addr */
 330     memset(&ai,0, sizeof(ai));
 331     ai.ai_flags = AI_PASSIVE;
 332     ai.ai_family = peer->ai_family;
 333     ai.ai_socktype = SOCK_DGRAM;
 334
 335     addr = qemu_opt_get(opts, "localaddr");
 336     port = qemu_opt_get(opts, "localport");
 337     if (addr == NULL || strlen(addr) == 0) {
 338         addr = NULL;
 339     }
 340     if (!port || strlen(port) == 0)
 341         port = "0";
 342
 343     if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
 344         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
 345                 gai_strerror(rc));
 346         return -1;
 347     }
 348     if (sockets_debug) {
 349         fprintf(stderr, "%s: local (%s:%s)\n", __FUNCTION__, addr, port);
 350         inet_print_addrinfo(__FUNCTION__, local);
 351     }
 352
 353     /* create socket */
 354     sock = socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
 355     if (sock < 0) {
 356         fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
 357                 inet_strfamily(peer->ai_family), strerror(errno));
 358         goto err;
 359     }
 360     setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
 361
 362     /* bind socket */
 363     if (getnameinfo((struct sockaddr*)local->ai_addr,local->ai_addrlen,
 364                     uaddr,INET6_ADDRSTRLEN,uport,32,
 365                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 366         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
 367         goto err;
 368     }
 369     if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
 370         fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
 371                 inet_strfamily(local->ai_family), uaddr, inet_getport(local));
 372         goto err;
 373     }
 374
 375     /* connect to peer */
 376     if (getnameinfo((struct sockaddr*)peer->ai_addr, peer->ai_addrlen,
 377                     uaddr, INET6_ADDRSTRLEN, uport, 32,
 378                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 379         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
 380         goto err;
 381     }
 382     if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
 383         fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
 384                 inet_strfamily(peer->ai_family),
 385                 peer->ai_canonname, uaddr, uport, strerror(errno));
 386         goto err;
 387     }
 388
 389     freeaddrinfo(local);
 390     freeaddrinfo(peer);
 391     return sock;
 392
 393 err:
 394     if (-1 != sock)
 395         closesocket(sock);
 396     if (local)
 397         freeaddrinfo(local);
 398     if (peer)
 399         freeaddrinfo(peer);
 400     return -1;
 401 }
 402
 403 /* compatibility wrapper */
 404 static int inet_parse(QemuOpts *opts, const char *str)
 405 {
 406     const char *optstr, *h;
 407     char addr[64];
 408     char port[33];
 409     int pos;
 410
 411     /* parse address */
 412     if (str[0] == ':') {
 413         /* no host given */
 414         addr[0] = '\0';
 415         if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
 416             fprintf(stderr, "%s: portonly parse error (%s)\n",
 417                     __FUNCTION__, str);
 418             return -1;
 419         }
 420     } else if (str[0] == '[') {
 421         /* IPv6 addr */
 422         if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
 423             fprintf(stderr, "%s: ipv6 parse error (%s)\n",
 424                     __FUNCTION__, str);
 425             return -1;
 426         }
 427         qemu_opt_set(opts, "ipv6", "yes");
 428     } else if (qemu_isdigit(str[0])) {
 429         /* IPv4 addr */
 430         if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
 431             fprintf(stderr, "%s: ipv4 parse error (%s)\n",
 432                     __FUNCTION__, str);
 433             return -1;
 434         }
 435         qemu_opt_set(opts, "ipv4", "yes");
 436     } else {
 437         /* hostname */
 438         if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
 439             fprintf(stderr, "%s: hostname parse error (%s)\n",
 440                     __FUNCTION__, str);
 441             return -1;
 442         }
 443     }
 444     qemu_opt_set(opts, "host", addr);
 445     qemu_opt_set(opts, "port", port);
 446
 447     /* parse options */
 448     optstr = str + pos;
 449     h = strstr(optstr, ",to=");
 450     if (h)
 451         qemu_opt_set(opts, "to", h+4);
 452     if (strstr(optstr, ",ipv4"))
 453         qemu_opt_set(opts, "ipv4", "yes");
 454     if (strstr(optstr, ",ipv6"))
 455         qemu_opt_set(opts, "ipv6", "yes");
 456     return 0;
 457 }
 458
 459 int inet_listen(const char *str, char *ostr, int olen,
 460                 int socktype, int port_offset)
 461 {
 462     QemuOpts *opts;
 463     char *optstr;
 464     int sock = -1;
 465
 466     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 467     if (inet_parse(opts, str) == 0) {
 468         sock = inet_listen_opts(opts, port_offset);
 469         if (sock != -1 && ostr) {
 470             optstr = strchr(str, ',');
 471             if (qemu_opt_get_bool(opts, "ipv6", 0)) {
 472                 snprintf(ostr, olen, "[%s]:%s%s",
 473                          qemu_opt_get(opts, "host"),
 474                          qemu_opt_get(opts, "port"),
 475                          optstr ? optstr : "");
 476             } else {
 477                 snprintf(ostr, olen, "%s:%s%s",
 478                          qemu_opt_get(opts, "host"),
 479                          qemu_opt_get(opts, "port"),
 480                          optstr ? optstr : "");
 481             }
 482         }
 483     }
 484     qemu_opts_del(opts);
 485     return sock;
 486 }
 487
 488 int inet_connect(const char *str, int socktype)
 489 {
 490     QemuOpts *opts;
 491     int sock = -1;
 492
 493     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 494     if (inet_parse(opts, str) == 0)
 495         sock = inet_connect_opts(opts);
 496     qemu_opts_del(opts);
 497     return sock;
 498 }
 499
 500 #ifndef _WIN32
 501
 502 int unix_listen_opts(QemuOpts *opts)
 503 {
 504     struct sockaddr_un un;
 505     const char *path = qemu_opt_get(opts, "path");
 506     int sock, fd;
 507
 508     sock = socket(PF_UNIX, SOCK_STREAM, 0);
 509     if (sock < 0) {
 510         perror("socket(unix)");
 511         return -1;
 512     }
 513
 514     memset(&un, 0, sizeof(un));
 515     un.sun_family = AF_UNIX;
 516     if (path && strlen(path)) {
 517         snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
 518     } else {
 519         char *tmpdir = getenv("TMPDIR");
 520         snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
 521                  tmpdir ? tmpdir : "/tmp");
 522         /*
 523          * This dummy fd usage silences the mktemp() unsecure warning.
 524          * Using mkstemp() doesn't make things more secure here
 525          * though.  bind() complains about existing files, so we have
 526          * to unlink first and thus re-open the race window.  The
 527          * worst case possible is bind() failing, i.e. a DoS attack.
 528          */
 529         fd = mkstemp(un.sun_path); close(fd);
 530         qemu_opt_set(opts, "path", un.sun_path);
 531     }
 532
 533     unlink(un.sun_path);
 534     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
 535         fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno));
 536         goto err;
 537     }
 538     if (listen(sock, 1) < 0) {
 539         fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno));
 540         goto err;
 541     }
 542
 543     if (sockets_debug)
 544         fprintf(stderr, "bind(unix:%s): OK\n", un.sun_path);
 545     return sock;
 546
 547 err:
 548     closesocket(sock);
 549     return -1;
 550 }
 551
 552 int unix_connect_opts(QemuOpts *opts)
 553 {
 554     struct sockaddr_un un;
 555     const char *path = qemu_opt_get(opts, "path");
 556     int sock;
 557
 558     if (NULL == path) {
 559         fprintf(stderr, "unix connect: no path specified\n");
 560         return -1;
 561     }
 562
 563     sock = socket(PF_UNIX, SOCK_STREAM, 0);
 564     if (sock < 0) {
 565         perror("socket(unix)");
 566         return -1;
 567     }
 568
 569     memset(&un, 0, sizeof(un));
 570     un.sun_family = AF_UNIX;
 571     snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
 572     if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
 573         fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno));
 574         return -1;
 575     }
 576
 577     if (sockets_debug)
 578         fprintf(stderr, "connect(unix:%s): OK\n", path);
 579     return sock;
 580 }
 581
 582 /* compatibility wrapper */
 583 int unix_listen(const char *str, char *ostr, int olen)
 584 {
 585     QemuOpts *opts;
 586     char *path, *optstr;
 587     int sock, len;
 588
 589     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 590
 591     optstr = strchr(str, ',');
 592     if (optstr) {
 593         len = optstr - str;
 594         if (len) {
 595             path = qemu_malloc(len+1);
 596             snprintf(path, len+1, "%.*s", len, str);
 597             qemu_opt_set(opts, "path", path);
 598             qemu_free(path);
 599         }
 600     } else {
 601         qemu_opt_set(opts, "path", str);
 602     }
 603
 604     sock = unix_listen_opts(opts);
 605
 606     if (sock != -1 && ostr)
 607         snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
 608     qemu_opts_del(opts);
 609     return sock;
 610 }
 611
 612 int unix_connect(const char *path)
 613 {
 614     QemuOpts *opts;
 615     int sock;
 616
 617     opts = qemu_opts_create(&dummy_opts, NULL, 0);
 618     qemu_opt_set(opts, "path", path);
 619     sock = unix_connect_opts(opts);
 620     qemu_opts_del(opts);
 621     return sock;
 622 }
 623
 624 #else
 625
 626 int unix_listen_opts(QemuOpts *opts)
 627 {
 628     fprintf(stderr, "unix sockets are not available on windows\n");
 629     return -1;
 630 }
 631
 632 int unix_connect_opts(QemuOpts *opts)
 633 {
 634     fprintf(stderr, "unix sockets are not available on windows\n");
 635     return -1;
 636 }
 637
 638 int unix_listen(const char *path, char *ostr, int olen)
 639 {
 640     fprintf(stderr, "unix sockets are not available on windows\n");
 641     return -1;
 642 }
 643
 644 int unix_connect(const char *path)
 645 {
 646     fprintf(stderr, "unix sockets are not available on windows\n");
 647     return -1;
 648 }
 649
 650 #endif