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 "qemu/option.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 !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 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_set_sockopts(int sock, InetSocketAddress *saddr, Error **errp) 210 { 211 if (saddr->keep_alive) { 212 int keep_alive = 1; 213 int ret = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, 214 &keep_alive, sizeof(keep_alive)); 215 216 if (ret < 0) { 217 error_setg_errno(errp, errno, 218 "Unable to set keep-alive option on socket"); 219 return -1; 220 } 221 } 222 return 0; 223 } 224 225 static int inet_listen_saddr(InetSocketAddress *saddr, 226 int port_offset, 227 int num, 228 Error **errp) 229 { 230 ERRP_GUARD(); 231 struct addrinfo ai, *res, *e; 232 char port[33]; 233 char uaddr[INET6_ADDRSTRLEN+1]; 234 char uport[33]; 235 int rc, port_min, port_max, p; 236 int slisten = -1; 237 int saved_errno = 0; 238 bool socket_created = false; 239 240 memset(&ai,0, sizeof(ai)); 241 ai.ai_flags = AI_PASSIVE; 242 if (saddr->has_numeric && saddr->numeric) { 243 ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV; 244 } 245 ai.ai_socktype = SOCK_STREAM; 246 ai.ai_family = inet_ai_family_from_address(saddr, errp); 247 if (*errp) { 248 return -1; 249 } 250 251 if (saddr->host == NULL) { 252 error_setg(errp, "host not specified"); 253 return -1; 254 } 255 if (saddr->port != NULL) { 256 pstrcpy(port, sizeof(port), saddr->port); 257 } else { 258 port[0] = '\0'; 259 } 260 261 /* lookup */ 262 if (port_offset) { 263 uint64_t baseport; 264 if (strlen(port) == 0) { 265 error_setg(errp, "port not specified"); 266 return -1; 267 } 268 if (parse_uint_full(port, 10, &baseport) < 0) { 269 error_setg(errp, "can't convert to a number: %s", port); 270 return -1; 271 } 272 if (baseport > 65535 || 273 baseport + port_offset > 65535) { 274 error_setg(errp, "port %s out of range", port); 275 return -1; 276 } 277 snprintf(port, sizeof(port), "%d", (int)baseport + port_offset); 278 } 279 rc = getaddrinfo(strlen(saddr->host) ? saddr->host : NULL, 280 strlen(port) ? port : NULL, &ai, &res); 281 if (rc != 0) { 282 error_setg(errp, "address resolution failed for %s:%s: %s", 283 saddr->host, port, gai_strerror(rc)); 284 return -1; 285 } 286 287 /* create socket + bind/listen */ 288 for (e = res; e != NULL; e = e->ai_next) { 289 #ifdef HAVE_IPPROTO_MPTCP 290 if (saddr->has_mptcp && saddr->mptcp) { 291 e->ai_protocol = IPPROTO_MPTCP; 292 } 293 #endif 294 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 295 uaddr,INET6_ADDRSTRLEN,uport,32, 296 NI_NUMERICHOST | NI_NUMERICSERV); 297 298 port_min = inet_getport(e); 299 port_max = saddr->has_to ? saddr->to + port_offset : port_min; 300 for (p = port_min; p <= port_max; p++) { 301 if (slisten >= 0) { 302 /* 303 * We have a socket we tried with the previous port. It cannot 304 * be rebound, we need to close it and create a new one. 305 */ 306 close(slisten); 307 slisten = -1; 308 } 309 inet_setport(e, p); 310 311 slisten = create_fast_reuse_socket(e); 312 if (slisten < 0) { 313 /* 314 * First time we expect we might fail to create the socket 315 * eg if 'e' has AF_INET6 but ipv6 kmod is not loaded. 316 * Later iterations should always succeed if first iteration 317 * worked though, so treat that as fatal. 318 */ 319 if (p == port_min) { 320 continue; 321 } else { 322 error_setg_errno(errp, errno, 323 "Failed to recreate failed listening socket"); 324 goto fail; 325 } 326 } 327 socket_created = true; 328 329 rc = try_bind(slisten, saddr, e); 330 if (rc < 0) { 331 if (errno == EADDRINUSE) { 332 /* This port is already used, try the next one */ 333 continue; 334 } 335 error_setg_errno(errp, errno, "Failed to bind socket"); 336 goto fail; 337 } 338 if (listen(slisten, num)) { 339 if (errno == EADDRINUSE) { 340 /* This port is already used, try the next one */ 341 continue; 342 } 343 error_setg_errno(errp, errno, "Failed to listen on socket"); 344 goto fail; 345 } 346 /* We have a listening socket */ 347 if (inet_set_sockopts(slisten, saddr, errp) < 0) { 348 goto fail; 349 } 350 freeaddrinfo(res); 351 return slisten; 352 } 353 } 354 error_setg_errno(errp, errno, 355 socket_created ? 356 "Failed to find an available port" : 357 "Failed to create a socket"); 358 fail: 359 saved_errno = errno; 360 if (slisten >= 0) { 361 close(slisten); 362 } 363 freeaddrinfo(res); 364 errno = saved_errno; 365 return -1; 366 } 367 368 #ifdef _WIN32 369 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 370 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY) 371 #else 372 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 373 ((rc) == -EINPROGRESS) 374 #endif 375 376 static int inet_connect_addr(const InetSocketAddress *saddr, 377 struct addrinfo *addr, Error **errp) 378 { 379 int sock, rc; 380 381 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 382 if (sock < 0) { 383 error_setg_errno(errp, errno, "Failed to create socket family %d", 384 addr->ai_family); 385 return -1; 386 } 387 388 /* connect to peer */ 389 do { 390 rc = 0; 391 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) { 392 rc = -errno; 393 } 394 } while (rc == -EINTR); 395 396 if (rc < 0) { 397 error_setg_errno(errp, errno, "Failed to connect to '%s:%s'", 398 saddr->host, saddr->port); 399 close(sock); 400 return -1; 401 } 402 403 return sock; 404 } 405 406 static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr, 407 Error **errp) 408 { 409 ERRP_GUARD(); 410 struct addrinfo ai, *res; 411 int rc; 412 static int useV4Mapped = 1; 413 414 memset(&ai, 0, sizeof(ai)); 415 416 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 417 if (qatomic_read(&useV4Mapped)) { 418 ai.ai_flags |= AI_V4MAPPED; 419 } 420 ai.ai_socktype = SOCK_STREAM; 421 ai.ai_family = inet_ai_family_from_address(saddr, errp); 422 if (*errp) { 423 return NULL; 424 } 425 426 if (saddr->host == NULL || saddr->port == NULL) { 427 error_setg(errp, "host and/or port not specified"); 428 return NULL; 429 } 430 431 /* lookup */ 432 rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); 433 434 /* At least FreeBSD and OS-X 10.6 declare AI_V4MAPPED but 435 * then don't implement it in their getaddrinfo(). Detect 436 * this and retry without the flag since that's preferable 437 * to a fatal error 438 */ 439 if (rc == EAI_BADFLAGS && 440 (ai.ai_flags & AI_V4MAPPED)) { 441 qatomic_set(&useV4Mapped, 0); 442 ai.ai_flags &= ~AI_V4MAPPED; 443 rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); 444 } 445 if (rc != 0) { 446 error_setg(errp, "address resolution failed for %s:%s: %s", 447 saddr->host, saddr->port, gai_strerror(rc)); 448 return NULL; 449 } 450 return res; 451 } 452 453 /** 454 * Create a socket and connect it to an address. 455 * 456 * @saddr: Inet socket address specification 457 * @errp: set on error 458 * 459 * Returns: -1 on error, file descriptor on success. 460 */ 461 int inet_connect_saddr(InetSocketAddress *saddr, Error **errp) 462 { 463 Error *local_err = NULL; 464 struct addrinfo *res, *e; 465 int sock = -1; 466 467 res = inet_parse_connect_saddr(saddr, errp); 468 if (!res) { 469 return -1; 470 } 471 472 for (e = res; e != NULL; e = e->ai_next) { 473 error_free(local_err); 474 local_err = NULL; 475 476 #ifdef HAVE_IPPROTO_MPTCP 477 if (saddr->has_mptcp && saddr->mptcp) { 478 e->ai_protocol = IPPROTO_MPTCP; 479 } 480 #endif 481 482 sock = inet_connect_addr(saddr, e, &local_err); 483 if (sock >= 0) { 484 break; 485 } 486 } 487 488 freeaddrinfo(res); 489 490 if (sock < 0) { 491 error_propagate(errp, local_err); 492 return sock; 493 } 494 495 if (inet_set_sockopts(sock, saddr, errp) < 0) { 496 close(sock); 497 return -1; 498 } 499 500 return sock; 501 } 502 503 static int inet_dgram_saddr(InetSocketAddress *sraddr, 504 InetSocketAddress *sladdr, 505 Error **errp) 506 { 507 ERRP_GUARD(); 508 struct addrinfo ai, *peer = NULL, *local = NULL; 509 const char *addr; 510 const char *port; 511 int sock = -1, rc; 512 513 /* lookup peer addr */ 514 memset(&ai,0, sizeof(ai)); 515 ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG; 516 ai.ai_socktype = SOCK_DGRAM; 517 ai.ai_family = inet_ai_family_from_address(sraddr, errp); 518 if (*errp) { 519 goto err; 520 } 521 522 addr = sraddr->host; 523 port = sraddr->port; 524 if (addr == NULL || strlen(addr) == 0) { 525 addr = "localhost"; 526 } 527 if (port == NULL || strlen(port) == 0) { 528 error_setg(errp, "remote port not specified"); 529 goto err; 530 } 531 532 if ((rc = getaddrinfo(addr, port, &ai, &peer)) != 0) { 533 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 534 gai_strerror(rc)); 535 goto err; 536 } 537 538 /* lookup local addr */ 539 memset(&ai,0, sizeof(ai)); 540 ai.ai_flags = AI_PASSIVE; 541 ai.ai_family = peer->ai_family; 542 ai.ai_socktype = SOCK_DGRAM; 543 544 if (sladdr) { 545 addr = sladdr->host; 546 port = sladdr->port; 547 if (addr == NULL || strlen(addr) == 0) { 548 addr = NULL; 549 } 550 if (!port || strlen(port) == 0) { 551 port = "0"; 552 } 553 } else { 554 addr = NULL; 555 port = "0"; 556 } 557 558 if ((rc = getaddrinfo(addr, port, &ai, &local)) != 0) { 559 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 560 gai_strerror(rc)); 561 goto err; 562 } 563 564 /* create socket */ 565 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol); 566 if (sock < 0) { 567 error_setg_errno(errp, errno, "Failed to create socket family %d", 568 peer->ai_family); 569 goto err; 570 } 571 socket_set_fast_reuse(sock); 572 573 /* bind socket */ 574 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) { 575 error_setg_errno(errp, errno, "Failed to bind socket"); 576 goto err; 577 } 578 579 /* connect to peer */ 580 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) { 581 error_setg_errno(errp, errno, "Failed to connect to '%s:%s'", 582 addr, port); 583 goto err; 584 } 585 586 freeaddrinfo(local); 587 freeaddrinfo(peer); 588 return sock; 589 590 err: 591 if (sock != -1) { 592 close(sock); 593 } 594 if (local) { 595 freeaddrinfo(local); 596 } 597 if (peer) { 598 freeaddrinfo(peer); 599 } 600 601 return -1; 602 } 603 604 static QemuOptsList inet_opts = { 605 .name = "InetSocketAddress", 606 .head = QTAILQ_HEAD_INITIALIZER(inet_opts.head), 607 .implied_opt_name = "addr", 608 .desc = { 609 { 610 .name = "addr", 611 .type = QEMU_OPT_STRING, 612 }, 613 { 614 .name = "numeric", 615 .type = QEMU_OPT_BOOL, 616 }, 617 { 618 .name = "to", 619 .type = QEMU_OPT_NUMBER, 620 }, 621 { 622 .name = "ipv4", 623 .type = QEMU_OPT_BOOL, 624 }, 625 { 626 .name = "ipv6", 627 .type = QEMU_OPT_BOOL, 628 }, 629 { 630 .name = "keep-alive", 631 .type = QEMU_OPT_BOOL, 632 }, 633 #ifdef HAVE_IPPROTO_MPTCP 634 { 635 .name = "mptcp", 636 .type = QEMU_OPT_BOOL, 637 }, 638 #endif 639 { /* end of list */ } 640 }, 641 }; 642 643 int inet_parse(InetSocketAddress *addr, const char *str, Error **errp) 644 { 645 QemuOpts *opts = qemu_opts_parse(&inet_opts, str, true, errp); 646 if (!opts) { 647 return -1; 648 } 649 memset(addr, 0, sizeof(*addr)); 650 651 /* parse address */ 652 const char *addr_str = qemu_opt_get(opts, "addr"); 653 if (!addr_str) { 654 error_setg(errp, "error parsing address ''"); 655 return -1; 656 } 657 if (str[0] == '[') { 658 /* IPv6 addr */ 659 const char *ip_end = strstr(addr_str, "]:"); 660 if (!ip_end || ip_end - addr_str < 2 || strlen(ip_end) < 3) { 661 error_setg(errp, "error parsing IPv6 address '%s'", addr_str); 662 return -1; 663 } 664 addr->host = g_strndup(addr_str + 1, ip_end - addr_str - 1); 665 addr->port = g_strdup(ip_end + 2); 666 } else { 667 /* no host, hostname or IPv4 addr */ 668 const char *port = strchr(addr_str, ':'); 669 if (!port || strlen(port) < 2) { 670 error_setg(errp, "error parsing address '%s'", addr_str); 671 return -1; 672 } 673 addr->host = g_strndup(addr_str, port - addr_str); 674 addr->port = g_strdup(port + 1); 675 } 676 677 /* parse options */ 678 if (qemu_opt_find(opts, "numeric")) { 679 addr->has_numeric = true, 680 addr->numeric = qemu_opt_get_bool(opts, "numeric", false); 681 } 682 if (qemu_opt_find(opts, "to")) { 683 addr->has_to = true; 684 addr->to = qemu_opt_get_number(opts, "to", 0); 685 } 686 if (qemu_opt_find(opts, "ipv4")) { 687 addr->has_ipv4 = true; 688 addr->ipv4 = qemu_opt_get_bool(opts, "ipv4", false); 689 } 690 if (qemu_opt_find(opts, "ipv6")) { 691 addr->has_ipv6 = true; 692 addr->ipv6 = qemu_opt_get_bool(opts, "ipv6", false); 693 } 694 if (qemu_opt_find(opts, "keep-alive")) { 695 addr->has_keep_alive = true; 696 addr->keep_alive = qemu_opt_get_bool(opts, "keep-alive", false); 697 } 698 #ifdef HAVE_IPPROTO_MPTCP 699 if (qemu_opt_find(opts, "mptcp")) { 700 addr->has_mptcp = true; 701 addr->mptcp = qemu_opt_get_bool(opts, "mptcp", 0); 702 } 703 #endif 704 return 0; 705 } 706 707 708 #ifdef CONFIG_AF_VSOCK 709 static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr, 710 struct sockaddr_vm *svm, 711 Error **errp) 712 { 713 uint64_t val; 714 715 memset(svm, 0, sizeof(*svm)); 716 svm->svm_family = AF_VSOCK; 717 718 if (parse_uint_full(vaddr->cid, 10, &val) < 0 || 719 val > UINT32_MAX) { 720 error_setg(errp, "Failed to parse cid '%s'", vaddr->cid); 721 return false; 722 } 723 svm->svm_cid = val; 724 725 if (parse_uint_full(vaddr->port, 10, &val) < 0 || 726 val > UINT32_MAX) { 727 error_setg(errp, "Failed to parse port '%s'", vaddr->port); 728 return false; 729 } 730 svm->svm_port = val; 731 732 return true; 733 } 734 735 static int vsock_connect_addr(const VsockSocketAddress *vaddr, 736 const struct sockaddr_vm *svm, Error **errp) 737 { 738 int sock, rc; 739 740 sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); 741 if (sock < 0) { 742 error_setg_errno(errp, errno, "Failed to create socket family %d", 743 AF_VSOCK); 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 to '%s:%s'", 757 vaddr->cid, vaddr->port); 758 close(sock); 759 return -1; 760 } 761 762 return sock; 763 } 764 765 static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp) 766 { 767 struct sockaddr_vm svm; 768 769 if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { 770 return -1; 771 } 772 773 return vsock_connect_addr(vaddr, &svm, errp); 774 } 775 776 static int vsock_listen_saddr(VsockSocketAddress *vaddr, 777 int num, 778 Error **errp) 779 { 780 struct sockaddr_vm svm; 781 int slisten; 782 783 if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { 784 return -1; 785 } 786 787 slisten = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); 788 if (slisten < 0) { 789 error_setg_errno(errp, errno, "Failed to create socket"); 790 return -1; 791 } 792 793 if (bind(slisten, (const struct sockaddr *)&svm, sizeof(svm)) != 0) { 794 error_setg_errno(errp, errno, "Failed to bind socket"); 795 close(slisten); 796 return -1; 797 } 798 799 if (listen(slisten, num) != 0) { 800 error_setg_errno(errp, errno, "Failed to listen on socket"); 801 close(slisten); 802 return -1; 803 } 804 return slisten; 805 } 806 807 static int vsock_parse(VsockSocketAddress *addr, const char *str, 808 Error **errp) 809 { 810 char cid[33]; 811 char port[33]; 812 int n; 813 814 if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) { 815 error_setg(errp, "error parsing address '%s'", str); 816 return -1; 817 } 818 if (str[n] != '\0') { 819 error_setg(errp, "trailing characters in address '%s'", str); 820 return -1; 821 } 822 823 addr->cid = g_strdup(cid); 824 addr->port = g_strdup(port); 825 return 0; 826 } 827 #else 828 static void vsock_unsupported(Error **errp) 829 { 830 error_setg(errp, "socket family AF_VSOCK unsupported"); 831 } 832 833 static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp) 834 { 835 vsock_unsupported(errp); 836 return -1; 837 } 838 839 static int vsock_listen_saddr(VsockSocketAddress *vaddr, 840 int num, 841 Error **errp) 842 { 843 vsock_unsupported(errp); 844 return -1; 845 } 846 847 static int vsock_parse(VsockSocketAddress *addr, const char *str, 848 Error **errp) 849 { 850 vsock_unsupported(errp); 851 return -1; 852 } 853 #endif /* CONFIG_AF_VSOCK */ 854 855 static bool saddr_is_abstract(UnixSocketAddress *saddr) 856 { 857 #ifdef CONFIG_LINUX 858 return saddr->abstract; 859 #else 860 return false; 861 #endif 862 } 863 864 static bool saddr_is_tight(UnixSocketAddress *saddr) 865 { 866 #ifdef CONFIG_LINUX 867 return !saddr->has_tight || saddr->tight; 868 #else 869 return false; 870 #endif 871 } 872 873 static int unix_listen_saddr(UnixSocketAddress *saddr, 874 int num, 875 Error **errp) 876 { 877 bool abstract = saddr_is_abstract(saddr); 878 struct sockaddr_un un; 879 int sock, fd; 880 char *pathbuf = NULL; 881 const char *path; 882 size_t pathlen; 883 size_t addrlen; 884 885 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 886 if (sock < 0) { 887 error_setg_errno(errp, errno, "Failed to create Unix socket"); 888 return -1; 889 } 890 891 if (saddr->path[0] || abstract) { 892 path = saddr->path; 893 } else { 894 path = pathbuf = g_strdup_printf("%s/qemu-socket-XXXXXX", 895 g_get_tmp_dir()); 896 } 897 898 pathlen = strlen(path); 899 if (pathlen > sizeof(un.sun_path) || 900 (abstract && pathlen > (sizeof(un.sun_path) - 1))) { 901 error_setg(errp, "UNIX socket path '%s' is too long", path); 902 error_append_hint(errp, "Path must be less than %zu bytes\n", 903 abstract ? sizeof(un.sun_path) - 1 : 904 sizeof(un.sun_path)); 905 goto err; 906 } 907 908 if (pathbuf != NULL) { 909 /* 910 * This dummy fd usage silences the mktemp() insecure warning. 911 * Using mkstemp() doesn't make things more secure here 912 * though. bind() complains about existing files, so we have 913 * to unlink first and thus re-open the race window. The 914 * worst case possible is bind() failing, i.e. a DoS attack. 915 */ 916 fd = mkstemp(pathbuf); 917 if (fd < 0) { 918 error_setg_errno(errp, errno, 919 "Failed to make a temporary socket %s", pathbuf); 920 goto err; 921 } 922 close(fd); 923 } 924 925 if (!abstract && unlink(path) < 0 && errno != ENOENT) { 926 error_setg_errno(errp, errno, 927 "Failed to unlink socket %s", path); 928 goto err; 929 } 930 931 memset(&un, 0, sizeof(un)); 932 un.sun_family = AF_UNIX; 933 addrlen = sizeof(un); 934 935 if (abstract) { 936 un.sun_path[0] = '\0'; 937 memcpy(&un.sun_path[1], path, pathlen); 938 if (saddr_is_tight(saddr)) { 939 addrlen = offsetof(struct sockaddr_un, sun_path) + 1 + pathlen; 940 } 941 } else { 942 memcpy(un.sun_path, path, pathlen); 943 } 944 945 if (bind(sock, (struct sockaddr *) &un, addrlen) < 0) { 946 error_setg_errno(errp, errno, "Failed to bind socket to %s", path); 947 goto err; 948 } 949 if (listen(sock, num) < 0) { 950 error_setg_errno(errp, errno, "Failed to listen on socket"); 951 goto err; 952 } 953 954 g_free(pathbuf); 955 return sock; 956 957 err: 958 g_free(pathbuf); 959 close(sock); 960 return -1; 961 } 962 963 static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp) 964 { 965 bool abstract = saddr_is_abstract(saddr); 966 struct sockaddr_un un; 967 int sock, rc; 968 size_t pathlen; 969 size_t addrlen; 970 971 if (saddr->path == NULL) { 972 error_setg(errp, "unix connect: no path specified"); 973 return -1; 974 } 975 976 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 977 if (sock < 0) { 978 error_setg_errno(errp, errno, "Failed to create socket"); 979 return -1; 980 } 981 982 pathlen = strlen(saddr->path); 983 if (pathlen > sizeof(un.sun_path) || 984 (abstract && pathlen > (sizeof(un.sun_path) - 1))) { 985 error_setg(errp, "UNIX socket path '%s' is too long", saddr->path); 986 error_append_hint(errp, "Path must be less than %zu bytes\n", 987 abstract ? sizeof(un.sun_path) - 1 : 988 sizeof(un.sun_path)); 989 goto err; 990 } 991 992 memset(&un, 0, sizeof(un)); 993 un.sun_family = AF_UNIX; 994 addrlen = sizeof(un); 995 996 if (abstract) { 997 un.sun_path[0] = '\0'; 998 memcpy(&un.sun_path[1], saddr->path, pathlen); 999 if (saddr_is_tight(saddr)) { 1000 addrlen = offsetof(struct sockaddr_un, sun_path) + 1 + pathlen; 1001 } 1002 } else { 1003 memcpy(un.sun_path, saddr->path, pathlen); 1004 } 1005 /* connect to peer */ 1006 do { 1007 rc = 0; 1008 if (connect(sock, (struct sockaddr *) &un, addrlen) < 0) { 1009 rc = -errno; 1010 } 1011 } while (rc == -EINTR); 1012 1013 if (rc < 0) { 1014 error_setg_errno(errp, -rc, "Failed to connect to '%s'", 1015 saddr->path); 1016 goto err; 1017 } 1018 1019 return sock; 1020 1021 err: 1022 close(sock); 1023 return -1; 1024 } 1025 1026 /* compatibility wrapper */ 1027 int unix_listen(const char *str, Error **errp) 1028 { 1029 UnixSocketAddress *saddr; 1030 int sock; 1031 1032 saddr = g_new0(UnixSocketAddress, 1); 1033 saddr->path = g_strdup(str); 1034 sock = unix_listen_saddr(saddr, 1, errp); 1035 qapi_free_UnixSocketAddress(saddr); 1036 return sock; 1037 } 1038 1039 int unix_connect(const char *path, Error **errp) 1040 { 1041 UnixSocketAddress *saddr; 1042 int sock; 1043 1044 saddr = g_new0(UnixSocketAddress, 1); 1045 saddr->path = g_strdup(path); 1046 sock = unix_connect_saddr(saddr, errp); 1047 qapi_free_UnixSocketAddress(saddr); 1048 return sock; 1049 } 1050 1051 char *socket_uri(SocketAddress *addr) 1052 { 1053 switch (addr->type) { 1054 case SOCKET_ADDRESS_TYPE_INET: 1055 return g_strdup_printf("tcp:%s:%s", 1056 addr->u.inet.host, 1057 addr->u.inet.port); 1058 case SOCKET_ADDRESS_TYPE_UNIX: 1059 return g_strdup_printf("unix:%s", 1060 addr->u.q_unix.path); 1061 case SOCKET_ADDRESS_TYPE_FD: 1062 return g_strdup_printf("fd:%s", addr->u.fd.str); 1063 case SOCKET_ADDRESS_TYPE_VSOCK: 1064 return g_strdup_printf("vsock:%s:%s", 1065 addr->u.vsock.cid, 1066 addr->u.vsock.port); 1067 default: 1068 return g_strdup("unknown address type"); 1069 } 1070 } 1071 1072 SocketAddress *socket_parse(const char *str, Error **errp) 1073 { 1074 SocketAddress *addr; 1075 1076 addr = g_new0(SocketAddress, 1); 1077 if (strstart(str, "unix:", NULL)) { 1078 if (str[5] == '\0') { 1079 error_setg(errp, "invalid Unix socket address"); 1080 goto fail; 1081 } else { 1082 addr->type = SOCKET_ADDRESS_TYPE_UNIX; 1083 addr->u.q_unix.path = g_strdup(str + 5); 1084 } 1085 } else if (strstart(str, "fd:", NULL)) { 1086 if (str[3] == '\0') { 1087 error_setg(errp, "invalid file descriptor address"); 1088 goto fail; 1089 } else { 1090 addr->type = SOCKET_ADDRESS_TYPE_FD; 1091 addr->u.fd.str = g_strdup(str + 3); 1092 } 1093 } else if (strstart(str, "vsock:", NULL)) { 1094 addr->type = SOCKET_ADDRESS_TYPE_VSOCK; 1095 if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) { 1096 goto fail; 1097 } 1098 } else if (strstart(str, "tcp:", NULL)) { 1099 addr->type = SOCKET_ADDRESS_TYPE_INET; 1100 if (inet_parse(&addr->u.inet, str + strlen("tcp:"), errp)) { 1101 goto fail; 1102 } 1103 } else { 1104 addr->type = SOCKET_ADDRESS_TYPE_INET; 1105 if (inet_parse(&addr->u.inet, str, errp)) { 1106 goto fail; 1107 } 1108 } 1109 return addr; 1110 1111 fail: 1112 qapi_free_SocketAddress(addr); 1113 return NULL; 1114 } 1115 1116 static int socket_get_fd(const char *fdstr, Error **errp) 1117 { 1118 Monitor *cur_mon = monitor_cur(); 1119 int fd; 1120 if (cur_mon) { 1121 fd = monitor_get_fd(cur_mon, fdstr, errp); 1122 if (fd < 0) { 1123 return -1; 1124 } 1125 } else { 1126 if (qemu_strtoi(fdstr, NULL, 10, &fd) < 0) { 1127 error_setg_errno(errp, errno, 1128 "Unable to parse FD number %s", 1129 fdstr); 1130 return -1; 1131 } 1132 } 1133 if (!fd_is_socket(fd)) { 1134 error_setg(errp, "File descriptor '%s' is not a socket", fdstr); 1135 close(fd); 1136 return -1; 1137 } 1138 return fd; 1139 } 1140 1141 int socket_address_parse_named_fd(SocketAddress *addr, Error **errp) 1142 { 1143 int fd; 1144 1145 if (addr->type != SOCKET_ADDRESS_TYPE_FD) { 1146 return 0; 1147 } 1148 1149 fd = socket_get_fd(addr->u.fd.str, errp); 1150 if (fd < 0) { 1151 return fd; 1152 } 1153 1154 g_free(addr->u.fd.str); 1155 addr->u.fd.str = g_strdup_printf("%d", fd); 1156 1157 return 0; 1158 } 1159 1160 int socket_connect(SocketAddress *addr, Error **errp) 1161 { 1162 int fd; 1163 1164 switch (addr->type) { 1165 case SOCKET_ADDRESS_TYPE_INET: 1166 fd = inet_connect_saddr(&addr->u.inet, errp); 1167 break; 1168 1169 case SOCKET_ADDRESS_TYPE_UNIX: 1170 fd = unix_connect_saddr(&addr->u.q_unix, errp); 1171 break; 1172 1173 case SOCKET_ADDRESS_TYPE_FD: 1174 fd = socket_get_fd(addr->u.fd.str, errp); 1175 break; 1176 1177 case SOCKET_ADDRESS_TYPE_VSOCK: 1178 fd = vsock_connect_saddr(&addr->u.vsock, errp); 1179 break; 1180 1181 default: 1182 abort(); 1183 } 1184 return fd; 1185 } 1186 1187 int socket_listen(SocketAddress *addr, int num, Error **errp) 1188 { 1189 int fd; 1190 1191 trace_socket_listen(num); 1192 switch (addr->type) { 1193 case SOCKET_ADDRESS_TYPE_INET: 1194 fd = inet_listen_saddr(&addr->u.inet, 0, num, errp); 1195 break; 1196 1197 case SOCKET_ADDRESS_TYPE_UNIX: 1198 fd = unix_listen_saddr(&addr->u.q_unix, num, errp); 1199 break; 1200 1201 case SOCKET_ADDRESS_TYPE_FD: 1202 fd = socket_get_fd(addr->u.fd.str, errp); 1203 if (fd < 0) { 1204 return -1; 1205 } 1206 1207 /* 1208 * If the socket is not yet in the listen state, then transition it to 1209 * the listen state now. 1210 * 1211 * If it's already listening then this updates the backlog value as 1212 * requested. 1213 * 1214 * If this socket cannot listen because it's already in another state 1215 * (e.g. unbound or connected) then we'll catch the error here. 1216 */ 1217 if (listen(fd, num) != 0) { 1218 error_setg_errno(errp, errno, "Failed to listen on fd socket"); 1219 close(fd); 1220 return -1; 1221 } 1222 break; 1223 1224 case SOCKET_ADDRESS_TYPE_VSOCK: 1225 fd = vsock_listen_saddr(&addr->u.vsock, num, errp); 1226 break; 1227 1228 default: 1229 abort(); 1230 } 1231 return fd; 1232 } 1233 1234 void socket_listen_cleanup(int fd, Error **errp) 1235 { 1236 SocketAddress *addr; 1237 1238 addr = socket_local_address(fd, errp); 1239 if (!addr) { 1240 return; 1241 } 1242 1243 if (addr->type == SOCKET_ADDRESS_TYPE_UNIX 1244 && addr->u.q_unix.path) { 1245 if (unlink(addr->u.q_unix.path) < 0 && errno != ENOENT) { 1246 error_setg_errno(errp, errno, 1247 "Failed to unlink socket %s", 1248 addr->u.q_unix.path); 1249 } 1250 } 1251 1252 qapi_free_SocketAddress(addr); 1253 } 1254 1255 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp) 1256 { 1257 int fd; 1258 1259 /* 1260 * TODO SOCKET_ADDRESS_TYPE_FD when fd is AF_INET or AF_INET6 1261 * (although other address families can do SOCK_DGRAM, too) 1262 */ 1263 switch (remote->type) { 1264 case SOCKET_ADDRESS_TYPE_INET: 1265 fd = inet_dgram_saddr(&remote->u.inet, 1266 local ? &local->u.inet : NULL, errp); 1267 break; 1268 1269 default: 1270 error_setg(errp, "socket type unsupported for datagram"); 1271 fd = -1; 1272 } 1273 return fd; 1274 } 1275 1276 1277 static SocketAddress * 1278 socket_sockaddr_to_address_inet(struct sockaddr_storage *sa, 1279 socklen_t salen, 1280 Error **errp) 1281 { 1282 char host[NI_MAXHOST]; 1283 char serv[NI_MAXSERV]; 1284 SocketAddress *addr; 1285 InetSocketAddress *inet; 1286 int ret; 1287 1288 ret = getnameinfo((struct sockaddr *)sa, salen, 1289 host, sizeof(host), 1290 serv, sizeof(serv), 1291 NI_NUMERICHOST | NI_NUMERICSERV); 1292 if (ret != 0) { 1293 error_setg(errp, "Cannot format numeric socket address: %s", 1294 gai_strerror(ret)); 1295 return NULL; 1296 } 1297 1298 addr = g_new0(SocketAddress, 1); 1299 addr->type = SOCKET_ADDRESS_TYPE_INET; 1300 inet = &addr->u.inet; 1301 inet->host = g_strdup(host); 1302 inet->port = g_strdup(serv); 1303 if (sa->ss_family == AF_INET) { 1304 inet->has_ipv4 = inet->ipv4 = true; 1305 } else { 1306 inet->has_ipv6 = inet->ipv6 = true; 1307 } 1308 1309 return addr; 1310 } 1311 1312 1313 static SocketAddress * 1314 socket_sockaddr_to_address_unix(struct sockaddr_storage *sa, 1315 socklen_t salen, 1316 Error **errp) 1317 { 1318 SocketAddress *addr; 1319 struct sockaddr_un *su = (struct sockaddr_un *)sa; 1320 1321 addr = g_new0(SocketAddress, 1); 1322 addr->type = SOCKET_ADDRESS_TYPE_UNIX; 1323 salen -= offsetof(struct sockaddr_un, sun_path); 1324 #ifdef CONFIG_LINUX 1325 if (salen > 0 && !su->sun_path[0]) { 1326 /* Linux abstract socket */ 1327 addr->u.q_unix.path = g_strndup(su->sun_path + 1, salen - 1); 1328 addr->u.q_unix.has_abstract = true; 1329 addr->u.q_unix.abstract = true; 1330 addr->u.q_unix.has_tight = true; 1331 addr->u.q_unix.tight = salen < sizeof(su->sun_path); 1332 return addr; 1333 } 1334 #endif 1335 1336 addr->u.q_unix.path = g_strndup(su->sun_path, salen); 1337 return addr; 1338 } 1339 1340 #ifdef CONFIG_AF_VSOCK 1341 static SocketAddress * 1342 socket_sockaddr_to_address_vsock(struct sockaddr_storage *sa, 1343 socklen_t salen, 1344 Error **errp) 1345 { 1346 SocketAddress *addr; 1347 VsockSocketAddress *vaddr; 1348 struct sockaddr_vm *svm = (struct sockaddr_vm *)sa; 1349 1350 addr = g_new0(SocketAddress, 1); 1351 addr->type = SOCKET_ADDRESS_TYPE_VSOCK; 1352 vaddr = &addr->u.vsock; 1353 vaddr->cid = g_strdup_printf("%u", svm->svm_cid); 1354 vaddr->port = g_strdup_printf("%u", svm->svm_port); 1355 1356 return addr; 1357 } 1358 #endif /* CONFIG_AF_VSOCK */ 1359 1360 SocketAddress * 1361 socket_sockaddr_to_address(struct sockaddr_storage *sa, 1362 socklen_t salen, 1363 Error **errp) 1364 { 1365 switch (sa->ss_family) { 1366 case AF_INET: 1367 case AF_INET6: 1368 return socket_sockaddr_to_address_inet(sa, salen, errp); 1369 1370 case AF_UNIX: 1371 return socket_sockaddr_to_address_unix(sa, salen, errp); 1372 1373 #ifdef CONFIG_AF_VSOCK 1374 case AF_VSOCK: 1375 return socket_sockaddr_to_address_vsock(sa, salen, errp); 1376 #endif 1377 1378 default: 1379 error_setg(errp, "socket family %d unsupported", 1380 sa->ss_family); 1381 return NULL; 1382 } 1383 return 0; 1384 } 1385 1386 1387 SocketAddress *socket_local_address(int fd, Error **errp) 1388 { 1389 struct sockaddr_storage ss; 1390 socklen_t sslen = sizeof(ss); 1391 1392 if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1393 error_setg_errno(errp, errno, "%s", 1394 "Unable to query local socket address"); 1395 return NULL; 1396 } 1397 1398 return socket_sockaddr_to_address(&ss, sslen, errp); 1399 } 1400 1401 1402 SocketAddress *socket_address_flatten(SocketAddressLegacy *addr_legacy) 1403 { 1404 SocketAddress *addr; 1405 1406 if (!addr_legacy) { 1407 return NULL; 1408 } 1409 1410 addr = g_new(SocketAddress, 1); 1411 1412 switch (addr_legacy->type) { 1413 case SOCKET_ADDRESS_TYPE_INET: 1414 addr->type = SOCKET_ADDRESS_TYPE_INET; 1415 QAPI_CLONE_MEMBERS(InetSocketAddress, &addr->u.inet, 1416 addr_legacy->u.inet.data); 1417 break; 1418 case SOCKET_ADDRESS_TYPE_UNIX: 1419 addr->type = SOCKET_ADDRESS_TYPE_UNIX; 1420 QAPI_CLONE_MEMBERS(UnixSocketAddress, &addr->u.q_unix, 1421 addr_legacy->u.q_unix.data); 1422 break; 1423 case SOCKET_ADDRESS_TYPE_VSOCK: 1424 addr->type = SOCKET_ADDRESS_TYPE_VSOCK; 1425 QAPI_CLONE_MEMBERS(VsockSocketAddress, &addr->u.vsock, 1426 addr_legacy->u.vsock.data); 1427 break; 1428 case SOCKET_ADDRESS_TYPE_FD: 1429 addr->type = SOCKET_ADDRESS_TYPE_FD; 1430 QAPI_CLONE_MEMBERS(FdSocketAddress, &addr->u.fd, 1431 addr_legacy->u.fd.data); 1432 break; 1433 default: 1434 abort(); 1435 } 1436 1437 return addr; 1438 } 1439