util/qemu-sockets.c

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