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