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 temporarely until all users are converted to QemuOpts */ 37 static QemuOptsList dummy_opts = { 38 .name = "dummy", 39 .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.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 qemu_setsockopt(slisten, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); 160 #ifdef IPV6_V6ONLY 161 if (e->ai_family == PF_INET6) { 162 /* listen on both ipv4 and ipv6 */ 163 qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &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 = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &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 qemu_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &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 static 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, 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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(&dummy_opts); 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 } 1000