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