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 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 (connect_state != NULL) { 377 connect_state->current_addr = e; 378 } 379 sock = inet_connect_addr(e, &in_progress, connect_state, errp); 380 if (in_progress) { 381 return sock; 382 } else if (sock >= 0) { 383 /* non blocking socket immediate success, call callback */ 384 if (callback != NULL) { 385 callback(sock, opaque); 386 } 387 break; 388 } 389 } 390 g_free(connect_state); 391 freeaddrinfo(res); 392 return sock; 393 } 394 395 int inet_dgram_opts(QemuOpts *opts, Error **errp) 396 { 397 struct addrinfo ai, *peer = NULL, *local = NULL; 398 const char *addr; 399 const char *port; 400 int sock = -1, rc; 401 402 /* lookup peer addr */ 403 memset(&ai,0, sizeof(ai)); 404 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 405 ai.ai_family = PF_UNSPEC; 406 ai.ai_socktype = SOCK_DGRAM; 407 408 addr = qemu_opt_get(opts, "host"); 409 port = qemu_opt_get(opts, "port"); 410 if (addr == NULL || strlen(addr) == 0) { 411 addr = "localhost"; 412 } 413 if (port == NULL || strlen(port) == 0) { 414 error_setg(errp, "remote port not specified"); 415 return -1; 416 } 417 418 if (qemu_opt_get_bool(opts, "ipv4", 0)) 419 ai.ai_family = PF_INET; 420 if (qemu_opt_get_bool(opts, "ipv6", 0)) 421 ai.ai_family = PF_INET6; 422 423 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) { 424 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 425 gai_strerror(rc)); 426 return -1; 427 } 428 429 /* lookup local addr */ 430 memset(&ai,0, sizeof(ai)); 431 ai.ai_flags = AI_PASSIVE; 432 ai.ai_family = peer->ai_family; 433 ai.ai_socktype = SOCK_DGRAM; 434 435 addr = qemu_opt_get(opts, "localaddr"); 436 port = qemu_opt_get(opts, "localport"); 437 if (addr == NULL || strlen(addr) == 0) { 438 addr = NULL; 439 } 440 if (!port || strlen(port) == 0) 441 port = "0"; 442 443 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) { 444 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 445 gai_strerror(rc)); 446 goto err; 447 } 448 449 /* create socket */ 450 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol); 451 if (sock < 0) { 452 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED); 453 goto err; 454 } 455 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on)); 456 457 /* bind socket */ 458 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) { 459 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED); 460 goto err; 461 } 462 463 /* connect to peer */ 464 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) { 465 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED); 466 goto err; 467 } 468 469 freeaddrinfo(local); 470 freeaddrinfo(peer); 471 return sock; 472 473 err: 474 if (-1 != sock) 475 closesocket(sock); 476 if (local) 477 freeaddrinfo(local); 478 if (peer) 479 freeaddrinfo(peer); 480 return -1; 481 } 482 483 /* compatibility wrapper */ 484 static InetSocketAddress *inet_parse(const char *str, Error **errp) 485 { 486 InetSocketAddress *addr; 487 const char *optstr, *h; 488 char host[64]; 489 char port[33]; 490 int to; 491 int pos; 492 493 addr = g_new0(InetSocketAddress, 1); 494 495 /* parse address */ 496 if (str[0] == ':') { 497 /* no host given */ 498 host[0] = '\0'; 499 if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) { 500 error_setg(errp, "error parsing port in address '%s'", str); 501 goto fail; 502 } 503 } else if (str[0] == '[') { 504 /* IPv6 addr */ 505 if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) { 506 error_setg(errp, "error parsing IPv6 address '%s'", str); 507 goto fail; 508 } 509 addr->ipv6 = addr->has_ipv6 = true; 510 } else if (qemu_isdigit(str[0])) { 511 /* IPv4 addr */ 512 if (2 != sscanf(str, "%64[0-9.]:%32[^,]%n", host, port, &pos)) { 513 error_setg(errp, "error parsing IPv4 address '%s'", str); 514 goto fail; 515 } 516 addr->ipv4 = addr->has_ipv4 = true; 517 } else { 518 /* hostname */ 519 if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) { 520 error_setg(errp, "error parsing address '%s'", str); 521 goto fail; 522 } 523 } 524 525 addr->host = g_strdup(host); 526 addr->port = g_strdup(port); 527 528 /* parse options */ 529 optstr = str + pos; 530 h = strstr(optstr, ",to="); 531 if (h) { 532 h += 4; 533 if (sscanf(h, "%d%n", &to, &pos) != 1 || 534 (h[pos] != '\0' && h[pos] != ',')) { 535 error_setg(errp, "error parsing to= argument"); 536 goto fail; 537 } 538 addr->has_to = true; 539 addr->to = to; 540 } 541 if (strstr(optstr, ",ipv4")) { 542 addr->ipv4 = addr->has_ipv4 = true; 543 } 544 if (strstr(optstr, ",ipv6")) { 545 addr->ipv6 = addr->has_ipv6 = true; 546 } 547 return addr; 548 549 fail: 550 qapi_free_InetSocketAddress(addr); 551 return NULL; 552 } 553 554 static void inet_addr_to_opts(QemuOpts *opts, InetSocketAddress *addr) 555 { 556 bool ipv4 = addr->ipv4 || !addr->has_ipv4; 557 bool ipv6 = addr->ipv6 || !addr->has_ipv6; 558 559 if (!ipv4 || !ipv6) { 560 qemu_opt_set_bool(opts, "ipv4", ipv4); 561 qemu_opt_set_bool(opts, "ipv6", ipv6); 562 } 563 if (addr->has_to) { 564 char to[20]; 565 snprintf(to, sizeof(to), "%d", addr->to); 566 qemu_opt_set(opts, "to", to); 567 } 568 qemu_opt_set(opts, "host", addr->host); 569 qemu_opt_set(opts, "port", addr->port); 570 } 571 572 int inet_listen(const char *str, char *ostr, int olen, 573 int socktype, int port_offset, Error **errp) 574 { 575 QemuOpts *opts; 576 char *optstr; 577 int sock = -1; 578 InetSocketAddress *addr; 579 580 addr = inet_parse(str, errp); 581 if (addr != NULL) { 582 opts = qemu_opts_create_nofail(&dummy_opts); 583 inet_addr_to_opts(opts, addr); 584 qapi_free_InetSocketAddress(addr); 585 sock = inet_listen_opts(opts, port_offset, errp); 586 if (sock != -1 && ostr) { 587 optstr = strchr(str, ','); 588 if (qemu_opt_get_bool(opts, "ipv6", 0)) { 589 snprintf(ostr, olen, "[%s]:%s%s", 590 qemu_opt_get(opts, "host"), 591 qemu_opt_get(opts, "port"), 592 optstr ? optstr : ""); 593 } else { 594 snprintf(ostr, olen, "%s:%s%s", 595 qemu_opt_get(opts, "host"), 596 qemu_opt_get(opts, "port"), 597 optstr ? optstr : ""); 598 } 599 } 600 qemu_opts_del(opts); 601 } 602 return sock; 603 } 604 605 /** 606 * Create a blocking socket and connect it to an address. 607 * 608 * @str: address string 609 * @errp: set in case of an error 610 * 611 * Returns -1 in case of error, file descriptor on success 612 **/ 613 int inet_connect(const char *str, Error **errp) 614 { 615 QemuOpts *opts; 616 int sock = -1; 617 InetSocketAddress *addr; 618 619 addr = inet_parse(str, errp); 620 if (addr != NULL) { 621 opts = qemu_opts_create_nofail(&dummy_opts); 622 inet_addr_to_opts(opts, addr); 623 qapi_free_InetSocketAddress(addr); 624 sock = inet_connect_opts(opts, errp, NULL, NULL); 625 qemu_opts_del(opts); 626 } 627 return sock; 628 } 629 630 /** 631 * Create a non-blocking socket and connect it to an address. 632 * Calls the callback function with fd in case of success or -1 in case of 633 * error. 634 * 635 * @str: address string 636 * @callback: callback function that is called when connect completes, 637 * cannot be NULL. 638 * @opaque: opaque for callback function 639 * @errp: set in case of an error 640 * 641 * Returns: -1 on immediate error, file descriptor on success. 642 **/ 643 int inet_nonblocking_connect(const char *str, 644 NonBlockingConnectHandler *callback, 645 void *opaque, Error **errp) 646 { 647 QemuOpts *opts; 648 int sock = -1; 649 InetSocketAddress *addr; 650 651 g_assert(callback != NULL); 652 653 addr = inet_parse(str, errp); 654 if (addr != NULL) { 655 opts = qemu_opts_create_nofail(&dummy_opts); 656 inet_addr_to_opts(opts, addr); 657 qapi_free_InetSocketAddress(addr); 658 sock = inet_connect_opts(opts, errp, callback, opaque); 659 qemu_opts_del(opts); 660 } 661 return sock; 662 } 663 664 #ifndef _WIN32 665 666 int unix_listen_opts(QemuOpts *opts, Error **errp) 667 { 668 struct sockaddr_un un; 669 const char *path = qemu_opt_get(opts, "path"); 670 int sock, fd; 671 672 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 673 if (sock < 0) { 674 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED); 675 return -1; 676 } 677 678 memset(&un, 0, sizeof(un)); 679 un.sun_family = AF_UNIX; 680 if (path && strlen(path)) { 681 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); 682 } else { 683 char *tmpdir = getenv("TMPDIR"); 684 snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX", 685 tmpdir ? tmpdir : "/tmp"); 686 /* 687 * This dummy fd usage silences the mktemp() unsecure warning. 688 * Using mkstemp() doesn't make things more secure here 689 * though. bind() complains about existing files, so we have 690 * to unlink first and thus re-open the race window. The 691 * worst case possible is bind() failing, i.e. a DoS attack. 692 */ 693 fd = mkstemp(un.sun_path); close(fd); 694 qemu_opt_set(opts, "path", un.sun_path); 695 } 696 697 unlink(un.sun_path); 698 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 699 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED); 700 goto err; 701 } 702 if (listen(sock, 1) < 0) { 703 error_set_errno(errp, errno, QERR_SOCKET_LISTEN_FAILED); 704 goto err; 705 } 706 707 return sock; 708 709 err: 710 closesocket(sock); 711 return -1; 712 } 713 714 int unix_connect_opts(QemuOpts *opts, Error **errp, 715 NonBlockingConnectHandler *callback, void *opaque) 716 { 717 struct sockaddr_un un; 718 const char *path = qemu_opt_get(opts, "path"); 719 ConnectState *connect_state = NULL; 720 int sock, rc; 721 722 if (NULL == path) { 723 error_setg(errp, "unix connect: no path specified\n"); 724 return -1; 725 } 726 727 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 728 if (sock < 0) { 729 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED); 730 return -1; 731 } 732 if (callback != NULL) { 733 connect_state = g_malloc0(sizeof(*connect_state)); 734 connect_state->callback = callback; 735 connect_state->opaque = opaque; 736 socket_set_nonblock(sock); 737 } 738 739 memset(&un, 0, sizeof(un)); 740 un.sun_family = AF_UNIX; 741 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); 742 743 /* connect to peer */ 744 do { 745 rc = 0; 746 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { 747 rc = -socket_error(); 748 } 749 } while (rc == -EINTR); 750 751 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 752 connect_state->fd = sock; 753 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect, 754 connect_state); 755 return sock; 756 } else if (rc >= 0) { 757 /* non blocking socket immediate success, call callback */ 758 if (callback != NULL) { 759 callback(sock, opaque); 760 } 761 } 762 763 if (rc < 0) { 764 error_set_errno(errp, -rc, QERR_SOCKET_CONNECT_FAILED); 765 close(sock); 766 sock = -1; 767 } 768 769 g_free(connect_state); 770 return sock; 771 } 772 773 #else 774 775 int unix_listen_opts(QemuOpts *opts, Error **errp) 776 { 777 error_setg(errp, "unix sockets are not available on windows"); 778 errno = ENOTSUP; 779 return -1; 780 } 781 782 int unix_connect_opts(QemuOpts *opts, Error **errp, 783 NonBlockingConnectHandler *callback, void *opaque) 784 { 785 error_setg(errp, "unix sockets are not available on windows"); 786 errno = ENOTSUP; 787 return -1; 788 } 789 #endif 790 791 /* compatibility wrapper */ 792 int unix_listen(const char *str, char *ostr, int olen, Error **errp) 793 { 794 QemuOpts *opts; 795 char *path, *optstr; 796 int sock, len; 797 798 opts = qemu_opts_create_nofail(&dummy_opts); 799 800 optstr = strchr(str, ','); 801 if (optstr) { 802 len = optstr - str; 803 if (len) { 804 path = g_malloc(len+1); 805 snprintf(path, len+1, "%.*s", len, str); 806 qemu_opt_set(opts, "path", path); 807 g_free(path); 808 } 809 } else { 810 qemu_opt_set(opts, "path", str); 811 } 812 813 sock = unix_listen_opts(opts, errp); 814 815 if (sock != -1 && ostr) 816 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : ""); 817 qemu_opts_del(opts); 818 return sock; 819 } 820 821 int unix_connect(const char *path, Error **errp) 822 { 823 QemuOpts *opts; 824 int sock; 825 826 opts = qemu_opts_create_nofail(&dummy_opts); 827 qemu_opt_set(opts, "path", path); 828 sock = unix_connect_opts(opts, errp, NULL, NULL); 829 qemu_opts_del(opts); 830 return sock; 831 } 832 833 834 int unix_nonblocking_connect(const char *path, 835 NonBlockingConnectHandler *callback, 836 void *opaque, Error **errp) 837 { 838 QemuOpts *opts; 839 int sock = -1; 840 841 g_assert(callback != NULL); 842 843 opts = qemu_opts_create_nofail(&dummy_opts); 844 qemu_opt_set(opts, "path", path); 845 sock = unix_connect_opts(opts, errp, callback, opaque); 846 qemu_opts_del(opts); 847 return sock; 848 } 849 850 SocketAddress *socket_parse(const char *str, Error **errp) 851 { 852 SocketAddress *addr = NULL; 853 854 addr = g_new(SocketAddress, 1); 855 if (strstart(str, "unix:", NULL)) { 856 if (str[5] == '\0') { 857 error_setg(errp, "invalid Unix socket address\n"); 858 goto fail; 859 } else { 860 addr->kind = SOCKET_ADDRESS_KIND_UNIX; 861 addr->q_unix = g_new(UnixSocketAddress, 1); 862 addr->q_unix->path = g_strdup(str + 5); 863 } 864 } else if (strstart(str, "fd:", NULL)) { 865 if (str[3] == '\0') { 866 error_setg(errp, "invalid file descriptor address\n"); 867 goto fail; 868 } else { 869 addr->kind = SOCKET_ADDRESS_KIND_FD; 870 addr->fd = g_new(String, 1); 871 addr->fd->str = g_strdup(str + 3); 872 } 873 } else { 874 addr->kind = SOCKET_ADDRESS_KIND_INET; 875 addr->inet = g_new(InetSocketAddress, 1); 876 addr->inet = inet_parse(str, errp); 877 if (addr->inet == NULL) { 878 goto fail; 879 } 880 } 881 return addr; 882 883 fail: 884 qapi_free_SocketAddress(addr); 885 return NULL; 886 } 887 888 int socket_connect(SocketAddress *addr, Error **errp, 889 NonBlockingConnectHandler *callback, void *opaque) 890 { 891 QemuOpts *opts; 892 int fd; 893 894 opts = qemu_opts_create_nofail(&dummy_opts); 895 switch (addr->kind) { 896 case SOCKET_ADDRESS_KIND_INET: 897 inet_addr_to_opts(opts, addr->inet); 898 fd = inet_connect_opts(opts, errp, callback, opaque); 899 break; 900 901 case SOCKET_ADDRESS_KIND_UNIX: 902 qemu_opt_set(opts, "path", addr->q_unix->path); 903 fd = unix_connect_opts(opts, errp, callback, opaque); 904 break; 905 906 case SOCKET_ADDRESS_KIND_FD: 907 fd = monitor_get_fd(cur_mon, addr->fd->str, errp); 908 if (callback) { 909 callback(fd, opaque); 910 } 911 break; 912 913 default: 914 abort(); 915 } 916 qemu_opts_del(opts); 917 return fd; 918 } 919 920 int socket_listen(SocketAddress *addr, Error **errp) 921 { 922 QemuOpts *opts; 923 int fd; 924 925 opts = qemu_opts_create_nofail(&dummy_opts); 926 switch (addr->kind) { 927 case SOCKET_ADDRESS_KIND_INET: 928 inet_addr_to_opts(opts, addr->inet); 929 fd = inet_listen_opts(opts, 0, errp); 930 break; 931 932 case SOCKET_ADDRESS_KIND_UNIX: 933 qemu_opt_set(opts, "path", addr->q_unix->path); 934 fd = unix_listen_opts(opts, errp); 935 break; 936 937 case SOCKET_ADDRESS_KIND_FD: 938 fd = monitor_get_fd(cur_mon, addr->fd->str, errp); 939 break; 940 941 default: 942 abort(); 943 } 944 qemu_opts_del(opts); 945 return fd; 946 } 947 948 #ifdef _WIN32 949 static void socket_cleanup(void) 950 { 951 WSACleanup(); 952 } 953 #endif 954 955 int socket_init(void) 956 { 957 #ifdef _WIN32 958 WSADATA Data; 959 int ret, err; 960 961 ret = WSAStartup(MAKEWORD(2,2), &Data); 962 if (ret != 0) { 963 err = WSAGetLastError(); 964 fprintf(stderr, "WSAStartup: %d\n", err); 965 return -1; 966 } 967 atexit(socket_cleanup); 968 #endif 969 return 0; 970 } 971