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 "qemu/osdep.h" 19 20 #include "monitor/monitor.h" 21 #include "qemu/sockets.h" 22 #include "qemu/main-loop.h" 23 #include "qapi/qmp-input-visitor.h" 24 #include "qapi/qmp-output-visitor.h" 25 #include "qapi-visit.h" 26 27 #ifndef AI_ADDRCONFIG 28 # define AI_ADDRCONFIG 0 29 #endif 30 #ifndef AI_V4MAPPED 31 # define AI_V4MAPPED 0 32 #endif 33 34 35 static int inet_getport(struct addrinfo *e) 36 { 37 struct sockaddr_in *i4; 38 struct sockaddr_in6 *i6; 39 40 switch (e->ai_family) { 41 case PF_INET6: 42 i6 = (void*)e->ai_addr; 43 return ntohs(i6->sin6_port); 44 case PF_INET: 45 i4 = (void*)e->ai_addr; 46 return ntohs(i4->sin_port); 47 default: 48 return 0; 49 } 50 } 51 52 static void inet_setport(struct addrinfo *e, int port) 53 { 54 struct sockaddr_in *i4; 55 struct sockaddr_in6 *i6; 56 57 switch (e->ai_family) { 58 case PF_INET6: 59 i6 = (void*)e->ai_addr; 60 i6->sin6_port = htons(port); 61 break; 62 case PF_INET: 63 i4 = (void*)e->ai_addr; 64 i4->sin_port = htons(port); 65 break; 66 } 67 } 68 69 NetworkAddressFamily inet_netfamily(int family) 70 { 71 switch (family) { 72 case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6; 73 case PF_INET: return NETWORK_ADDRESS_FAMILY_IPV4; 74 case PF_UNIX: return NETWORK_ADDRESS_FAMILY_UNIX; 75 } 76 return NETWORK_ADDRESS_FAMILY_UNKNOWN; 77 } 78 79 /* 80 * Matrix we're trying to apply 81 * 82 * ipv4 ipv6 family 83 * - - PF_UNSPEC 84 * - f PF_INET 85 * - t PF_INET6 86 * f - PF_INET6 87 * f f <error> 88 * f t PF_INET6 89 * t - PF_INET 90 * t f PF_INET 91 * t t PF_INET6 92 * 93 * NB, this matrix is only about getting the neccessary results 94 * from getaddrinfo(). Some of the cases require further work 95 * after reading results from getaddrinfo in order to fully 96 * apply the logic the end user wants. eg with the last case 97 * ipv4=t + ipv6=t + PF_INET6, getaddrinfo alone can only 98 * guarantee the ipv6=t part of the request - we need more 99 * checks to provide ipv4=t part of the guarantee. This is 100 * outside scope of this method and not currently handled by 101 * callers at all. 102 */ 103 static int inet_ai_family_from_address(InetSocketAddress *addr, 104 Error **errp) 105 { 106 if (addr->has_ipv6 && addr->has_ipv4 && 107 !addr->ipv6 && !addr->ipv4) { 108 error_setg(errp, "Cannot disable IPv4 and IPv6 at same time"); 109 return PF_UNSPEC; 110 } 111 if ((addr->has_ipv6 && addr->ipv6) || (addr->has_ipv4 && !addr->ipv4)) { 112 return PF_INET6; 113 } 114 if ((addr->has_ipv4 && addr->ipv4) || (addr->has_ipv6 && !addr->ipv6)) { 115 return PF_INET; 116 } 117 return PF_UNSPEC; 118 } 119 120 static int inet_listen_saddr(InetSocketAddress *saddr, 121 int port_offset, 122 bool update_addr, 123 Error **errp) 124 { 125 struct addrinfo ai,*res,*e; 126 char port[33]; 127 char uaddr[INET6_ADDRSTRLEN+1]; 128 char uport[33]; 129 int slisten, rc, port_min, port_max, p; 130 Error *err = NULL; 131 132 memset(&ai,0, sizeof(ai)); 133 ai.ai_flags = AI_PASSIVE; 134 ai.ai_family = inet_ai_family_from_address(saddr, &err); 135 ai.ai_socktype = SOCK_STREAM; 136 137 if (err) { 138 error_propagate(errp, err); 139 return -1; 140 } 141 142 if (saddr->host == NULL) { 143 error_setg(errp, "host not specified"); 144 return -1; 145 } 146 if (saddr->port != NULL) { 147 pstrcpy(port, sizeof(port), saddr->port); 148 } else { 149 port[0] = '\0'; 150 } 151 152 /* lookup */ 153 if (port_offset) { 154 unsigned long long baseport; 155 if (strlen(port) == 0) { 156 error_setg(errp, "port not specified"); 157 return -1; 158 } 159 if (parse_uint_full(port, &baseport, 10) < 0) { 160 error_setg(errp, "can't convert to a number: %s", port); 161 return -1; 162 } 163 if (baseport > 65535 || 164 baseport + port_offset > 65535) { 165 error_setg(errp, "port %s out of range", port); 166 return -1; 167 } 168 snprintf(port, sizeof(port), "%d", (int)baseport + port_offset); 169 } 170 rc = getaddrinfo(strlen(saddr->host) ? saddr->host : NULL, 171 strlen(port) ? port : NULL, &ai, &res); 172 if (rc != 0) { 173 error_setg(errp, "address resolution failed for %s:%s: %s", 174 saddr->host, port, gai_strerror(rc)); 175 return -1; 176 } 177 178 /* create socket + bind */ 179 for (e = res; e != NULL; e = e->ai_next) { 180 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 181 uaddr,INET6_ADDRSTRLEN,uport,32, 182 NI_NUMERICHOST | NI_NUMERICSERV); 183 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol); 184 if (slisten < 0) { 185 if (!e->ai_next) { 186 error_setg_errno(errp, errno, "Failed to create socket"); 187 } 188 continue; 189 } 190 191 socket_set_fast_reuse(slisten); 192 #ifdef IPV6_V6ONLY 193 if (e->ai_family == PF_INET6) { 194 /* listen on both ipv4 and ipv6 */ 195 const int off = 0; 196 qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off, 197 sizeof(off)); 198 } 199 #endif 200 201 port_min = inet_getport(e); 202 port_max = saddr->has_to ? saddr->to + port_offset : port_min; 203 for (p = port_min; p <= port_max; p++) { 204 inet_setport(e, p); 205 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) { 206 goto listen; 207 } 208 if (p == port_max) { 209 if (!e->ai_next) { 210 error_setg_errno(errp, errno, "Failed to bind socket"); 211 } 212 } 213 } 214 closesocket(slisten); 215 } 216 freeaddrinfo(res); 217 return -1; 218 219 listen: 220 if (listen(slisten,1) != 0) { 221 error_setg_errno(errp, errno, "Failed to listen on socket"); 222 closesocket(slisten); 223 freeaddrinfo(res); 224 return -1; 225 } 226 if (update_addr) { 227 g_free(saddr->host); 228 saddr->host = g_strdup(uaddr); 229 g_free(saddr->port); 230 saddr->port = g_strdup_printf("%d", 231 inet_getport(e) - port_offset); 232 saddr->has_ipv6 = saddr->ipv6 = e->ai_family == PF_INET6; 233 saddr->has_ipv4 = saddr->ipv4 = e->ai_family != PF_INET6; 234 } 235 freeaddrinfo(res); 236 return slisten; 237 } 238 239 #ifdef _WIN32 240 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 241 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY) 242 #else 243 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 244 ((rc) == -EINPROGRESS) 245 #endif 246 247 /* Struct to store connect state for non blocking connect */ 248 typedef struct ConnectState { 249 int fd; 250 struct addrinfo *addr_list; 251 struct addrinfo *current_addr; 252 NonBlockingConnectHandler *callback; 253 void *opaque; 254 } ConnectState; 255 256 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress, 257 ConnectState *connect_state, Error **errp); 258 259 static void wait_for_connect(void *opaque) 260 { 261 ConnectState *s = opaque; 262 int val = 0, rc = 0; 263 socklen_t valsize = sizeof(val); 264 bool in_progress; 265 Error *err = NULL; 266 267 qemu_set_fd_handler(s->fd, NULL, NULL, NULL); 268 269 do { 270 rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize); 271 } while (rc == -1 && errno == EINTR); 272 273 /* update rc to contain error */ 274 if (!rc && val) { 275 rc = -1; 276 errno = val; 277 } 278 279 /* connect error */ 280 if (rc < 0) { 281 error_setg_errno(&err, errno, "Error connecting to socket"); 282 closesocket(s->fd); 283 s->fd = rc; 284 } 285 286 /* try to connect to the next address on the list */ 287 if (s->current_addr) { 288 while (s->current_addr->ai_next != NULL && s->fd < 0) { 289 s->current_addr = s->current_addr->ai_next; 290 s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL); 291 if (s->fd < 0) { 292 error_free(err); 293 err = NULL; 294 error_setg_errno(&err, errno, "Unable to start socket connect"); 295 } 296 /* connect in progress */ 297 if (in_progress) { 298 goto out; 299 } 300 } 301 302 freeaddrinfo(s->addr_list); 303 } 304 305 if (s->callback) { 306 s->callback(s->fd, err, s->opaque); 307 } 308 g_free(s); 309 out: 310 error_free(err); 311 } 312 313 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress, 314 ConnectState *connect_state, Error **errp) 315 { 316 int sock, rc; 317 318 *in_progress = false; 319 320 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 321 if (sock < 0) { 322 error_setg_errno(errp, errno, "Failed to create socket"); 323 return -1; 324 } 325 socket_set_fast_reuse(sock); 326 if (connect_state != NULL) { 327 qemu_set_nonblock(sock); 328 } 329 /* connect to peer */ 330 do { 331 rc = 0; 332 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) { 333 rc = -errno; 334 } 335 } while (rc == -EINTR); 336 337 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 338 connect_state->fd = sock; 339 qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state); 340 *in_progress = true; 341 } else if (rc < 0) { 342 error_setg_errno(errp, errno, "Failed to connect socket"); 343 closesocket(sock); 344 return -1; 345 } 346 return sock; 347 } 348 349 static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr, 350 Error **errp) 351 { 352 struct addrinfo ai, *res; 353 int rc; 354 Error *err = NULL; 355 356 memset(&ai, 0, sizeof(ai)); 357 358 ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG; 359 ai.ai_family = inet_ai_family_from_address(saddr, &err); 360 ai.ai_socktype = SOCK_STREAM; 361 362 if (err) { 363 error_propagate(errp, err); 364 return NULL; 365 } 366 367 if (saddr->host == NULL || saddr->port == NULL) { 368 error_setg(errp, "host and/or port not specified"); 369 return NULL; 370 } 371 372 /* lookup */ 373 rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); 374 if (rc != 0) { 375 error_setg(errp, "address resolution failed for %s:%s: %s", 376 saddr->host, saddr->port, gai_strerror(rc)); 377 return NULL; 378 } 379 return res; 380 } 381 382 /** 383 * Create a socket and connect it to an address. 384 * 385 * @saddr: Inet socket address specification 386 * @errp: set on error 387 * @callback: callback function for non-blocking connect 388 * @opaque: opaque for callback function 389 * 390 * Returns: -1 on error, file descriptor on success. 391 * 392 * If @callback is non-null, the connect is non-blocking. If this 393 * function succeeds, callback will be called when the connection 394 * completes, with the file descriptor on success, or -1 on error. 395 */ 396 static int inet_connect_saddr(InetSocketAddress *saddr, Error **errp, 397 NonBlockingConnectHandler *callback, void *opaque) 398 { 399 Error *local_err = NULL; 400 struct addrinfo *res, *e; 401 int sock = -1; 402 bool in_progress; 403 ConnectState *connect_state = NULL; 404 405 res = inet_parse_connect_saddr(saddr, errp); 406 if (!res) { 407 return -1; 408 } 409 410 if (callback != NULL) { 411 connect_state = g_malloc0(sizeof(*connect_state)); 412 connect_state->addr_list = res; 413 connect_state->callback = callback; 414 connect_state->opaque = opaque; 415 } 416 417 for (e = res; e != NULL; e = e->ai_next) { 418 error_free(local_err); 419 local_err = NULL; 420 if (connect_state != NULL) { 421 connect_state->current_addr = e; 422 } 423 sock = inet_connect_addr(e, &in_progress, connect_state, &local_err); 424 if (sock >= 0) { 425 break; 426 } 427 } 428 429 if (sock < 0) { 430 error_propagate(errp, local_err); 431 } else if (in_progress) { 432 /* wait_for_connect() will do the rest */ 433 return sock; 434 } else { 435 if (callback) { 436 callback(sock, NULL, opaque); 437 } 438 } 439 g_free(connect_state); 440 freeaddrinfo(res); 441 return sock; 442 } 443 444 static int inet_dgram_saddr(InetSocketAddress *sraddr, 445 InetSocketAddress *sladdr, 446 Error **errp) 447 { 448 struct addrinfo ai, *peer = NULL, *local = NULL; 449 const char *addr; 450 const char *port; 451 int sock = -1, rc; 452 Error *err = NULL; 453 454 /* lookup peer addr */ 455 memset(&ai,0, sizeof(ai)); 456 ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG; 457 ai.ai_family = inet_ai_family_from_address(sraddr, &err); 458 ai.ai_socktype = SOCK_DGRAM; 459 460 if (err) { 461 error_propagate(errp, err); 462 goto err; 463 } 464 465 addr = sraddr->host; 466 port = sraddr->port; 467 if (addr == NULL || strlen(addr) == 0) { 468 addr = "localhost"; 469 } 470 if (port == NULL || strlen(port) == 0) { 471 error_setg(errp, "remote port not specified"); 472 goto err; 473 } 474 475 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) { 476 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 477 gai_strerror(rc)); 478 goto err; 479 } 480 481 /* lookup local addr */ 482 memset(&ai,0, sizeof(ai)); 483 ai.ai_flags = AI_PASSIVE; 484 ai.ai_family = peer->ai_family; 485 ai.ai_socktype = SOCK_DGRAM; 486 487 if (sladdr) { 488 addr = sladdr->host; 489 port = sladdr->port; 490 if (addr == NULL || strlen(addr) == 0) { 491 addr = NULL; 492 } 493 if (!port || strlen(port) == 0) { 494 port = "0"; 495 } 496 } else { 497 addr = NULL; 498 port = "0"; 499 } 500 501 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) { 502 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 503 gai_strerror(rc)); 504 goto err; 505 } 506 507 /* create socket */ 508 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol); 509 if (sock < 0) { 510 error_setg_errno(errp, errno, "Failed to create socket"); 511 goto err; 512 } 513 socket_set_fast_reuse(sock); 514 515 /* bind socket */ 516 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) { 517 error_setg_errno(errp, errno, "Failed to bind socket"); 518 goto err; 519 } 520 521 /* connect to peer */ 522 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) { 523 error_setg_errno(errp, errno, "Failed to connect socket"); 524 goto err; 525 } 526 527 freeaddrinfo(local); 528 freeaddrinfo(peer); 529 return sock; 530 531 err: 532 if (-1 != sock) 533 closesocket(sock); 534 if (local) 535 freeaddrinfo(local); 536 if (peer) 537 freeaddrinfo(peer); 538 return -1; 539 } 540 541 /* compatibility wrapper */ 542 InetSocketAddress *inet_parse(const char *str, Error **errp) 543 { 544 InetSocketAddress *addr; 545 const char *optstr, *h; 546 char host[65]; 547 char port[33]; 548 int to; 549 int pos; 550 551 addr = g_new0(InetSocketAddress, 1); 552 553 /* parse address */ 554 if (str[0] == ':') { 555 /* no host given */ 556 host[0] = '\0'; 557 if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) { 558 error_setg(errp, "error parsing port in address '%s'", str); 559 goto fail; 560 } 561 } else if (str[0] == '[') { 562 /* IPv6 addr */ 563 if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) { 564 error_setg(errp, "error parsing IPv6 address '%s'", str); 565 goto fail; 566 } 567 addr->ipv6 = addr->has_ipv6 = true; 568 } else { 569 /* hostname or IPv4 addr */ 570 if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) { 571 error_setg(errp, "error parsing address '%s'", str); 572 goto fail; 573 } 574 if (host[strspn(host, "0123456789.")] == '\0') { 575 addr->ipv4 = addr->has_ipv4 = true; 576 } 577 } 578 579 addr->host = g_strdup(host); 580 addr->port = g_strdup(port); 581 582 /* parse options */ 583 optstr = str + pos; 584 h = strstr(optstr, ",to="); 585 if (h) { 586 h += 4; 587 if (sscanf(h, "%d%n", &to, &pos) != 1 || 588 (h[pos] != '\0' && h[pos] != ',')) { 589 error_setg(errp, "error parsing to= argument"); 590 goto fail; 591 } 592 addr->has_to = true; 593 addr->to = to; 594 } 595 if (strstr(optstr, ",ipv4")) { 596 addr->ipv4 = addr->has_ipv4 = true; 597 } 598 if (strstr(optstr, ",ipv6")) { 599 addr->ipv6 = addr->has_ipv6 = true; 600 } 601 return addr; 602 603 fail: 604 qapi_free_InetSocketAddress(addr); 605 return NULL; 606 } 607 608 int inet_listen(const char *str, char *ostr, int olen, 609 int socktype, int port_offset, Error **errp) 610 { 611 char *optstr; 612 int sock = -1; 613 InetSocketAddress *addr; 614 615 addr = inet_parse(str, errp); 616 if (addr != NULL) { 617 sock = inet_listen_saddr(addr, port_offset, true, errp); 618 if (sock != -1 && ostr) { 619 optstr = strchr(str, ','); 620 if (addr->ipv6) { 621 snprintf(ostr, olen, "[%s]:%s%s", 622 addr->host, 623 addr->port, 624 optstr ? optstr : ""); 625 } else { 626 snprintf(ostr, olen, "%s:%s%s", 627 addr->host, 628 addr->port, 629 optstr ? optstr : ""); 630 } 631 } 632 qapi_free_InetSocketAddress(addr); 633 } 634 return sock; 635 } 636 637 /** 638 * Create a blocking socket and connect it to an address. 639 * 640 * @str: address string 641 * @errp: set in case of an error 642 * 643 * Returns -1 in case of error, file descriptor on success 644 **/ 645 int inet_connect(const char *str, Error **errp) 646 { 647 int sock = -1; 648 InetSocketAddress *addr; 649 650 addr = inet_parse(str, errp); 651 if (addr != NULL) { 652 sock = inet_connect_saddr(addr, errp, NULL, NULL); 653 qapi_free_InetSocketAddress(addr); 654 } 655 return sock; 656 } 657 658 /** 659 * Create a non-blocking socket and connect it to an address. 660 * Calls the callback function with fd in case of success or -1 in case of 661 * error. 662 * 663 * @str: address string 664 * @callback: callback function that is called when connect completes, 665 * cannot be NULL. 666 * @opaque: opaque for callback function 667 * @errp: set in case of an error 668 * 669 * Returns: -1 on immediate error, file descriptor on success. 670 **/ 671 int inet_nonblocking_connect(const char *str, 672 NonBlockingConnectHandler *callback, 673 void *opaque, Error **errp) 674 { 675 int sock = -1; 676 InetSocketAddress *addr; 677 678 g_assert(callback != NULL); 679 680 addr = inet_parse(str, errp); 681 if (addr != NULL) { 682 sock = inet_connect_saddr(addr, errp, callback, opaque); 683 qapi_free_InetSocketAddress(addr); 684 } 685 return sock; 686 } 687 688 #ifndef _WIN32 689 690 static int unix_listen_saddr(UnixSocketAddress *saddr, 691 bool update_addr, 692 Error **errp) 693 { 694 struct sockaddr_un un; 695 int sock, fd; 696 697 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 698 if (sock < 0) { 699 error_setg_errno(errp, errno, "Failed to create Unix socket"); 700 return -1; 701 } 702 703 memset(&un, 0, sizeof(un)); 704 un.sun_family = AF_UNIX; 705 if (saddr->path && strlen(saddr->path)) { 706 snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path); 707 } else { 708 const char *tmpdir = getenv("TMPDIR"); 709 tmpdir = tmpdir ? tmpdir : "/tmp"; 710 if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX", 711 tmpdir) >= sizeof(un.sun_path)) { 712 error_setg_errno(errp, errno, 713 "TMPDIR environment variable (%s) too large", tmpdir); 714 goto err; 715 } 716 717 /* 718 * This dummy fd usage silences the mktemp() unsecure warning. 719 * Using mkstemp() doesn't make things more secure here 720 * though. bind() complains about existing files, so we have 721 * to unlink first and thus re-open the race window. The 722 * worst case possible is bind() failing, i.e. a DoS attack. 723 */ 724 fd = mkstemp(un.sun_path); 725 if (fd < 0) { 726 error_setg_errno(errp, errno, 727 "Failed to make a temporary socket name in %s", tmpdir); 728 goto err; 729 } 730 close(fd); 731 if (update_addr) { 732 g_free(saddr->path); 733 saddr->path = g_strdup(un.sun_path); 734 } 735 } 736 737 if (unlink(un.sun_path) < 0 && errno != ENOENT) { 738 error_setg_errno(errp, errno, 739 "Failed to unlink socket %s", un.sun_path); 740 goto err; 741 } 742 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 743 error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path); 744 goto err; 745 } 746 if (listen(sock, 1) < 0) { 747 error_setg_errno(errp, errno, "Failed to listen on socket"); 748 goto err; 749 } 750 751 return sock; 752 753 err: 754 closesocket(sock); 755 return -1; 756 } 757 758 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp, 759 NonBlockingConnectHandler *callback, void *opaque) 760 { 761 struct sockaddr_un un; 762 ConnectState *connect_state = NULL; 763 int sock, rc; 764 765 if (saddr->path == NULL) { 766 error_setg(errp, "unix connect: no path specified"); 767 return -1; 768 } 769 770 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 771 if (sock < 0) { 772 error_setg_errno(errp, errno, "Failed to create socket"); 773 return -1; 774 } 775 if (callback != NULL) { 776 connect_state = g_malloc0(sizeof(*connect_state)); 777 connect_state->callback = callback; 778 connect_state->opaque = opaque; 779 qemu_set_nonblock(sock); 780 } 781 782 memset(&un, 0, sizeof(un)); 783 un.sun_family = AF_UNIX; 784 snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path); 785 786 /* connect to peer */ 787 do { 788 rc = 0; 789 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { 790 rc = -errno; 791 } 792 } while (rc == -EINTR); 793 794 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 795 connect_state->fd = sock; 796 qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state); 797 return sock; 798 } else if (rc >= 0) { 799 /* non blocking socket immediate success, call callback */ 800 if (callback != NULL) { 801 callback(sock, NULL, opaque); 802 } 803 } 804 805 if (rc < 0) { 806 error_setg_errno(errp, -rc, "Failed to connect socket"); 807 close(sock); 808 sock = -1; 809 } 810 811 g_free(connect_state); 812 return sock; 813 } 814 815 #else 816 817 static int unix_listen_saddr(UnixSocketAddress *saddr, 818 bool update_addr, 819 Error **errp) 820 { 821 error_setg(errp, "unix sockets are not available on windows"); 822 errno = ENOTSUP; 823 return -1; 824 } 825 826 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp, 827 NonBlockingConnectHandler *callback, void *opaque) 828 { 829 error_setg(errp, "unix sockets are not available on windows"); 830 errno = ENOTSUP; 831 return -1; 832 } 833 #endif 834 835 /* compatibility wrapper */ 836 int unix_listen(const char *str, char *ostr, int olen, Error **errp) 837 { 838 char *path, *optstr; 839 int sock, len; 840 UnixSocketAddress *saddr; 841 842 saddr = g_new0(UnixSocketAddress, 1); 843 844 optstr = strchr(str, ','); 845 if (optstr) { 846 len = optstr - str; 847 if (len) { 848 path = g_malloc(len+1); 849 snprintf(path, len+1, "%.*s", len, str); 850 saddr->path = path; 851 } 852 } else { 853 saddr->path = g_strdup(str); 854 } 855 856 sock = unix_listen_saddr(saddr, true, errp); 857 858 if (sock != -1 && ostr) 859 snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : ""); 860 qapi_free_UnixSocketAddress(saddr); 861 return sock; 862 } 863 864 int unix_connect(const char *path, Error **errp) 865 { 866 UnixSocketAddress *saddr; 867 int sock; 868 869 saddr = g_new0(UnixSocketAddress, 1); 870 saddr->path = g_strdup(path); 871 sock = unix_connect_saddr(saddr, errp, NULL, NULL); 872 qapi_free_UnixSocketAddress(saddr); 873 return sock; 874 } 875 876 877 int unix_nonblocking_connect(const char *path, 878 NonBlockingConnectHandler *callback, 879 void *opaque, Error **errp) 880 { 881 UnixSocketAddress *saddr; 882 int sock = -1; 883 884 g_assert(callback != NULL); 885 886 saddr = g_new0(UnixSocketAddress, 1); 887 saddr->path = g_strdup(path); 888 sock = unix_connect_saddr(saddr, errp, callback, opaque); 889 qapi_free_UnixSocketAddress(saddr); 890 return sock; 891 } 892 893 SocketAddress *socket_parse(const char *str, Error **errp) 894 { 895 SocketAddress *addr; 896 897 addr = g_new0(SocketAddress, 1); 898 if (strstart(str, "unix:", NULL)) { 899 if (str[5] == '\0') { 900 error_setg(errp, "invalid Unix socket address"); 901 goto fail; 902 } else { 903 addr->type = SOCKET_ADDRESS_KIND_UNIX; 904 addr->u.q_unix.data = g_new(UnixSocketAddress, 1); 905 addr->u.q_unix.data->path = g_strdup(str + 5); 906 } 907 } else if (strstart(str, "fd:", NULL)) { 908 if (str[3] == '\0') { 909 error_setg(errp, "invalid file descriptor address"); 910 goto fail; 911 } else { 912 addr->type = SOCKET_ADDRESS_KIND_FD; 913 addr->u.fd.data = g_new(String, 1); 914 addr->u.fd.data->str = g_strdup(str + 3); 915 } 916 } else { 917 addr->type = SOCKET_ADDRESS_KIND_INET; 918 addr->u.inet.data = inet_parse(str, errp); 919 if (addr->u.inet.data == NULL) { 920 goto fail; 921 } 922 } 923 return addr; 924 925 fail: 926 qapi_free_SocketAddress(addr); 927 return NULL; 928 } 929 930 int socket_connect(SocketAddress *addr, Error **errp, 931 NonBlockingConnectHandler *callback, void *opaque) 932 { 933 int fd; 934 935 switch (addr->type) { 936 case SOCKET_ADDRESS_KIND_INET: 937 fd = inet_connect_saddr(addr->u.inet.data, errp, callback, opaque); 938 break; 939 940 case SOCKET_ADDRESS_KIND_UNIX: 941 fd = unix_connect_saddr(addr->u.q_unix.data, errp, callback, opaque); 942 break; 943 944 case SOCKET_ADDRESS_KIND_FD: 945 fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp); 946 if (fd >= 0 && callback) { 947 qemu_set_nonblock(fd); 948 callback(fd, NULL, opaque); 949 } 950 break; 951 952 default: 953 abort(); 954 } 955 return fd; 956 } 957 958 int socket_listen(SocketAddress *addr, Error **errp) 959 { 960 int fd; 961 962 switch (addr->type) { 963 case SOCKET_ADDRESS_KIND_INET: 964 fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp); 965 break; 966 967 case SOCKET_ADDRESS_KIND_UNIX: 968 fd = unix_listen_saddr(addr->u.q_unix.data, false, errp); 969 break; 970 971 case SOCKET_ADDRESS_KIND_FD: 972 fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp); 973 break; 974 975 default: 976 abort(); 977 } 978 return fd; 979 } 980 981 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp) 982 { 983 int fd; 984 985 switch (remote->type) { 986 case SOCKET_ADDRESS_KIND_INET: 987 fd = inet_dgram_saddr(remote->u.inet.data, 988 local ? local->u.inet.data : NULL, errp); 989 break; 990 991 default: 992 error_setg(errp, "socket type unsupported for datagram"); 993 fd = -1; 994 } 995 return fd; 996 } 997 998 999 static SocketAddress * 1000 socket_sockaddr_to_address_inet(struct sockaddr_storage *sa, 1001 socklen_t salen, 1002 Error **errp) 1003 { 1004 char host[NI_MAXHOST]; 1005 char serv[NI_MAXSERV]; 1006 SocketAddress *addr; 1007 InetSocketAddress *inet; 1008 int ret; 1009 1010 ret = getnameinfo((struct sockaddr *)sa, salen, 1011 host, sizeof(host), 1012 serv, sizeof(serv), 1013 NI_NUMERICHOST | NI_NUMERICSERV); 1014 if (ret != 0) { 1015 error_setg(errp, "Cannot format numeric socket address: %s", 1016 gai_strerror(ret)); 1017 return NULL; 1018 } 1019 1020 addr = g_new0(SocketAddress, 1); 1021 addr->type = SOCKET_ADDRESS_KIND_INET; 1022 inet = addr->u.inet.data = g_new0(InetSocketAddress, 1); 1023 inet->host = g_strdup(host); 1024 inet->port = g_strdup(serv); 1025 if (sa->ss_family == AF_INET) { 1026 inet->has_ipv4 = inet->ipv4 = true; 1027 } else { 1028 inet->has_ipv6 = inet->ipv6 = true; 1029 } 1030 1031 return addr; 1032 } 1033 1034 1035 #ifndef WIN32 1036 static SocketAddress * 1037 socket_sockaddr_to_address_unix(struct sockaddr_storage *sa, 1038 socklen_t salen, 1039 Error **errp) 1040 { 1041 SocketAddress *addr; 1042 struct sockaddr_un *su = (struct sockaddr_un *)sa; 1043 1044 addr = g_new0(SocketAddress, 1); 1045 addr->type = SOCKET_ADDRESS_KIND_UNIX; 1046 addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); 1047 if (su->sun_path[0]) { 1048 addr->u.q_unix.data->path = g_strndup(su->sun_path, 1049 sizeof(su->sun_path)); 1050 } 1051 1052 return addr; 1053 } 1054 #endif /* WIN32 */ 1055 1056 SocketAddress * 1057 socket_sockaddr_to_address(struct sockaddr_storage *sa, 1058 socklen_t salen, 1059 Error **errp) 1060 { 1061 switch (sa->ss_family) { 1062 case AF_INET: 1063 case AF_INET6: 1064 return socket_sockaddr_to_address_inet(sa, salen, errp); 1065 1066 #ifndef WIN32 1067 case AF_UNIX: 1068 return socket_sockaddr_to_address_unix(sa, salen, errp); 1069 #endif /* WIN32 */ 1070 1071 default: 1072 error_setg(errp, "socket family %d unsupported", 1073 sa->ss_family); 1074 return NULL; 1075 } 1076 return 0; 1077 } 1078 1079 1080 SocketAddress *socket_local_address(int fd, Error **errp) 1081 { 1082 struct sockaddr_storage ss; 1083 socklen_t sslen = sizeof(ss); 1084 1085 if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1086 error_setg_errno(errp, errno, "%s", 1087 "Unable to query local socket address"); 1088 return NULL; 1089 } 1090 1091 return socket_sockaddr_to_address(&ss, sslen, errp); 1092 } 1093 1094 1095 SocketAddress *socket_remote_address(int fd, Error **errp) 1096 { 1097 struct sockaddr_storage ss; 1098 socklen_t sslen = sizeof(ss); 1099 1100 if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1101 error_setg_errno(errp, errno, "%s", 1102 "Unable to query remote socket address"); 1103 return NULL; 1104 } 1105 1106 return socket_sockaddr_to_address(&ss, sslen, errp); 1107 } 1108 1109 1110 void qapi_copy_SocketAddress(SocketAddress **p_dest, 1111 SocketAddress *src) 1112 { 1113 QmpOutputVisitor *qov; 1114 QmpInputVisitor *qiv; 1115 Visitor *ov, *iv; 1116 QObject *obj; 1117 1118 *p_dest = NULL; 1119 1120 qov = qmp_output_visitor_new(); 1121 ov = qmp_output_get_visitor(qov); 1122 visit_type_SocketAddress(ov, NULL, &src, &error_abort); 1123 obj = qmp_output_get_qobject(qov); 1124 qmp_output_visitor_cleanup(qov); 1125 if (!obj) { 1126 return; 1127 } 1128 1129 qiv = qmp_input_visitor_new(obj); 1130 iv = qmp_input_get_visitor(qiv); 1131 visit_type_SocketAddress(iv, NULL, p_dest, &error_abort); 1132 qmp_input_visitor_cleanup(qiv); 1133 qobject_decref(obj); 1134 } 1135