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 #ifdef CONFIG_AF_VSOCK 21 #include <linux/vm_sockets.h> 22 #endif /* CONFIG_AF_VSOCK */ 23 24 #include "qemu-common.h" 25 #include "monitor/monitor.h" 26 #include "qapi/clone-visitor.h" 27 #include "qapi/error.h" 28 #include "qapi/qapi-visit-sockets.h" 29 #include "qemu/sockets.h" 30 #include "qemu/main-loop.h" 31 #include "qapi/qobject-input-visitor.h" 32 #include "qapi/qobject-output-visitor.h" 33 #include "qemu/cutils.h" 34 #include "trace.h" 35 36 #ifndef AI_ADDRCONFIG 37 # define AI_ADDRCONFIG 0 38 #endif 39 40 #ifndef AI_V4MAPPED 41 # define AI_V4MAPPED 0 42 #endif 43 44 #ifndef AI_NUMERICSERV 45 # define AI_NUMERICSERV 0 46 #endif 47 48 49 static int inet_getport(struct addrinfo *e) 50 { 51 struct sockaddr_in *i4; 52 struct sockaddr_in6 *i6; 53 54 switch (e->ai_family) { 55 case PF_INET6: 56 i6 = (void*)e->ai_addr; 57 return ntohs(i6->sin6_port); 58 case PF_INET: 59 i4 = (void*)e->ai_addr; 60 return ntohs(i4->sin_port); 61 default: 62 return 0; 63 } 64 } 65 66 static void inet_setport(struct addrinfo *e, int port) 67 { 68 struct sockaddr_in *i4; 69 struct sockaddr_in6 *i6; 70 71 switch (e->ai_family) { 72 case PF_INET6: 73 i6 = (void*)e->ai_addr; 74 i6->sin6_port = htons(port); 75 break; 76 case PF_INET: 77 i4 = (void*)e->ai_addr; 78 i4->sin_port = htons(port); 79 break; 80 } 81 } 82 83 NetworkAddressFamily inet_netfamily(int family) 84 { 85 switch (family) { 86 case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6; 87 case PF_INET: return NETWORK_ADDRESS_FAMILY_IPV4; 88 case PF_UNIX: return NETWORK_ADDRESS_FAMILY_UNIX; 89 #ifdef CONFIG_AF_VSOCK 90 case PF_VSOCK: return NETWORK_ADDRESS_FAMILY_VSOCK; 91 #endif /* CONFIG_AF_VSOCK */ 92 } 93 return NETWORK_ADDRESS_FAMILY_UNKNOWN; 94 } 95 96 bool fd_is_socket(int fd) 97 { 98 int optval; 99 socklen_t optlen = sizeof(optval); 100 return !qemu_getsockopt(fd, SOL_SOCKET, SO_TYPE, &optval, &optlen); 101 } 102 103 104 /* 105 * Matrix we're trying to apply 106 * 107 * ipv4 ipv6 family 108 * - - PF_UNSPEC 109 * - f PF_INET 110 * - t PF_INET6 111 * f - PF_INET6 112 * f f <error> 113 * f t PF_INET6 114 * t - PF_INET 115 * t f PF_INET 116 * t t PF_INET6/PF_UNSPEC 117 * 118 * NB, this matrix is only about getting the necessary results 119 * from getaddrinfo(). Some of the cases require further work 120 * after reading results from getaddrinfo in order to fully 121 * apply the logic the end user wants. 122 * 123 * In the first and last cases, we must set IPV6_V6ONLY=0 124 * when binding, to allow a single listener to potentially 125 * accept both IPv4+6 addresses. 126 */ 127 int inet_ai_family_from_address(InetSocketAddress *addr, 128 Error **errp) 129 { 130 if (addr->has_ipv6 && addr->has_ipv4 && 131 !addr->ipv6 && !addr->ipv4) { 132 error_setg(errp, "Cannot disable IPv4 and IPv6 at same time"); 133 return PF_UNSPEC; 134 } 135 if ((addr->has_ipv6 && addr->ipv6) && (addr->has_ipv4 && addr->ipv4)) { 136 /* 137 * Some backends can only do a single listener. In that case 138 * we want empty hostname to resolve to "::" and then use the 139 * flag IPV6_V6ONLY==0 to get both protocols on 1 socket. This 140 * doesn't work for addresses other than "", so they're just 141 * inevitably broken until multiple listeners can be used, 142 * and thus we honour getaddrinfo automatic protocol detection 143 * Once all backends do multi-listener, remove the PF_INET6 144 * branch entirely. 145 */ 146 if (!addr->host || g_str_equal(addr->host, "")) { 147 return PF_INET6; 148 } else { 149 return PF_UNSPEC; 150 } 151 } 152 if ((addr->has_ipv6 && addr->ipv6) || (addr->has_ipv4 && !addr->ipv4)) { 153 return PF_INET6; 154 } 155 if ((addr->has_ipv4 && addr->ipv4) || (addr->has_ipv6 && !addr->ipv6)) { 156 return PF_INET; 157 } 158 return PF_UNSPEC; 159 } 160 161 static int create_fast_reuse_socket(struct addrinfo *e) 162 { 163 int slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol); 164 if (slisten < 0) { 165 return -1; 166 } 167 socket_set_fast_reuse(slisten); 168 return slisten; 169 } 170 171 static int try_bind(int socket, InetSocketAddress *saddr, struct addrinfo *e) 172 { 173 #ifndef IPV6_V6ONLY 174 return bind(socket, e->ai_addr, e->ai_addrlen); 175 #else 176 /* 177 * Deals with first & last cases in matrix in comment 178 * for inet_ai_family_from_address(). 179 */ 180 int v6only = 181 ((!saddr->has_ipv4 && !saddr->has_ipv6) || 182 (saddr->has_ipv4 && saddr->ipv4 && 183 saddr->has_ipv6 && saddr->ipv6)) ? 0 : 1; 184 int stat; 185 186 rebind: 187 if (e->ai_family == PF_INET6) { 188 qemu_setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, &v6only, 189 sizeof(v6only)); 190 } 191 192 stat = bind(socket, e->ai_addr, e->ai_addrlen); 193 if (!stat) { 194 return 0; 195 } 196 197 /* If we got EADDRINUSE from an IPv6 bind & v6only is unset, 198 * it could be that the IPv4 port is already claimed, so retry 199 * with v6only set 200 */ 201 if (e->ai_family == PF_INET6 && errno == EADDRINUSE && !v6only) { 202 v6only = 1; 203 goto rebind; 204 } 205 return stat; 206 #endif 207 } 208 209 static int inet_listen_saddr(InetSocketAddress *saddr, 210 int port_offset, 211 int num, 212 Error **errp) 213 { 214 struct addrinfo ai,*res,*e; 215 char port[33]; 216 char uaddr[INET6_ADDRSTRLEN+1]; 217 char uport[33]; 218 int rc, port_min, port_max, p; 219 int slisten = -1; 220 int saved_errno = 0; 221 bool socket_created = false; 222 Error *err = NULL; 223 224 if (saddr->keep_alive) { 225 error_setg(errp, "keep-alive option is not supported for passive " 226 "sockets"); 227 return -1; 228 } 229 230 memset(&ai,0, sizeof(ai)); 231 ai.ai_flags = AI_PASSIVE; 232 if (saddr->has_numeric && saddr->numeric) { 233 ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV; 234 } 235 ai.ai_family = inet_ai_family_from_address(saddr, &err); 236 ai.ai_socktype = SOCK_STREAM; 237 238 if (err) { 239 error_propagate(errp, err); 240 return -1; 241 } 242 243 if (saddr->host == NULL) { 244 error_setg(errp, "host not specified"); 245 return -1; 246 } 247 if (saddr->port != NULL) { 248 pstrcpy(port, sizeof(port), saddr->port); 249 } else { 250 port[0] = '\0'; 251 } 252 253 /* lookup */ 254 if (port_offset) { 255 unsigned long long baseport; 256 if (strlen(port) == 0) { 257 error_setg(errp, "port not specified"); 258 return -1; 259 } 260 if (parse_uint_full(port, &baseport, 10) < 0) { 261 error_setg(errp, "can't convert to a number: %s", port); 262 return -1; 263 } 264 if (baseport > 65535 || 265 baseport + port_offset > 65535) { 266 error_setg(errp, "port %s out of range", port); 267 return -1; 268 } 269 snprintf(port, sizeof(port), "%d", (int)baseport + port_offset); 270 } 271 rc = getaddrinfo(strlen(saddr->host) ? saddr->host : NULL, 272 strlen(port) ? port : NULL, &ai, &res); 273 if (rc != 0) { 274 error_setg(errp, "address resolution failed for %s:%s: %s", 275 saddr->host, port, gai_strerror(rc)); 276 return -1; 277 } 278 279 /* create socket + bind/listen */ 280 for (e = res; e != NULL; e = e->ai_next) { 281 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 282 uaddr,INET6_ADDRSTRLEN,uport,32, 283 NI_NUMERICHOST | NI_NUMERICSERV); 284 285 port_min = inet_getport(e); 286 port_max = saddr->has_to ? saddr->to + port_offset : port_min; 287 for (p = port_min; p <= port_max; p++) { 288 inet_setport(e, p); 289 290 slisten = create_fast_reuse_socket(e); 291 if (slisten < 0) { 292 /* First time we expect we might fail to create the socket 293 * eg if 'e' has AF_INET6 but ipv6 kmod is not loaded. 294 * Later iterations should always succeed if first iteration 295 * worked though, so treat that as fatal. 296 */ 297 if (p == port_min) { 298 continue; 299 } else { 300 error_setg_errno(errp, errno, 301 "Failed to recreate failed listening socket"); 302 goto listen_failed; 303 } 304 } 305 socket_created = true; 306 307 rc = try_bind(slisten, saddr, e); 308 if (rc < 0) { 309 if (errno != EADDRINUSE) { 310 error_setg_errno(errp, errno, "Failed to bind socket"); 311 goto listen_failed; 312 } 313 } else { 314 if (!listen(slisten, num)) { 315 goto listen_ok; 316 } 317 if (errno != EADDRINUSE) { 318 error_setg_errno(errp, errno, "Failed to listen on socket"); 319 goto listen_failed; 320 } 321 } 322 /* Someone else managed to bind to the same port and beat us 323 * to listen on it! Socket semantics does not allow us to 324 * recover from this situation, so we need to recreate the 325 * socket to allow bind attempts for subsequent ports: 326 */ 327 closesocket(slisten); 328 slisten = -1; 329 } 330 } 331 error_setg_errno(errp, errno, 332 socket_created ? 333 "Failed to find an available port" : 334 "Failed to create a socket"); 335 listen_failed: 336 saved_errno = errno; 337 if (slisten >= 0) { 338 closesocket(slisten); 339 } 340 freeaddrinfo(res); 341 errno = saved_errno; 342 return -1; 343 344 listen_ok: 345 freeaddrinfo(res); 346 return slisten; 347 } 348 349 #ifdef _WIN32 350 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 351 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY) 352 #else 353 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 354 ((rc) == -EINPROGRESS) 355 #endif 356 357 static int inet_connect_addr(struct addrinfo *addr, Error **errp); 358 359 static int inet_connect_addr(struct addrinfo *addr, Error **errp) 360 { 361 int sock, rc; 362 363 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 364 if (sock < 0) { 365 error_setg_errno(errp, errno, "Failed to create socket"); 366 return -1; 367 } 368 socket_set_fast_reuse(sock); 369 370 /* connect to peer */ 371 do { 372 rc = 0; 373 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) { 374 rc = -errno; 375 } 376 } while (rc == -EINTR); 377 378 if (rc < 0) { 379 error_setg_errno(errp, errno, "Failed to connect socket"); 380 closesocket(sock); 381 return -1; 382 } 383 384 return sock; 385 } 386 387 static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr, 388 Error **errp) 389 { 390 struct addrinfo ai, *res; 391 int rc; 392 Error *err = NULL; 393 static int useV4Mapped = 1; 394 395 memset(&ai, 0, sizeof(ai)); 396 397 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 398 if (atomic_read(&useV4Mapped)) { 399 ai.ai_flags |= AI_V4MAPPED; 400 } 401 ai.ai_family = inet_ai_family_from_address(saddr, &err); 402 ai.ai_socktype = SOCK_STREAM; 403 404 if (err) { 405 error_propagate(errp, err); 406 return NULL; 407 } 408 409 if (saddr->host == NULL || saddr->port == NULL) { 410 error_setg(errp, "host and/or port not specified"); 411 return NULL; 412 } 413 414 /* lookup */ 415 rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); 416 417 /* At least FreeBSD and OS-X 10.6 declare AI_V4MAPPED but 418 * then don't implement it in their getaddrinfo(). Detect 419 * this and retry without the flag since that's preferrable 420 * to a fatal error 421 */ 422 if (rc == EAI_BADFLAGS && 423 (ai.ai_flags & AI_V4MAPPED)) { 424 atomic_set(&useV4Mapped, 0); 425 ai.ai_flags &= ~AI_V4MAPPED; 426 rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); 427 } 428 if (rc != 0) { 429 error_setg(errp, "address resolution failed for %s:%s: %s", 430 saddr->host, saddr->port, gai_strerror(rc)); 431 return NULL; 432 } 433 return res; 434 } 435 436 /** 437 * Create a socket and connect it to an address. 438 * 439 * @saddr: Inet socket address specification 440 * @errp: set on error 441 * 442 * Returns: -1 on error, file descriptor on success. 443 */ 444 int inet_connect_saddr(InetSocketAddress *saddr, Error **errp) 445 { 446 Error *local_err = NULL; 447 struct addrinfo *res, *e; 448 int sock = -1; 449 450 res = inet_parse_connect_saddr(saddr, errp); 451 if (!res) { 452 return -1; 453 } 454 455 for (e = res; e != NULL; e = e->ai_next) { 456 error_free(local_err); 457 local_err = NULL; 458 sock = inet_connect_addr(e, &local_err); 459 if (sock >= 0) { 460 break; 461 } 462 } 463 464 if (sock < 0) { 465 error_propagate(errp, local_err); 466 } 467 468 freeaddrinfo(res); 469 470 if (saddr->keep_alive) { 471 int val = 1; 472 int ret = qemu_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, 473 &val, sizeof(val)); 474 475 if (ret < 0) { 476 error_setg_errno(errp, errno, "Unable to set KEEPALIVE"); 477 close(sock); 478 return -1; 479 } 480 } 481 482 return sock; 483 } 484 485 static int inet_dgram_saddr(InetSocketAddress *sraddr, 486 InetSocketAddress *sladdr, 487 Error **errp) 488 { 489 struct addrinfo ai, *peer = NULL, *local = NULL; 490 const char *addr; 491 const char *port; 492 int sock = -1, rc; 493 Error *err = NULL; 494 495 /* lookup peer addr */ 496 memset(&ai,0, sizeof(ai)); 497 ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG; 498 ai.ai_family = inet_ai_family_from_address(sraddr, &err); 499 ai.ai_socktype = SOCK_DGRAM; 500 501 if (err) { 502 error_propagate(errp, err); 503 goto err; 504 } 505 506 addr = sraddr->host; 507 port = sraddr->port; 508 if (addr == NULL || strlen(addr) == 0) { 509 addr = "localhost"; 510 } 511 if (port == NULL || strlen(port) == 0) { 512 error_setg(errp, "remote port not specified"); 513 goto err; 514 } 515 516 if ((rc = getaddrinfo(addr, port, &ai, &peer)) != 0) { 517 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 518 gai_strerror(rc)); 519 goto err; 520 } 521 522 /* lookup local addr */ 523 memset(&ai,0, sizeof(ai)); 524 ai.ai_flags = AI_PASSIVE; 525 ai.ai_family = peer->ai_family; 526 ai.ai_socktype = SOCK_DGRAM; 527 528 if (sladdr) { 529 addr = sladdr->host; 530 port = sladdr->port; 531 if (addr == NULL || strlen(addr) == 0) { 532 addr = NULL; 533 } 534 if (!port || strlen(port) == 0) { 535 port = "0"; 536 } 537 } else { 538 addr = NULL; 539 port = "0"; 540 } 541 542 if ((rc = getaddrinfo(addr, port, &ai, &local)) != 0) { 543 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 544 gai_strerror(rc)); 545 goto err; 546 } 547 548 /* create socket */ 549 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol); 550 if (sock < 0) { 551 error_setg_errno(errp, errno, "Failed to create socket"); 552 goto err; 553 } 554 socket_set_fast_reuse(sock); 555 556 /* bind socket */ 557 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) { 558 error_setg_errno(errp, errno, "Failed to bind socket"); 559 goto err; 560 } 561 562 /* connect to peer */ 563 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) { 564 error_setg_errno(errp, errno, "Failed to connect socket"); 565 goto err; 566 } 567 568 freeaddrinfo(local); 569 freeaddrinfo(peer); 570 return sock; 571 572 err: 573 if (sock != -1) { 574 closesocket(sock); 575 } 576 if (local) { 577 freeaddrinfo(local); 578 } 579 if (peer) { 580 freeaddrinfo(peer); 581 } 582 583 return -1; 584 } 585 586 /* compatibility wrapper */ 587 static int inet_parse_flag(const char *flagname, const char *optstr, bool *val, 588 Error **errp) 589 { 590 char *end; 591 size_t len; 592 593 end = strstr(optstr, ","); 594 if (end) { 595 if (end[1] == ',') { /* Reject 'ipv6=on,,foo' */ 596 error_setg(errp, "error parsing '%s' flag '%s'", flagname, optstr); 597 return -1; 598 } 599 len = end - optstr; 600 } else { 601 len = strlen(optstr); 602 } 603 if (len == 0 || (len == 3 && strncmp(optstr, "=on", len) == 0)) { 604 *val = true; 605 } else if (len == 4 && strncmp(optstr, "=off", len) == 0) { 606 *val = false; 607 } else { 608 error_setg(errp, "error parsing '%s' flag '%s'", flagname, optstr); 609 return -1; 610 } 611 return 0; 612 } 613 614 int inet_parse(InetSocketAddress *addr, const char *str, Error **errp) 615 { 616 const char *optstr, *h; 617 char host[65]; 618 char port[33]; 619 int to; 620 int pos; 621 char *begin; 622 623 memset(addr, 0, sizeof(*addr)); 624 625 /* parse address */ 626 if (str[0] == ':') { 627 /* no host given */ 628 host[0] = '\0'; 629 if (sscanf(str, ":%32[^,]%n", port, &pos) != 1) { 630 error_setg(errp, "error parsing port in address '%s'", str); 631 return -1; 632 } 633 } else if (str[0] == '[') { 634 /* IPv6 addr */ 635 if (sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos) != 2) { 636 error_setg(errp, "error parsing IPv6 address '%s'", str); 637 return -1; 638 } 639 } else { 640 /* hostname or IPv4 addr */ 641 if (sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos) != 2) { 642 error_setg(errp, "error parsing address '%s'", str); 643 return -1; 644 } 645 } 646 647 addr->host = g_strdup(host); 648 addr->port = g_strdup(port); 649 650 /* parse options */ 651 optstr = str + pos; 652 h = strstr(optstr, ",to="); 653 if (h) { 654 h += 4; 655 if (sscanf(h, "%d%n", &to, &pos) != 1 || 656 (h[pos] != '\0' && h[pos] != ',')) { 657 error_setg(errp, "error parsing to= argument"); 658 return -1; 659 } 660 addr->has_to = true; 661 addr->to = to; 662 } 663 begin = strstr(optstr, ",ipv4"); 664 if (begin) { 665 if (inet_parse_flag("ipv4", begin + 5, &addr->ipv4, errp) < 0) { 666 return -1; 667 } 668 addr->has_ipv4 = true; 669 } 670 begin = strstr(optstr, ",ipv6"); 671 if (begin) { 672 if (inet_parse_flag("ipv6", begin + 5, &addr->ipv6, errp) < 0) { 673 return -1; 674 } 675 addr->has_ipv6 = true; 676 } 677 begin = strstr(optstr, ",keep-alive"); 678 if (begin) { 679 if (inet_parse_flag("keep-alive", begin + strlen(",keep-alive"), 680 &addr->keep_alive, errp) < 0) 681 { 682 return -1; 683 } 684 addr->has_keep_alive = true; 685 } 686 return 0; 687 } 688 689 690 /** 691 * Create a blocking socket and connect it to an address. 692 * 693 * @str: address string 694 * @errp: set in case of an error 695 * 696 * Returns -1 in case of error, file descriptor on success 697 **/ 698 int inet_connect(const char *str, Error **errp) 699 { 700 int sock = -1; 701 InetSocketAddress *addr = g_new(InetSocketAddress, 1); 702 703 if (!inet_parse(addr, str, errp)) { 704 sock = inet_connect_saddr(addr, errp); 705 } 706 qapi_free_InetSocketAddress(addr); 707 return sock; 708 } 709 710 #ifdef CONFIG_AF_VSOCK 711 static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr, 712 struct sockaddr_vm *svm, 713 Error **errp) 714 { 715 unsigned long long val; 716 717 memset(svm, 0, sizeof(*svm)); 718 svm->svm_family = AF_VSOCK; 719 720 if (parse_uint_full(vaddr->cid, &val, 10) < 0 || 721 val > UINT32_MAX) { 722 error_setg(errp, "Failed to parse cid '%s'", vaddr->cid); 723 return false; 724 } 725 svm->svm_cid = val; 726 727 if (parse_uint_full(vaddr->port, &val, 10) < 0 || 728 val > UINT32_MAX) { 729 error_setg(errp, "Failed to parse port '%s'", vaddr->port); 730 return false; 731 } 732 svm->svm_port = val; 733 734 return true; 735 } 736 737 static int vsock_connect_addr(const struct sockaddr_vm *svm, Error **errp) 738 { 739 int sock, rc; 740 741 sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); 742 if (sock < 0) { 743 error_setg_errno(errp, errno, "Failed to create socket"); 744 return -1; 745 } 746 747 /* connect to peer */ 748 do { 749 rc = 0; 750 if (connect(sock, (const struct sockaddr *)svm, sizeof(*svm)) < 0) { 751 rc = -errno; 752 } 753 } while (rc == -EINTR); 754 755 if (rc < 0) { 756 error_setg_errno(errp, errno, "Failed to connect socket"); 757 closesocket(sock); 758 return -1; 759 } 760 761 return sock; 762 } 763 764 static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp) 765 { 766 struct sockaddr_vm svm; 767 int sock = -1; 768 769 if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { 770 return -1; 771 } 772 773 sock = vsock_connect_addr(&svm, errp); 774 775 return sock; 776 } 777 778 static int vsock_listen_saddr(VsockSocketAddress *vaddr, 779 int num, 780 Error **errp) 781 { 782 struct sockaddr_vm svm; 783 int slisten; 784 785 if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { 786 return -1; 787 } 788 789 slisten = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); 790 if (slisten < 0) { 791 error_setg_errno(errp, errno, "Failed to create socket"); 792 return -1; 793 } 794 795 if (bind(slisten, (const struct sockaddr *)&svm, sizeof(svm)) != 0) { 796 error_setg_errno(errp, errno, "Failed to bind socket"); 797 closesocket(slisten); 798 return -1; 799 } 800 801 if (listen(slisten, num) != 0) { 802 error_setg_errno(errp, errno, "Failed to listen on socket"); 803 closesocket(slisten); 804 return -1; 805 } 806 return slisten; 807 } 808 809 static int vsock_parse(VsockSocketAddress *addr, const char *str, 810 Error **errp) 811 { 812 char cid[33]; 813 char port[33]; 814 int n; 815 816 if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) { 817 error_setg(errp, "error parsing address '%s'", str); 818 return -1; 819 } 820 if (str[n] != '\0') { 821 error_setg(errp, "trailing characters in address '%s'", str); 822 return -1; 823 } 824 825 addr->cid = g_strdup(cid); 826 addr->port = g_strdup(port); 827 return 0; 828 } 829 #else 830 static void vsock_unsupported(Error **errp) 831 { 832 error_setg(errp, "socket family AF_VSOCK unsupported"); 833 } 834 835 static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp) 836 { 837 vsock_unsupported(errp); 838 return -1; 839 } 840 841 static int vsock_listen_saddr(VsockSocketAddress *vaddr, 842 int num, 843 Error **errp) 844 { 845 vsock_unsupported(errp); 846 return -1; 847 } 848 849 static int vsock_parse(VsockSocketAddress *addr, const char *str, 850 Error **errp) 851 { 852 vsock_unsupported(errp); 853 return -1; 854 } 855 #endif /* CONFIG_AF_VSOCK */ 856 857 #ifndef _WIN32 858 859 static int unix_listen_saddr(UnixSocketAddress *saddr, 860 int num, 861 Error **errp) 862 { 863 struct sockaddr_un un; 864 int sock, fd; 865 char *pathbuf = NULL; 866 const char *path; 867 size_t pathlen; 868 869 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 870 if (sock < 0) { 871 error_setg_errno(errp, errno, "Failed to create Unix socket"); 872 return -1; 873 } 874 875 if (saddr->path && saddr->path[0]) { 876 path = saddr->path; 877 } else { 878 const char *tmpdir = getenv("TMPDIR"); 879 tmpdir = tmpdir ? tmpdir : "/tmp"; 880 path = pathbuf = g_strdup_printf("%s/qemu-socket-XXXXXX", tmpdir); 881 } 882 883 pathlen = strlen(path); 884 if (pathlen > sizeof(un.sun_path)) { 885 error_setg(errp, "UNIX socket path '%s' is too long", path); 886 error_append_hint(errp, "Path must be less than %zu bytes\n", 887 sizeof(un.sun_path)); 888 goto err; 889 } 890 891 if (pathbuf != NULL) { 892 /* 893 * This dummy fd usage silences the mktemp() unsecure warning. 894 * Using mkstemp() doesn't make things more secure here 895 * though. bind() complains about existing files, so we have 896 * to unlink first and thus re-open the race window. The 897 * worst case possible is bind() failing, i.e. a DoS attack. 898 */ 899 fd = mkstemp(pathbuf); 900 if (fd < 0) { 901 error_setg_errno(errp, errno, 902 "Failed to make a temporary socket %s", pathbuf); 903 goto err; 904 } 905 close(fd); 906 } 907 908 if (unlink(path) < 0 && errno != ENOENT) { 909 error_setg_errno(errp, errno, 910 "Failed to unlink socket %s", path); 911 goto err; 912 } 913 914 memset(&un, 0, sizeof(un)); 915 un.sun_family = AF_UNIX; 916 memcpy(un.sun_path, path, pathlen); 917 918 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 919 error_setg_errno(errp, errno, "Failed to bind socket to %s", path); 920 goto err; 921 } 922 if (listen(sock, num) < 0) { 923 error_setg_errno(errp, errno, "Failed to listen on socket"); 924 goto err; 925 } 926 927 g_free(pathbuf); 928 return sock; 929 930 err: 931 g_free(pathbuf); 932 closesocket(sock); 933 return -1; 934 } 935 936 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp) 937 { 938 struct sockaddr_un un; 939 int sock, rc; 940 size_t pathlen; 941 942 if (saddr->path == NULL) { 943 error_setg(errp, "unix connect: no path specified"); 944 return -1; 945 } 946 947 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 948 if (sock < 0) { 949 error_setg_errno(errp, errno, "Failed to create socket"); 950 return -1; 951 } 952 953 pathlen = strlen(saddr->path); 954 if (pathlen > sizeof(un.sun_path)) { 955 error_setg(errp, "UNIX socket path '%s' is too long", saddr->path); 956 error_append_hint(errp, "Path must be less than %zu bytes\n", 957 sizeof(un.sun_path)); 958 goto err; 959 } 960 961 memset(&un, 0, sizeof(un)); 962 un.sun_family = AF_UNIX; 963 memcpy(un.sun_path, saddr->path, pathlen); 964 965 /* connect to peer */ 966 do { 967 rc = 0; 968 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { 969 rc = -errno; 970 } 971 } while (rc == -EINTR); 972 973 if (rc < 0) { 974 error_setg_errno(errp, -rc, "Failed to connect socket %s", 975 saddr->path); 976 goto err; 977 } 978 979 return sock; 980 981 err: 982 close(sock); 983 return -1; 984 } 985 986 #else 987 988 static int unix_listen_saddr(UnixSocketAddress *saddr, 989 int num, 990 Error **errp) 991 { 992 error_setg(errp, "unix sockets are not available on windows"); 993 errno = ENOTSUP; 994 return -1; 995 } 996 997 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp) 998 { 999 error_setg(errp, "unix sockets are not available on windows"); 1000 errno = ENOTSUP; 1001 return -1; 1002 } 1003 #endif 1004 1005 /* compatibility wrapper */ 1006 int unix_listen(const char *str, Error **errp) 1007 { 1008 UnixSocketAddress *saddr; 1009 int sock; 1010 1011 saddr = g_new0(UnixSocketAddress, 1); 1012 saddr->path = g_strdup(str); 1013 sock = unix_listen_saddr(saddr, 1, errp); 1014 qapi_free_UnixSocketAddress(saddr); 1015 return sock; 1016 } 1017 1018 int unix_connect(const char *path, Error **errp) 1019 { 1020 UnixSocketAddress *saddr; 1021 int sock; 1022 1023 saddr = g_new0(UnixSocketAddress, 1); 1024 saddr->path = g_strdup(path); 1025 sock = unix_connect_saddr(saddr, errp); 1026 qapi_free_UnixSocketAddress(saddr); 1027 return sock; 1028 } 1029 1030 1031 SocketAddress *socket_parse(const char *str, Error **errp) 1032 { 1033 SocketAddress *addr; 1034 1035 addr = g_new0(SocketAddress, 1); 1036 if (strstart(str, "unix:", NULL)) { 1037 if (str[5] == '\0') { 1038 error_setg(errp, "invalid Unix socket address"); 1039 goto fail; 1040 } else { 1041 addr->type = SOCKET_ADDRESS_TYPE_UNIX; 1042 addr->u.q_unix.path = g_strdup(str + 5); 1043 } 1044 } else if (strstart(str, "fd:", NULL)) { 1045 if (str[3] == '\0') { 1046 error_setg(errp, "invalid file descriptor address"); 1047 goto fail; 1048 } else { 1049 addr->type = SOCKET_ADDRESS_TYPE_FD; 1050 addr->u.fd.str = g_strdup(str + 3); 1051 } 1052 } else if (strstart(str, "vsock:", NULL)) { 1053 addr->type = SOCKET_ADDRESS_TYPE_VSOCK; 1054 if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) { 1055 goto fail; 1056 } 1057 } else { 1058 addr->type = SOCKET_ADDRESS_TYPE_INET; 1059 if (inet_parse(&addr->u.inet, str, errp)) { 1060 goto fail; 1061 } 1062 } 1063 return addr; 1064 1065 fail: 1066 qapi_free_SocketAddress(addr); 1067 return NULL; 1068 } 1069 1070 static int socket_get_fd(const char *fdstr, int num, Error **errp) 1071 { 1072 int fd; 1073 if (num != 1) { 1074 error_setg_errno(errp, EINVAL, "socket_get_fd: too many connections"); 1075 return -1; 1076 } 1077 if (cur_mon) { 1078 fd = monitor_get_fd(cur_mon, fdstr, errp); 1079 if (fd < 0) { 1080 return -1; 1081 } 1082 } else { 1083 if (qemu_strtoi(fdstr, NULL, 10, &fd) < 0) { 1084 error_setg_errno(errp, errno, 1085 "Unable to parse FD number %s", 1086 fdstr); 1087 return -1; 1088 } 1089 } 1090 if (!fd_is_socket(fd)) { 1091 error_setg(errp, "File descriptor '%s' is not a socket", fdstr); 1092 close(fd); 1093 return -1; 1094 } 1095 return fd; 1096 } 1097 1098 int socket_connect(SocketAddress *addr, Error **errp) 1099 { 1100 int fd; 1101 1102 switch (addr->type) { 1103 case SOCKET_ADDRESS_TYPE_INET: 1104 fd = inet_connect_saddr(&addr->u.inet, errp); 1105 break; 1106 1107 case SOCKET_ADDRESS_TYPE_UNIX: 1108 fd = unix_connect_saddr(&addr->u.q_unix, errp); 1109 break; 1110 1111 case SOCKET_ADDRESS_TYPE_FD: 1112 fd = socket_get_fd(addr->u.fd.str, 1, errp); 1113 break; 1114 1115 case SOCKET_ADDRESS_TYPE_VSOCK: 1116 fd = vsock_connect_saddr(&addr->u.vsock, errp); 1117 break; 1118 1119 default: 1120 abort(); 1121 } 1122 return fd; 1123 } 1124 1125 int socket_listen(SocketAddress *addr, int num, Error **errp) 1126 { 1127 int fd; 1128 1129 trace_socket_listen(num); 1130 switch (addr->type) { 1131 case SOCKET_ADDRESS_TYPE_INET: 1132 fd = inet_listen_saddr(&addr->u.inet, 0, num, errp); 1133 break; 1134 1135 case SOCKET_ADDRESS_TYPE_UNIX: 1136 fd = unix_listen_saddr(&addr->u.q_unix, num, errp); 1137 break; 1138 1139 case SOCKET_ADDRESS_TYPE_FD: 1140 fd = socket_get_fd(addr->u.fd.str, num, errp); 1141 break; 1142 1143 case SOCKET_ADDRESS_TYPE_VSOCK: 1144 fd = vsock_listen_saddr(&addr->u.vsock, num, errp); 1145 break; 1146 1147 default: 1148 abort(); 1149 } 1150 return fd; 1151 } 1152 1153 void socket_listen_cleanup(int fd, Error **errp) 1154 { 1155 SocketAddress *addr; 1156 1157 addr = socket_local_address(fd, errp); 1158 if (!addr) { 1159 return; 1160 } 1161 1162 if (addr->type == SOCKET_ADDRESS_TYPE_UNIX 1163 && addr->u.q_unix.path) { 1164 if (unlink(addr->u.q_unix.path) < 0 && errno != ENOENT) { 1165 error_setg_errno(errp, errno, 1166 "Failed to unlink socket %s", 1167 addr->u.q_unix.path); 1168 } 1169 } 1170 1171 qapi_free_SocketAddress(addr); 1172 } 1173 1174 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp) 1175 { 1176 int fd; 1177 1178 /* 1179 * TODO SOCKET_ADDRESS_TYPE_FD when fd is AF_INET or AF_INET6 1180 * (although other address families can do SOCK_DGRAM, too) 1181 */ 1182 switch (remote->type) { 1183 case SOCKET_ADDRESS_TYPE_INET: 1184 fd = inet_dgram_saddr(&remote->u.inet, 1185 local ? &local->u.inet : NULL, errp); 1186 break; 1187 1188 default: 1189 error_setg(errp, "socket type unsupported for datagram"); 1190 fd = -1; 1191 } 1192 return fd; 1193 } 1194 1195 1196 static SocketAddress * 1197 socket_sockaddr_to_address_inet(struct sockaddr_storage *sa, 1198 socklen_t salen, 1199 Error **errp) 1200 { 1201 char host[NI_MAXHOST]; 1202 char serv[NI_MAXSERV]; 1203 SocketAddress *addr; 1204 InetSocketAddress *inet; 1205 int ret; 1206 1207 ret = getnameinfo((struct sockaddr *)sa, salen, 1208 host, sizeof(host), 1209 serv, sizeof(serv), 1210 NI_NUMERICHOST | NI_NUMERICSERV); 1211 if (ret != 0) { 1212 error_setg(errp, "Cannot format numeric socket address: %s", 1213 gai_strerror(ret)); 1214 return NULL; 1215 } 1216 1217 addr = g_new0(SocketAddress, 1); 1218 addr->type = SOCKET_ADDRESS_TYPE_INET; 1219 inet = &addr->u.inet; 1220 inet->host = g_strdup(host); 1221 inet->port = g_strdup(serv); 1222 if (sa->ss_family == AF_INET) { 1223 inet->has_ipv4 = inet->ipv4 = true; 1224 } else { 1225 inet->has_ipv6 = inet->ipv6 = true; 1226 } 1227 1228 return addr; 1229 } 1230 1231 1232 #ifndef WIN32 1233 static SocketAddress * 1234 socket_sockaddr_to_address_unix(struct sockaddr_storage *sa, 1235 socklen_t salen, 1236 Error **errp) 1237 { 1238 SocketAddress *addr; 1239 struct sockaddr_un *su = (struct sockaddr_un *)sa; 1240 1241 addr = g_new0(SocketAddress, 1); 1242 addr->type = SOCKET_ADDRESS_TYPE_UNIX; 1243 if (su->sun_path[0]) { 1244 addr->u.q_unix.path = g_strndup(su->sun_path, sizeof(su->sun_path)); 1245 } 1246 1247 return addr; 1248 } 1249 #endif /* WIN32 */ 1250 1251 #ifdef CONFIG_AF_VSOCK 1252 static SocketAddress * 1253 socket_sockaddr_to_address_vsock(struct sockaddr_storage *sa, 1254 socklen_t salen, 1255 Error **errp) 1256 { 1257 SocketAddress *addr; 1258 VsockSocketAddress *vaddr; 1259 struct sockaddr_vm *svm = (struct sockaddr_vm *)sa; 1260 1261 addr = g_new0(SocketAddress, 1); 1262 addr->type = SOCKET_ADDRESS_TYPE_VSOCK; 1263 vaddr = &addr->u.vsock; 1264 vaddr->cid = g_strdup_printf("%u", svm->svm_cid); 1265 vaddr->port = g_strdup_printf("%u", svm->svm_port); 1266 1267 return addr; 1268 } 1269 #endif /* CONFIG_AF_VSOCK */ 1270 1271 SocketAddress * 1272 socket_sockaddr_to_address(struct sockaddr_storage *sa, 1273 socklen_t salen, 1274 Error **errp) 1275 { 1276 switch (sa->ss_family) { 1277 case AF_INET: 1278 case AF_INET6: 1279 return socket_sockaddr_to_address_inet(sa, salen, errp); 1280 1281 #ifndef WIN32 1282 case AF_UNIX: 1283 return socket_sockaddr_to_address_unix(sa, salen, errp); 1284 #endif /* WIN32 */ 1285 1286 #ifdef CONFIG_AF_VSOCK 1287 case AF_VSOCK: 1288 return socket_sockaddr_to_address_vsock(sa, salen, errp); 1289 #endif 1290 1291 default: 1292 error_setg(errp, "socket family %d unsupported", 1293 sa->ss_family); 1294 return NULL; 1295 } 1296 return 0; 1297 } 1298 1299 1300 SocketAddress *socket_local_address(int fd, Error **errp) 1301 { 1302 struct sockaddr_storage ss; 1303 socklen_t sslen = sizeof(ss); 1304 1305 if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1306 error_setg_errno(errp, errno, "%s", 1307 "Unable to query local socket address"); 1308 return NULL; 1309 } 1310 1311 return socket_sockaddr_to_address(&ss, sslen, errp); 1312 } 1313 1314 1315 SocketAddress *socket_remote_address(int fd, Error **errp) 1316 { 1317 struct sockaddr_storage ss; 1318 socklen_t sslen = sizeof(ss); 1319 1320 if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1321 error_setg_errno(errp, errno, "%s", 1322 "Unable to query remote socket address"); 1323 return NULL; 1324 } 1325 1326 return socket_sockaddr_to_address(&ss, sslen, errp); 1327 } 1328 1329 1330 SocketAddress *socket_address_flatten(SocketAddressLegacy *addr_legacy) 1331 { 1332 SocketAddress *addr; 1333 1334 if (!addr_legacy) { 1335 return NULL; 1336 } 1337 1338 addr = g_new(SocketAddress, 1); 1339 1340 switch (addr_legacy->type) { 1341 case SOCKET_ADDRESS_LEGACY_KIND_INET: 1342 addr->type = SOCKET_ADDRESS_TYPE_INET; 1343 QAPI_CLONE_MEMBERS(InetSocketAddress, &addr->u.inet, 1344 addr_legacy->u.inet.data); 1345 break; 1346 case SOCKET_ADDRESS_LEGACY_KIND_UNIX: 1347 addr->type = SOCKET_ADDRESS_TYPE_UNIX; 1348 QAPI_CLONE_MEMBERS(UnixSocketAddress, &addr->u.q_unix, 1349 addr_legacy->u.q_unix.data); 1350 break; 1351 case SOCKET_ADDRESS_LEGACY_KIND_VSOCK: 1352 addr->type = SOCKET_ADDRESS_TYPE_VSOCK; 1353 QAPI_CLONE_MEMBERS(VsockSocketAddress, &addr->u.vsock, 1354 addr_legacy->u.vsock.data); 1355 break; 1356 case SOCKET_ADDRESS_LEGACY_KIND_FD: 1357 addr->type = SOCKET_ADDRESS_TYPE_FD; 1358 QAPI_CLONE_MEMBERS(String, &addr->u.fd, addr_legacy->u.fd.data); 1359 break; 1360 default: 1361 abort(); 1362 } 1363 1364 return addr; 1365 } 1366