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