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