util/qemu-sockets.c

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