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 int inet_parse(InetSocketAddress *addr, const char *str, Error **errp) 582 { 583 const char *optstr, *h; 584 char host[65]; 585 char port[33]; 586 int to; 587 int pos; 588 589 memset(addr, 0, sizeof(*addr)); 590 591 /* parse address */ 592 if (str[0] == ':') { 593 /* no host given */ 594 host[0] = '\0'; 595 if (sscanf(str, ":%32[^,]%n", port, &pos) != 1) { 596 error_setg(errp, "error parsing port in address '%s'", str); 597 return -1; 598 } 599 } else if (str[0] == '[') { 600 /* IPv6 addr */ 601 if (sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos) != 2) { 602 error_setg(errp, "error parsing IPv6 address '%s'", str); 603 return -1; 604 } 605 addr->ipv6 = addr->has_ipv6 = true; 606 } else { 607 /* hostname or IPv4 addr */ 608 if (sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos) != 2) { 609 error_setg(errp, "error parsing address '%s'", str); 610 return -1; 611 } 612 if (host[strspn(host, "0123456789.")] == '\0') { 613 addr->ipv4 = addr->has_ipv4 = true; 614 } 615 } 616 617 addr->host = g_strdup(host); 618 addr->port = g_strdup(port); 619 620 /* parse options */ 621 optstr = str + pos; 622 h = strstr(optstr, ",to="); 623 if (h) { 624 h += 4; 625 if (sscanf(h, "%d%n", &to, &pos) != 1 || 626 (h[pos] != '\0' && h[pos] != ',')) { 627 error_setg(errp, "error parsing to= argument"); 628 return -1; 629 } 630 addr->has_to = true; 631 addr->to = to; 632 } 633 if (strstr(optstr, ",ipv4")) { 634 addr->ipv4 = addr->has_ipv4 = true; 635 } 636 if (strstr(optstr, ",ipv6")) { 637 addr->ipv6 = addr->has_ipv6 = true; 638 } 639 return 0; 640 } 641 642 643 /** 644 * Create a blocking socket and connect it to an address. 645 * 646 * @str: address string 647 * @errp: set in case of an error 648 * 649 * Returns -1 in case of error, file descriptor on success 650 **/ 651 int inet_connect(const char *str, Error **errp) 652 { 653 int sock = -1; 654 InetSocketAddress *addr = g_new(InetSocketAddress, 1); 655 656 if (!inet_parse(addr, str, errp)) { 657 sock = inet_connect_saddr(addr, NULL, NULL, errp); 658 } 659 qapi_free_InetSocketAddress(addr); 660 return sock; 661 } 662 663 #ifdef CONFIG_AF_VSOCK 664 static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr, 665 struct sockaddr_vm *svm, 666 Error **errp) 667 { 668 unsigned long long val; 669 670 memset(svm, 0, sizeof(*svm)); 671 svm->svm_family = AF_VSOCK; 672 673 if (parse_uint_full(vaddr->cid, &val, 10) < 0 || 674 val > UINT32_MAX) { 675 error_setg(errp, "Failed to parse cid '%s'", vaddr->cid); 676 return false; 677 } 678 svm->svm_cid = val; 679 680 if (parse_uint_full(vaddr->port, &val, 10) < 0 || 681 val > UINT32_MAX) { 682 error_setg(errp, "Failed to parse port '%s'", vaddr->port); 683 return false; 684 } 685 svm->svm_port = val; 686 687 return true; 688 } 689 690 static int vsock_connect_addr(const struct sockaddr_vm *svm, bool *in_progress, 691 ConnectState *connect_state, Error **errp) 692 { 693 int sock, rc; 694 695 *in_progress = false; 696 697 sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); 698 if (sock < 0) { 699 error_setg_errno(errp, errno, "Failed to create socket"); 700 return -1; 701 } 702 if (connect_state != NULL) { 703 qemu_set_nonblock(sock); 704 } 705 /* connect to peer */ 706 do { 707 rc = 0; 708 if (connect(sock, (const struct sockaddr *)svm, sizeof(*svm)) < 0) { 709 rc = -errno; 710 } 711 } while (rc == -EINTR); 712 713 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 714 connect_state->fd = sock; 715 qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state); 716 *in_progress = true; 717 } else if (rc < 0) { 718 error_setg_errno(errp, errno, "Failed to connect socket"); 719 closesocket(sock); 720 return -1; 721 } 722 return sock; 723 } 724 725 static int vsock_connect_saddr(VsockSocketAddress *vaddr, 726 NonBlockingConnectHandler *callback, 727 void *opaque, 728 Error **errp) 729 { 730 struct sockaddr_vm svm; 731 int sock = -1; 732 bool in_progress; 733 ConnectState *connect_state = NULL; 734 735 if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { 736 return -1; 737 } 738 739 if (callback != NULL) { 740 connect_state = g_malloc0(sizeof(*connect_state)); 741 connect_state->callback = callback; 742 connect_state->opaque = opaque; 743 } 744 745 sock = vsock_connect_addr(&svm, &in_progress, connect_state, errp); 746 if (sock < 0) { 747 /* do nothing */ 748 } else if (in_progress) { 749 /* wait_for_connect() will do the rest */ 750 return sock; 751 } else { 752 if (callback) { 753 callback(sock, NULL, opaque); 754 } 755 } 756 g_free(connect_state); 757 return sock; 758 } 759 760 static int vsock_listen_saddr(VsockSocketAddress *vaddr, 761 Error **errp) 762 { 763 struct sockaddr_vm svm; 764 int slisten; 765 766 if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { 767 return -1; 768 } 769 770 slisten = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); 771 if (slisten < 0) { 772 error_setg_errno(errp, errno, "Failed to create socket"); 773 return -1; 774 } 775 776 if (bind(slisten, (const struct sockaddr *)&svm, sizeof(svm)) != 0) { 777 error_setg_errno(errp, errno, "Failed to bind socket"); 778 closesocket(slisten); 779 return -1; 780 } 781 782 if (listen(slisten, 1) != 0) { 783 error_setg_errno(errp, errno, "Failed to listen on socket"); 784 closesocket(slisten); 785 return -1; 786 } 787 return slisten; 788 } 789 790 static int vsock_parse(VsockSocketAddress *addr, const char *str, 791 Error **errp) 792 { 793 char cid[33]; 794 char port[33]; 795 int n; 796 797 if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) { 798 error_setg(errp, "error parsing address '%s'", str); 799 return -1; 800 } 801 if (str[n] != '\0') { 802 error_setg(errp, "trailing characters in address '%s'", str); 803 return -1; 804 } 805 806 addr->cid = g_strdup(cid); 807 addr->port = g_strdup(port); 808 return 0; 809 } 810 #else 811 static void vsock_unsupported(Error **errp) 812 { 813 error_setg(errp, "socket family AF_VSOCK unsupported"); 814 } 815 816 static int vsock_connect_saddr(VsockSocketAddress *vaddr, 817 NonBlockingConnectHandler *callback, 818 void *opaque, Error **errp) 819 { 820 vsock_unsupported(errp); 821 return -1; 822 } 823 824 static int vsock_listen_saddr(VsockSocketAddress *vaddr, 825 Error **errp) 826 { 827 vsock_unsupported(errp); 828 return -1; 829 } 830 831 static int vsock_parse(VsockSocketAddress *addr, const char *str, 832 Error **errp) 833 { 834 vsock_unsupported(errp); 835 return -1; 836 } 837 #endif /* CONFIG_AF_VSOCK */ 838 839 #ifndef _WIN32 840 841 static int unix_listen_saddr(UnixSocketAddress *saddr, 842 bool update_addr, 843 Error **errp) 844 { 845 struct sockaddr_un un; 846 int sock, fd; 847 848 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 849 if (sock < 0) { 850 error_setg_errno(errp, errno, "Failed to create Unix socket"); 851 return -1; 852 } 853 854 memset(&un, 0, sizeof(un)); 855 un.sun_family = AF_UNIX; 856 if (saddr->path && strlen(saddr->path)) { 857 snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path); 858 } else { 859 const char *tmpdir = getenv("TMPDIR"); 860 tmpdir = tmpdir ? tmpdir : "/tmp"; 861 if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX", 862 tmpdir) >= sizeof(un.sun_path)) { 863 error_setg_errno(errp, errno, 864 "TMPDIR environment variable (%s) too large", tmpdir); 865 goto err; 866 } 867 868 /* 869 * This dummy fd usage silences the mktemp() unsecure warning. 870 * Using mkstemp() doesn't make things more secure here 871 * though. bind() complains about existing files, so we have 872 * to unlink first and thus re-open the race window. The 873 * worst case possible is bind() failing, i.e. a DoS attack. 874 */ 875 fd = mkstemp(un.sun_path); 876 if (fd < 0) { 877 error_setg_errno(errp, errno, 878 "Failed to make a temporary socket name in %s", tmpdir); 879 goto err; 880 } 881 close(fd); 882 if (update_addr) { 883 g_free(saddr->path); 884 saddr->path = g_strdup(un.sun_path); 885 } 886 } 887 888 if (unlink(un.sun_path) < 0 && errno != ENOENT) { 889 error_setg_errno(errp, errno, 890 "Failed to unlink socket %s", un.sun_path); 891 goto err; 892 } 893 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 894 error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path); 895 goto err; 896 } 897 if (listen(sock, 1) < 0) { 898 error_setg_errno(errp, errno, "Failed to listen on socket"); 899 goto err; 900 } 901 902 return sock; 903 904 err: 905 closesocket(sock); 906 return -1; 907 } 908 909 static int unix_connect_saddr(UnixSocketAddress *saddr, 910 NonBlockingConnectHandler *callback, void *opaque, 911 Error **errp) 912 { 913 struct sockaddr_un un; 914 ConnectState *connect_state = NULL; 915 int sock, rc; 916 917 if (saddr->path == NULL) { 918 error_setg(errp, "unix connect: no path specified"); 919 return -1; 920 } 921 922 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 923 if (sock < 0) { 924 error_setg_errno(errp, errno, "Failed to create socket"); 925 return -1; 926 } 927 if (callback != NULL) { 928 connect_state = g_malloc0(sizeof(*connect_state)); 929 connect_state->callback = callback; 930 connect_state->opaque = opaque; 931 qemu_set_nonblock(sock); 932 } 933 934 memset(&un, 0, sizeof(un)); 935 un.sun_family = AF_UNIX; 936 snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path); 937 938 /* connect to peer */ 939 do { 940 rc = 0; 941 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { 942 rc = -errno; 943 } 944 } while (rc == -EINTR); 945 946 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 947 connect_state->fd = sock; 948 qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state); 949 return sock; 950 } else if (rc >= 0) { 951 /* non blocking socket immediate success, call callback */ 952 if (callback != NULL) { 953 callback(sock, NULL, opaque); 954 } 955 } 956 957 if (rc < 0) { 958 error_setg_errno(errp, -rc, "Failed to connect socket"); 959 close(sock); 960 sock = -1; 961 } 962 963 g_free(connect_state); 964 return sock; 965 } 966 967 #else 968 969 static int unix_listen_saddr(UnixSocketAddress *saddr, 970 bool update_addr, 971 Error **errp) 972 { 973 error_setg(errp, "unix sockets are not available on windows"); 974 errno = ENOTSUP; 975 return -1; 976 } 977 978 static int unix_connect_saddr(UnixSocketAddress *saddr, 979 NonBlockingConnectHandler *callback, void *opaque, 980 Error **errp) 981 { 982 error_setg(errp, "unix sockets are not available on windows"); 983 errno = ENOTSUP; 984 return -1; 985 } 986 #endif 987 988 /* compatibility wrapper */ 989 int unix_listen(const char *str, char *ostr, int olen, Error **errp) 990 { 991 char *path, *optstr; 992 int sock, len; 993 UnixSocketAddress *saddr; 994 995 saddr = g_new0(UnixSocketAddress, 1); 996 997 optstr = strchr(str, ','); 998 if (optstr) { 999 len = optstr - str; 1000 if (len) { 1001 path = g_malloc(len+1); 1002 snprintf(path, len+1, "%.*s", len, str); 1003 saddr->path = path; 1004 } 1005 } else { 1006 saddr->path = g_strdup(str); 1007 } 1008 1009 sock = unix_listen_saddr(saddr, true, errp); 1010 1011 if (sock != -1 && ostr) { 1012 snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : ""); 1013 } 1014 1015 qapi_free_UnixSocketAddress(saddr); 1016 return sock; 1017 } 1018 1019 int unix_connect(const char *path, Error **errp) 1020 { 1021 UnixSocketAddress *saddr; 1022 int sock; 1023 1024 saddr = g_new0(UnixSocketAddress, 1); 1025 saddr->path = g_strdup(path); 1026 sock = unix_connect_saddr(saddr, NULL, NULL, errp); 1027 qapi_free_UnixSocketAddress(saddr); 1028 return sock; 1029 } 1030 1031 1032 SocketAddressLegacy *socket_parse(const char *str, Error **errp) 1033 { 1034 SocketAddressLegacy *addr; 1035 1036 addr = g_new0(SocketAddressLegacy, 1); 1037 if (strstart(str, "unix:", NULL)) { 1038 if (str[5] == '\0') { 1039 error_setg(errp, "invalid Unix socket address"); 1040 goto fail; 1041 } else { 1042 addr->type = SOCKET_ADDRESS_LEGACY_KIND_UNIX; 1043 addr->u.q_unix.data = g_new(UnixSocketAddress, 1); 1044 addr->u.q_unix.data->path = g_strdup(str + 5); 1045 } 1046 } else if (strstart(str, "fd:", NULL)) { 1047 if (str[3] == '\0') { 1048 error_setg(errp, "invalid file descriptor address"); 1049 goto fail; 1050 } else { 1051 addr->type = SOCKET_ADDRESS_LEGACY_KIND_FD; 1052 addr->u.fd.data = g_new(String, 1); 1053 addr->u.fd.data->str = g_strdup(str + 3); 1054 } 1055 } else if (strstart(str, "vsock:", NULL)) { 1056 addr->type = SOCKET_ADDRESS_LEGACY_KIND_VSOCK; 1057 addr->u.vsock.data = g_new(VsockSocketAddress, 1); 1058 if (vsock_parse(addr->u.vsock.data, str + strlen("vsock:"), errp)) { 1059 goto fail; 1060 } 1061 } else { 1062 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET; 1063 addr->u.inet.data = g_new(InetSocketAddress, 1); 1064 if (inet_parse(addr->u.inet.data, str, errp)) { 1065 goto fail; 1066 } 1067 } 1068 return addr; 1069 1070 fail: 1071 qapi_free_SocketAddressLegacy(addr); 1072 return NULL; 1073 } 1074 1075 int socket_connect(SocketAddressLegacy *addr, NonBlockingConnectHandler *callback, 1076 void *opaque, Error **errp) 1077 { 1078 int fd; 1079 1080 switch (addr->type) { 1081 case SOCKET_ADDRESS_LEGACY_KIND_INET: 1082 fd = inet_connect_saddr(addr->u.inet.data, callback, opaque, errp); 1083 break; 1084 1085 case SOCKET_ADDRESS_LEGACY_KIND_UNIX: 1086 fd = unix_connect_saddr(addr->u.q_unix.data, callback, opaque, errp); 1087 break; 1088 1089 case SOCKET_ADDRESS_LEGACY_KIND_FD: 1090 fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp); 1091 if (fd >= 0 && callback) { 1092 qemu_set_nonblock(fd); 1093 callback(fd, NULL, opaque); 1094 } 1095 break; 1096 1097 case SOCKET_ADDRESS_LEGACY_KIND_VSOCK: 1098 fd = vsock_connect_saddr(addr->u.vsock.data, callback, opaque, errp); 1099 break; 1100 1101 default: 1102 abort(); 1103 } 1104 return fd; 1105 } 1106 1107 int socket_listen(SocketAddressLegacy *addr, Error **errp) 1108 { 1109 int fd; 1110 1111 switch (addr->type) { 1112 case SOCKET_ADDRESS_LEGACY_KIND_INET: 1113 fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp); 1114 break; 1115 1116 case SOCKET_ADDRESS_LEGACY_KIND_UNIX: 1117 fd = unix_listen_saddr(addr->u.q_unix.data, false, errp); 1118 break; 1119 1120 case SOCKET_ADDRESS_LEGACY_KIND_FD: 1121 fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp); 1122 break; 1123 1124 case SOCKET_ADDRESS_LEGACY_KIND_VSOCK: 1125 fd = vsock_listen_saddr(addr->u.vsock.data, errp); 1126 break; 1127 1128 default: 1129 abort(); 1130 } 1131 return fd; 1132 } 1133 1134 void socket_listen_cleanup(int fd, Error **errp) 1135 { 1136 SocketAddressLegacy *addr; 1137 1138 addr = socket_local_address(fd, errp); 1139 1140 if (addr->type == SOCKET_ADDRESS_LEGACY_KIND_UNIX 1141 && addr->u.q_unix.data->path) { 1142 if (unlink(addr->u.q_unix.data->path) < 0 && errno != ENOENT) { 1143 error_setg_errno(errp, errno, 1144 "Failed to unlink socket %s", 1145 addr->u.q_unix.data->path); 1146 } 1147 } 1148 1149 qapi_free_SocketAddressLegacy(addr); 1150 } 1151 1152 int socket_dgram(SocketAddressLegacy *remote, SocketAddressLegacy *local, Error **errp) 1153 { 1154 int fd; 1155 1156 /* 1157 * TODO SOCKET_ADDRESS_LEGACY_KIND_FD when fd is AF_INET or AF_INET6 1158 * (although other address families can do SOCK_DGRAM, too) 1159 */ 1160 switch (remote->type) { 1161 case SOCKET_ADDRESS_LEGACY_KIND_INET: 1162 fd = inet_dgram_saddr(remote->u.inet.data, 1163 local ? local->u.inet.data : NULL, errp); 1164 break; 1165 1166 default: 1167 error_setg(errp, "socket type unsupported for datagram"); 1168 fd = -1; 1169 } 1170 return fd; 1171 } 1172 1173 1174 static SocketAddressLegacy * 1175 socket_sockaddr_to_address_inet(struct sockaddr_storage *sa, 1176 socklen_t salen, 1177 Error **errp) 1178 { 1179 char host[NI_MAXHOST]; 1180 char serv[NI_MAXSERV]; 1181 SocketAddressLegacy *addr; 1182 InetSocketAddress *inet; 1183 int ret; 1184 1185 ret = getnameinfo((struct sockaddr *)sa, salen, 1186 host, sizeof(host), 1187 serv, sizeof(serv), 1188 NI_NUMERICHOST | NI_NUMERICSERV); 1189 if (ret != 0) { 1190 error_setg(errp, "Cannot format numeric socket address: %s", 1191 gai_strerror(ret)); 1192 return NULL; 1193 } 1194 1195 addr = g_new0(SocketAddressLegacy, 1); 1196 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET; 1197 inet = addr->u.inet.data = g_new0(InetSocketAddress, 1); 1198 inet->host = g_strdup(host); 1199 inet->port = g_strdup(serv); 1200 if (sa->ss_family == AF_INET) { 1201 inet->has_ipv4 = inet->ipv4 = true; 1202 } else { 1203 inet->has_ipv6 = inet->ipv6 = true; 1204 } 1205 1206 return addr; 1207 } 1208 1209 1210 #ifndef WIN32 1211 static SocketAddressLegacy * 1212 socket_sockaddr_to_address_unix(struct sockaddr_storage *sa, 1213 socklen_t salen, 1214 Error **errp) 1215 { 1216 SocketAddressLegacy *addr; 1217 struct sockaddr_un *su = (struct sockaddr_un *)sa; 1218 1219 addr = g_new0(SocketAddressLegacy, 1); 1220 addr->type = SOCKET_ADDRESS_LEGACY_KIND_UNIX; 1221 addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); 1222 if (su->sun_path[0]) { 1223 addr->u.q_unix.data->path = g_strndup(su->sun_path, 1224 sizeof(su->sun_path)); 1225 } 1226 1227 return addr; 1228 } 1229 #endif /* WIN32 */ 1230 1231 #ifdef CONFIG_AF_VSOCK 1232 static SocketAddressLegacy * 1233 socket_sockaddr_to_address_vsock(struct sockaddr_storage *sa, 1234 socklen_t salen, 1235 Error **errp) 1236 { 1237 SocketAddressLegacy *addr; 1238 VsockSocketAddress *vaddr; 1239 struct sockaddr_vm *svm = (struct sockaddr_vm *)sa; 1240 1241 addr = g_new0(SocketAddressLegacy, 1); 1242 addr->type = SOCKET_ADDRESS_LEGACY_KIND_VSOCK; 1243 addr->u.vsock.data = vaddr = g_new0(VsockSocketAddress, 1); 1244 vaddr->cid = g_strdup_printf("%u", svm->svm_cid); 1245 vaddr->port = g_strdup_printf("%u", svm->svm_port); 1246 1247 return addr; 1248 } 1249 #endif /* CONFIG_AF_VSOCK */ 1250 1251 SocketAddressLegacy * 1252 socket_sockaddr_to_address(struct sockaddr_storage *sa, 1253 socklen_t salen, 1254 Error **errp) 1255 { 1256 switch (sa->ss_family) { 1257 case AF_INET: 1258 case AF_INET6: 1259 return socket_sockaddr_to_address_inet(sa, salen, errp); 1260 1261 #ifndef WIN32 1262 case AF_UNIX: 1263 return socket_sockaddr_to_address_unix(sa, salen, errp); 1264 #endif /* WIN32 */ 1265 1266 #ifdef CONFIG_AF_VSOCK 1267 case AF_VSOCK: 1268 return socket_sockaddr_to_address_vsock(sa, salen, errp); 1269 #endif 1270 1271 default: 1272 error_setg(errp, "socket family %d unsupported", 1273 sa->ss_family); 1274 return NULL; 1275 } 1276 return 0; 1277 } 1278 1279 1280 SocketAddressLegacy *socket_local_address(int fd, Error **errp) 1281 { 1282 struct sockaddr_storage ss; 1283 socklen_t sslen = sizeof(ss); 1284 1285 if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1286 error_setg_errno(errp, errno, "%s", 1287 "Unable to query local socket address"); 1288 return NULL; 1289 } 1290 1291 return socket_sockaddr_to_address(&ss, sslen, errp); 1292 } 1293 1294 1295 SocketAddressLegacy *socket_remote_address(int fd, Error **errp) 1296 { 1297 struct sockaddr_storage ss; 1298 socklen_t sslen = sizeof(ss); 1299 1300 if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) { 1301 error_setg_errno(errp, errno, "%s", 1302 "Unable to query remote socket address"); 1303 return NULL; 1304 } 1305 1306 return socket_sockaddr_to_address(&ss, sslen, errp); 1307 } 1308 1309 char *socket_address_to_string(struct SocketAddressLegacy *addr, Error **errp) 1310 { 1311 char *buf; 1312 InetSocketAddress *inet; 1313 1314 switch (addr->type) { 1315 case SOCKET_ADDRESS_LEGACY_KIND_INET: 1316 inet = addr->u.inet.data; 1317 if (strchr(inet->host, ':') == NULL) { 1318 buf = g_strdup_printf("%s:%s", inet->host, inet->port); 1319 } else { 1320 buf = g_strdup_printf("[%s]:%s", inet->host, inet->port); 1321 } 1322 break; 1323 1324 case SOCKET_ADDRESS_LEGACY_KIND_UNIX: 1325 buf = g_strdup(addr->u.q_unix.data->path); 1326 break; 1327 1328 case SOCKET_ADDRESS_LEGACY_KIND_FD: 1329 buf = g_strdup(addr->u.fd.data->str); 1330 break; 1331 1332 case SOCKET_ADDRESS_LEGACY_KIND_VSOCK: 1333 buf = g_strdup_printf("%s:%s", 1334 addr->u.vsock.data->cid, 1335 addr->u.vsock.data->port); 1336 break; 1337 1338 default: 1339 abort(); 1340 } 1341 return buf; 1342 } 1343 1344 SocketAddressLegacy *socket_address_crumple(SocketAddress *addr_flat) 1345 { 1346 SocketAddressLegacy *addr = g_new(SocketAddressLegacy, 1); 1347 1348 switch (addr_flat->type) { 1349 case SOCKET_ADDRESS_TYPE_INET: 1350 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET; 1351 addr->u.inet.data = QAPI_CLONE(InetSocketAddress, 1352 &addr_flat->u.inet); 1353 break; 1354 case SOCKET_ADDRESS_TYPE_UNIX: 1355 addr->type = SOCKET_ADDRESS_LEGACY_KIND_UNIX; 1356 addr->u.q_unix.data = QAPI_CLONE(UnixSocketAddress, 1357 &addr_flat->u.q_unix); 1358 break; 1359 case SOCKET_ADDRESS_TYPE_VSOCK: 1360 addr->type = SOCKET_ADDRESS_LEGACY_KIND_VSOCK; 1361 addr->u.vsock.data = QAPI_CLONE(VsockSocketAddress, 1362 &addr_flat->u.vsock); 1363 break; 1364 case SOCKET_ADDRESS_TYPE_FD: 1365 addr->type = SOCKET_ADDRESS_LEGACY_KIND_FD; 1366 addr->u.fd.data = QAPI_CLONE(String, &addr_flat->u.fd); 1367 break; 1368 default: 1369 abort(); 1370 } 1371 1372 return addr; 1373 } 1374