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