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 <stdio.h> 19 #include <stdlib.h> 20 #include <string.h> 21 #include <ctype.h> 22 #include <errno.h> 23 #include <unistd.h> 24 25 #include "monitor/monitor.h" 26 #include "qemu/sockets.h" 27 #include "qemu/main-loop.h" 28 29 #ifndef AI_ADDRCONFIG 30 # define AI_ADDRCONFIG 0 31 #endif 32 33 /* used temporarily until all users are converted to QemuOpts */ 34 QemuOptsList socket_optslist = { 35 .name = "socket", 36 .head = QTAILQ_HEAD_INITIALIZER(socket_optslist.head), 37 .desc = { 38 { 39 .name = "path", 40 .type = QEMU_OPT_STRING, 41 },{ 42 .name = "host", 43 .type = QEMU_OPT_STRING, 44 },{ 45 .name = "port", 46 .type = QEMU_OPT_STRING, 47 },{ 48 .name = "localaddr", 49 .type = QEMU_OPT_STRING, 50 },{ 51 .name = "localport", 52 .type = QEMU_OPT_STRING, 53 },{ 54 .name = "to", 55 .type = QEMU_OPT_NUMBER, 56 },{ 57 .name = "ipv4", 58 .type = QEMU_OPT_BOOL, 59 },{ 60 .name = "ipv6", 61 .type = QEMU_OPT_BOOL, 62 }, 63 { /* end if list */ } 64 }, 65 }; 66 67 static int inet_getport(struct addrinfo *e) 68 { 69 struct sockaddr_in *i4; 70 struct sockaddr_in6 *i6; 71 72 switch (e->ai_family) { 73 case PF_INET6: 74 i6 = (void*)e->ai_addr; 75 return ntohs(i6->sin6_port); 76 case PF_INET: 77 i4 = (void*)e->ai_addr; 78 return ntohs(i4->sin_port); 79 default: 80 return 0; 81 } 82 } 83 84 static void inet_setport(struct addrinfo *e, int port) 85 { 86 struct sockaddr_in *i4; 87 struct sockaddr_in6 *i6; 88 89 switch (e->ai_family) { 90 case PF_INET6: 91 i6 = (void*)e->ai_addr; 92 i6->sin6_port = htons(port); 93 break; 94 case PF_INET: 95 i4 = (void*)e->ai_addr; 96 i4->sin_port = htons(port); 97 break; 98 } 99 } 100 101 NetworkAddressFamily inet_netfamily(int family) 102 { 103 switch (family) { 104 case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6; 105 case PF_INET: return NETWORK_ADDRESS_FAMILY_IPV4; 106 case PF_UNIX: return NETWORK_ADDRESS_FAMILY_UNIX; 107 } 108 return NETWORK_ADDRESS_FAMILY_UNKNOWN; 109 } 110 111 int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp) 112 { 113 struct addrinfo ai,*res,*e; 114 const char *addr; 115 char port[33]; 116 char uaddr[INET6_ADDRSTRLEN+1]; 117 char uport[33]; 118 int slisten, rc, to, port_min, port_max, p; 119 120 memset(&ai,0, sizeof(ai)); 121 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; 122 ai.ai_family = PF_UNSPEC; 123 ai.ai_socktype = SOCK_STREAM; 124 125 if ((qemu_opt_get(opts, "host") == NULL) || 126 (qemu_opt_get(opts, "port") == NULL)) { 127 error_setg(errp, "host and/or port not specified"); 128 return -1; 129 } 130 pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port")); 131 addr = qemu_opt_get(opts, "host"); 132 133 to = qemu_opt_get_number(opts, "to", 0); 134 if (qemu_opt_get_bool(opts, "ipv4", 0)) 135 ai.ai_family = PF_INET; 136 if (qemu_opt_get_bool(opts, "ipv6", 0)) 137 ai.ai_family = PF_INET6; 138 139 /* lookup */ 140 if (port_offset) { 141 unsigned long long baseport; 142 if (parse_uint_full(port, &baseport, 10) < 0) { 143 error_setg(errp, "can't convert to a number: %s", port); 144 return -1; 145 } 146 if (baseport > 65535 || 147 baseport + port_offset > 65535) { 148 error_setg(errp, "port %s out of range", port); 149 return -1; 150 } 151 snprintf(port, sizeof(port), "%d", (int)baseport + port_offset); 152 } 153 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res); 154 if (rc != 0) { 155 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 156 gai_strerror(rc)); 157 return -1; 158 } 159 160 /* create socket + bind */ 161 for (e = res; e != NULL; e = e->ai_next) { 162 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 163 uaddr,INET6_ADDRSTRLEN,uport,32, 164 NI_NUMERICHOST | NI_NUMERICSERV); 165 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol); 166 if (slisten < 0) { 167 if (!e->ai_next) { 168 error_setg_errno(errp, errno, "Failed to create socket"); 169 } 170 continue; 171 } 172 173 socket_set_fast_reuse(slisten); 174 #ifdef IPV6_V6ONLY 175 if (e->ai_family == PF_INET6) { 176 /* listen on both ipv4 and ipv6 */ 177 const int off = 0; 178 qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off, 179 sizeof(off)); 180 } 181 #endif 182 183 port_min = inet_getport(e); 184 port_max = to ? to + port_offset : port_min; 185 for (p = port_min; p <= port_max; p++) { 186 inet_setport(e, p); 187 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) { 188 goto listen; 189 } 190 if (p == port_max) { 191 if (!e->ai_next) { 192 error_setg_errno(errp, errno, "Failed to bind socket"); 193 } 194 } 195 } 196 closesocket(slisten); 197 } 198 freeaddrinfo(res); 199 return -1; 200 201 listen: 202 if (listen(slisten,1) != 0) { 203 error_setg_errno(errp, errno, "Failed to listen on socket"); 204 closesocket(slisten); 205 freeaddrinfo(res); 206 return -1; 207 } 208 qemu_opt_set(opts, "host", uaddr, &error_abort); 209 qemu_opt_set_number(opts, "port", inet_getport(e) - port_offset, 210 &error_abort); 211 qemu_opt_set_bool(opts, "ipv6", e->ai_family == PF_INET6, 212 &error_abort); 213 qemu_opt_set_bool(opts, "ipv4", e->ai_family != PF_INET6, 214 &error_abort); 215 freeaddrinfo(res); 216 return slisten; 217 } 218 219 #ifdef _WIN32 220 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 221 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY) 222 #else 223 #define QEMU_SOCKET_RC_INPROGRESS(rc) \ 224 ((rc) == -EINPROGRESS) 225 #endif 226 227 /* Struct to store connect state for non blocking connect */ 228 typedef struct ConnectState { 229 int fd; 230 struct addrinfo *addr_list; 231 struct addrinfo *current_addr; 232 NonBlockingConnectHandler *callback; 233 void *opaque; 234 } ConnectState; 235 236 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress, 237 ConnectState *connect_state, Error **errp); 238 239 static void wait_for_connect(void *opaque) 240 { 241 ConnectState *s = opaque; 242 int val = 0, rc = 0; 243 socklen_t valsize = sizeof(val); 244 bool in_progress; 245 Error *err = NULL; 246 247 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL); 248 249 do { 250 rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize); 251 } while (rc == -1 && socket_error() == EINTR); 252 253 /* update rc to contain error */ 254 if (!rc && val) { 255 rc = -1; 256 errno = val; 257 } 258 259 /* connect error */ 260 if (rc < 0) { 261 error_setg_errno(&err, errno, "Error connecting to socket"); 262 closesocket(s->fd); 263 s->fd = rc; 264 } 265 266 /* try to connect to the next address on the list */ 267 if (s->current_addr) { 268 while (s->current_addr->ai_next != NULL && s->fd < 0) { 269 s->current_addr = s->current_addr->ai_next; 270 s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL); 271 if (s->fd < 0) { 272 error_free(err); 273 err = NULL; 274 error_setg_errno(&err, errno, "Unable to start socket connect"); 275 } 276 /* connect in progress */ 277 if (in_progress) { 278 goto out; 279 } 280 } 281 282 freeaddrinfo(s->addr_list); 283 } 284 285 if (s->callback) { 286 s->callback(s->fd, err, s->opaque); 287 } 288 g_free(s); 289 out: 290 error_free(err); 291 } 292 293 static int inet_connect_addr(struct addrinfo *addr, bool *in_progress, 294 ConnectState *connect_state, Error **errp) 295 { 296 int sock, rc; 297 298 *in_progress = false; 299 300 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 301 if (sock < 0) { 302 error_setg_errno(errp, errno, "Failed to create socket"); 303 return -1; 304 } 305 socket_set_fast_reuse(sock); 306 if (connect_state != NULL) { 307 qemu_set_nonblock(sock); 308 } 309 /* connect to peer */ 310 do { 311 rc = 0; 312 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) { 313 rc = -socket_error(); 314 } 315 } while (rc == -EINTR); 316 317 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 318 connect_state->fd = sock; 319 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect, 320 connect_state); 321 *in_progress = true; 322 } else if (rc < 0) { 323 error_setg_errno(errp, errno, "Failed to connect socket"); 324 closesocket(sock); 325 return -1; 326 } 327 return sock; 328 } 329 330 static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp) 331 { 332 struct addrinfo ai, *res; 333 int rc; 334 const char *addr; 335 const char *port; 336 337 memset(&ai, 0, sizeof(ai)); 338 339 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 340 ai.ai_family = PF_UNSPEC; 341 ai.ai_socktype = SOCK_STREAM; 342 343 addr = qemu_opt_get(opts, "host"); 344 port = qemu_opt_get(opts, "port"); 345 if (addr == NULL || port == NULL) { 346 error_setg(errp, "host and/or port not specified"); 347 return NULL; 348 } 349 350 if (qemu_opt_get_bool(opts, "ipv4", 0)) { 351 ai.ai_family = PF_INET; 352 } 353 if (qemu_opt_get_bool(opts, "ipv6", 0)) { 354 ai.ai_family = PF_INET6; 355 } 356 357 /* lookup */ 358 rc = getaddrinfo(addr, port, &ai, &res); 359 if (rc != 0) { 360 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 361 gai_strerror(rc)); 362 return NULL; 363 } 364 return res; 365 } 366 367 /** 368 * Create a socket and connect it to an address. 369 * 370 * @opts: QEMU options, recognized parameters strings "host" and "port", 371 * bools "ipv4" and "ipv6". 372 * @errp: set on error 373 * @callback: callback function for non-blocking connect 374 * @opaque: opaque for callback function 375 * 376 * Returns: -1 on error, file descriptor on success. 377 * 378 * If @callback is non-null, the connect is non-blocking. If this 379 * function succeeds, callback will be called when the connection 380 * completes, with the file descriptor on success, or -1 on error. 381 */ 382 int inet_connect_opts(QemuOpts *opts, Error **errp, 383 NonBlockingConnectHandler *callback, void *opaque) 384 { 385 Error *local_err = NULL; 386 struct addrinfo *res, *e; 387 int sock = -1; 388 bool in_progress; 389 ConnectState *connect_state = NULL; 390 391 res = inet_parse_connect_opts(opts, errp); 392 if (!res) { 393 return -1; 394 } 395 396 if (callback != NULL) { 397 connect_state = g_malloc0(sizeof(*connect_state)); 398 connect_state->addr_list = res; 399 connect_state->callback = callback; 400 connect_state->opaque = opaque; 401 } 402 403 for (e = res; e != NULL; e = e->ai_next) { 404 error_free(local_err); 405 local_err = NULL; 406 if (connect_state != NULL) { 407 connect_state->current_addr = e; 408 } 409 sock = inet_connect_addr(e, &in_progress, connect_state, &local_err); 410 if (sock >= 0) { 411 break; 412 } 413 } 414 415 if (sock < 0) { 416 error_propagate(errp, local_err); 417 } else if (in_progress) { 418 /* wait_for_connect() will do the rest */ 419 return sock; 420 } else { 421 if (callback) { 422 callback(sock, NULL, opaque); 423 } 424 } 425 g_free(connect_state); 426 freeaddrinfo(res); 427 return sock; 428 } 429 430 int inet_dgram_opts(QemuOpts *opts, Error **errp) 431 { 432 struct addrinfo ai, *peer = NULL, *local = NULL; 433 const char *addr; 434 const char *port; 435 int sock = -1, rc; 436 437 /* lookup peer addr */ 438 memset(&ai,0, sizeof(ai)); 439 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 440 ai.ai_family = PF_UNSPEC; 441 ai.ai_socktype = SOCK_DGRAM; 442 443 addr = qemu_opt_get(opts, "host"); 444 port = qemu_opt_get(opts, "port"); 445 if (addr == NULL || strlen(addr) == 0) { 446 addr = "localhost"; 447 } 448 if (port == NULL || strlen(port) == 0) { 449 error_setg(errp, "remote port not specified"); 450 return -1; 451 } 452 453 if (qemu_opt_get_bool(opts, "ipv4", 0)) 454 ai.ai_family = PF_INET; 455 if (qemu_opt_get_bool(opts, "ipv6", 0)) 456 ai.ai_family = PF_INET6; 457 458 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) { 459 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 460 gai_strerror(rc)); 461 return -1; 462 } 463 464 /* lookup local addr */ 465 memset(&ai,0, sizeof(ai)); 466 ai.ai_flags = AI_PASSIVE; 467 ai.ai_family = peer->ai_family; 468 ai.ai_socktype = SOCK_DGRAM; 469 470 addr = qemu_opt_get(opts, "localaddr"); 471 port = qemu_opt_get(opts, "localport"); 472 if (addr == NULL || strlen(addr) == 0) { 473 addr = NULL; 474 } 475 if (!port || strlen(port) == 0) 476 port = "0"; 477 478 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) { 479 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, 480 gai_strerror(rc)); 481 goto err; 482 } 483 484 /* create socket */ 485 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol); 486 if (sock < 0) { 487 error_setg_errno(errp, errno, "Failed to create socket"); 488 goto err; 489 } 490 socket_set_fast_reuse(sock); 491 492 /* bind socket */ 493 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) { 494 error_setg_errno(errp, errno, "Failed to bind socket"); 495 goto err; 496 } 497 498 /* connect to peer */ 499 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) { 500 error_setg_errno(errp, errno, "Failed to connect socket"); 501 goto err; 502 } 503 504 freeaddrinfo(local); 505 freeaddrinfo(peer); 506 return sock; 507 508 err: 509 if (-1 != sock) 510 closesocket(sock); 511 if (local) 512 freeaddrinfo(local); 513 if (peer) 514 freeaddrinfo(peer); 515 return -1; 516 } 517 518 /* compatibility wrapper */ 519 InetSocketAddress *inet_parse(const char *str, Error **errp) 520 { 521 InetSocketAddress *addr; 522 const char *optstr, *h; 523 char host[65]; 524 char port[33]; 525 int to; 526 int pos; 527 528 addr = g_new0(InetSocketAddress, 1); 529 530 /* parse address */ 531 if (str[0] == ':') { 532 /* no host given */ 533 host[0] = '\0'; 534 if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) { 535 error_setg(errp, "error parsing port in address '%s'", str); 536 goto fail; 537 } 538 } else if (str[0] == '[') { 539 /* IPv6 addr */ 540 if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) { 541 error_setg(errp, "error parsing IPv6 address '%s'", str); 542 goto fail; 543 } 544 addr->ipv6 = addr->has_ipv6 = true; 545 } else { 546 /* hostname or IPv4 addr */ 547 if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) { 548 error_setg(errp, "error parsing address '%s'", str); 549 goto fail; 550 } 551 if (host[strspn(host, "0123456789.")] == '\0') { 552 addr->ipv4 = addr->has_ipv4 = true; 553 } 554 } 555 556 addr->host = g_strdup(host); 557 addr->port = g_strdup(port); 558 559 /* parse options */ 560 optstr = str + pos; 561 h = strstr(optstr, ",to="); 562 if (h) { 563 h += 4; 564 if (sscanf(h, "%d%n", &to, &pos) != 1 || 565 (h[pos] != '\0' && h[pos] != ',')) { 566 error_setg(errp, "error parsing to= argument"); 567 goto fail; 568 } 569 addr->has_to = true; 570 addr->to = to; 571 } 572 if (strstr(optstr, ",ipv4")) { 573 addr->ipv4 = addr->has_ipv4 = true; 574 } 575 if (strstr(optstr, ",ipv6")) { 576 addr->ipv6 = addr->has_ipv6 = true; 577 } 578 return addr; 579 580 fail: 581 qapi_free_InetSocketAddress(addr); 582 return NULL; 583 } 584 585 static void inet_addr_to_opts(QemuOpts *opts, const InetSocketAddress *addr) 586 { 587 bool ipv4 = addr->ipv4 || !addr->has_ipv4; 588 bool ipv6 = addr->ipv6 || !addr->has_ipv6; 589 590 if (!ipv4 || !ipv6) { 591 qemu_opt_set_bool(opts, "ipv4", ipv4, &error_abort); 592 qemu_opt_set_bool(opts, "ipv6", ipv6, &error_abort); 593 } 594 if (addr->has_to) { 595 qemu_opt_set_number(opts, "to", addr->to, &error_abort); 596 } 597 qemu_opt_set(opts, "host", addr->host, &error_abort); 598 qemu_opt_set(opts, "port", addr->port, &error_abort); 599 } 600 601 int inet_listen(const char *str, char *ostr, int olen, 602 int socktype, int port_offset, Error **errp) 603 { 604 QemuOpts *opts; 605 char *optstr; 606 int sock = -1; 607 InetSocketAddress *addr; 608 609 addr = inet_parse(str, errp); 610 if (addr != NULL) { 611 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 612 inet_addr_to_opts(opts, addr); 613 qapi_free_InetSocketAddress(addr); 614 sock = inet_listen_opts(opts, port_offset, errp); 615 if (sock != -1 && ostr) { 616 optstr = strchr(str, ','); 617 if (qemu_opt_get_bool(opts, "ipv6", 0)) { 618 snprintf(ostr, olen, "[%s]:%s%s", 619 qemu_opt_get(opts, "host"), 620 qemu_opt_get(opts, "port"), 621 optstr ? optstr : ""); 622 } else { 623 snprintf(ostr, olen, "%s:%s%s", 624 qemu_opt_get(opts, "host"), 625 qemu_opt_get(opts, "port"), 626 optstr ? optstr : ""); 627 } 628 } 629 qemu_opts_del(opts); 630 } 631 return sock; 632 } 633 634 /** 635 * Create a blocking socket and connect it to an address. 636 * 637 * @str: address string 638 * @errp: set in case of an error 639 * 640 * Returns -1 in case of error, file descriptor on success 641 **/ 642 int inet_connect(const char *str, Error **errp) 643 { 644 QemuOpts *opts; 645 int sock = -1; 646 InetSocketAddress *addr; 647 648 addr = inet_parse(str, errp); 649 if (addr != NULL) { 650 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 651 inet_addr_to_opts(opts, addr); 652 qapi_free_InetSocketAddress(addr); 653 sock = inet_connect_opts(opts, errp, NULL, NULL); 654 qemu_opts_del(opts); 655 } 656 return sock; 657 } 658 659 /** 660 * Create a non-blocking socket and connect it to an address. 661 * Calls the callback function with fd in case of success or -1 in case of 662 * error. 663 * 664 * @str: address string 665 * @callback: callback function that is called when connect completes, 666 * cannot be NULL. 667 * @opaque: opaque for callback function 668 * @errp: set in case of an error 669 * 670 * Returns: -1 on immediate error, file descriptor on success. 671 **/ 672 int inet_nonblocking_connect(const char *str, 673 NonBlockingConnectHandler *callback, 674 void *opaque, Error **errp) 675 { 676 QemuOpts *opts; 677 int sock = -1; 678 InetSocketAddress *addr; 679 680 g_assert(callback != NULL); 681 682 addr = inet_parse(str, errp); 683 if (addr != NULL) { 684 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 685 inet_addr_to_opts(opts, addr); 686 qapi_free_InetSocketAddress(addr); 687 sock = inet_connect_opts(opts, errp, callback, opaque); 688 qemu_opts_del(opts); 689 } 690 return sock; 691 } 692 693 #ifndef _WIN32 694 695 int unix_listen_opts(QemuOpts *opts, Error **errp) 696 { 697 struct sockaddr_un un; 698 const char *path = qemu_opt_get(opts, "path"); 699 int sock, fd; 700 701 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 702 if (sock < 0) { 703 error_setg_errno(errp, errno, "Failed to create Unix socket"); 704 return -1; 705 } 706 707 memset(&un, 0, sizeof(un)); 708 un.sun_family = AF_UNIX; 709 if (path && strlen(path)) { 710 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); 711 } else { 712 const char *tmpdir = getenv("TMPDIR"); 713 tmpdir = tmpdir ? tmpdir : "/tmp"; 714 if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX", 715 tmpdir) >= sizeof(un.sun_path)) { 716 error_setg_errno(errp, errno, 717 "TMPDIR environment variable (%s) too large", tmpdir); 718 goto err; 719 } 720 721 /* 722 * This dummy fd usage silences the mktemp() unsecure warning. 723 * Using mkstemp() doesn't make things more secure here 724 * though. bind() complains about existing files, so we have 725 * to unlink first and thus re-open the race window. The 726 * worst case possible is bind() failing, i.e. a DoS attack. 727 */ 728 fd = mkstemp(un.sun_path); 729 if (fd < 0) { 730 error_setg_errno(errp, errno, 731 "Failed to make a temporary socket name in %s", tmpdir); 732 goto err; 733 } 734 close(fd); 735 qemu_opt_set(opts, "path", un.sun_path, &error_abort); 736 } 737 738 if ((access(un.sun_path, F_OK) == 0) && 739 unlink(un.sun_path) < 0) { 740 error_setg_errno(errp, errno, 741 "Failed to unlink socket %s", un.sun_path); 742 goto err; 743 } 744 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 745 error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path); 746 goto err; 747 } 748 if (listen(sock, 1) < 0) { 749 error_setg_errno(errp, errno, "Failed to listen on socket"); 750 goto err; 751 } 752 753 return sock; 754 755 err: 756 closesocket(sock); 757 return -1; 758 } 759 760 int unix_connect_opts(QemuOpts *opts, Error **errp, 761 NonBlockingConnectHandler *callback, void *opaque) 762 { 763 struct sockaddr_un un; 764 const char *path = qemu_opt_get(opts, "path"); 765 ConnectState *connect_state = NULL; 766 int sock, rc; 767 768 if (path == NULL) { 769 error_setg(errp, "unix connect: no path specified"); 770 return -1; 771 } 772 773 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); 774 if (sock < 0) { 775 error_setg_errno(errp, errno, "Failed to create socket"); 776 return -1; 777 } 778 if (callback != NULL) { 779 connect_state = g_malloc0(sizeof(*connect_state)); 780 connect_state->callback = callback; 781 connect_state->opaque = opaque; 782 qemu_set_nonblock(sock); 783 } 784 785 memset(&un, 0, sizeof(un)); 786 un.sun_family = AF_UNIX; 787 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); 788 789 /* connect to peer */ 790 do { 791 rc = 0; 792 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { 793 rc = -socket_error(); 794 } 795 } while (rc == -EINTR); 796 797 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { 798 connect_state->fd = sock; 799 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect, 800 connect_state); 801 return sock; 802 } else if (rc >= 0) { 803 /* non blocking socket immediate success, call callback */ 804 if (callback != NULL) { 805 callback(sock, NULL, opaque); 806 } 807 } 808 809 if (rc < 0) { 810 error_setg_errno(errp, -rc, "Failed to connect socket"); 811 close(sock); 812 sock = -1; 813 } 814 815 g_free(connect_state); 816 return sock; 817 } 818 819 #else 820 821 int unix_listen_opts(QemuOpts *opts, Error **errp) 822 { 823 error_setg(errp, "unix sockets are not available on windows"); 824 errno = ENOTSUP; 825 return -1; 826 } 827 828 int unix_connect_opts(QemuOpts *opts, Error **errp, 829 NonBlockingConnectHandler *callback, void *opaque) 830 { 831 error_setg(errp, "unix sockets are not available on windows"); 832 errno = ENOTSUP; 833 return -1; 834 } 835 #endif 836 837 /* compatibility wrapper */ 838 int unix_listen(const char *str, char *ostr, int olen, Error **errp) 839 { 840 QemuOpts *opts; 841 char *path, *optstr; 842 int sock, len; 843 844 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 845 846 optstr = strchr(str, ','); 847 if (optstr) { 848 len = optstr - str; 849 if (len) { 850 path = g_malloc(len+1); 851 snprintf(path, len+1, "%.*s", len, str); 852 qemu_opt_set(opts, "path", path, &error_abort); 853 g_free(path); 854 } 855 } else { 856 qemu_opt_set(opts, "path", str, &error_abort); 857 } 858 859 sock = unix_listen_opts(opts, errp); 860 861 if (sock != -1 && ostr) 862 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : ""); 863 qemu_opts_del(opts); 864 return sock; 865 } 866 867 int unix_connect(const char *path, Error **errp) 868 { 869 QemuOpts *opts; 870 int sock; 871 872 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 873 qemu_opt_set(opts, "path", path, &error_abort); 874 sock = unix_connect_opts(opts, errp, NULL, NULL); 875 qemu_opts_del(opts); 876 return sock; 877 } 878 879 880 int unix_nonblocking_connect(const char *path, 881 NonBlockingConnectHandler *callback, 882 void *opaque, Error **errp) 883 { 884 QemuOpts *opts; 885 int sock = -1; 886 887 g_assert(callback != NULL); 888 889 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 890 qemu_opt_set(opts, "path", path, &error_abort); 891 sock = unix_connect_opts(opts, errp, callback, opaque); 892 qemu_opts_del(opts); 893 return sock; 894 } 895 896 SocketAddress *socket_parse(const char *str, Error **errp) 897 { 898 SocketAddress *addr; 899 900 addr = g_new0(SocketAddress, 1); 901 if (strstart(str, "unix:", NULL)) { 902 if (str[5] == '\0') { 903 error_setg(errp, "invalid Unix socket address"); 904 goto fail; 905 } else { 906 addr->kind = SOCKET_ADDRESS_KIND_UNIX; 907 addr->q_unix = g_new(UnixSocketAddress, 1); 908 addr->q_unix->path = g_strdup(str + 5); 909 } 910 } else if (strstart(str, "fd:", NULL)) { 911 if (str[3] == '\0') { 912 error_setg(errp, "invalid file descriptor address"); 913 goto fail; 914 } else { 915 addr->kind = SOCKET_ADDRESS_KIND_FD; 916 addr->fd = g_new(String, 1); 917 addr->fd->str = g_strdup(str + 3); 918 } 919 } else { 920 addr->kind = SOCKET_ADDRESS_KIND_INET; 921 addr->inet = inet_parse(str, errp); 922 if (addr->inet == NULL) { 923 goto fail; 924 } 925 } 926 return addr; 927 928 fail: 929 qapi_free_SocketAddress(addr); 930 return NULL; 931 } 932 933 int socket_connect(SocketAddress *addr, Error **errp, 934 NonBlockingConnectHandler *callback, void *opaque) 935 { 936 QemuOpts *opts; 937 int fd; 938 939 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 940 switch (addr->kind) { 941 case SOCKET_ADDRESS_KIND_INET: 942 inet_addr_to_opts(opts, addr->inet); 943 fd = inet_connect_opts(opts, errp, callback, opaque); 944 break; 945 946 case SOCKET_ADDRESS_KIND_UNIX: 947 qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort); 948 fd = unix_connect_opts(opts, errp, callback, opaque); 949 break; 950 951 case SOCKET_ADDRESS_KIND_FD: 952 fd = monitor_get_fd(cur_mon, addr->fd->str, errp); 953 if (fd >= 0 && callback) { 954 qemu_set_nonblock(fd); 955 callback(fd, NULL, opaque); 956 } 957 break; 958 959 default: 960 abort(); 961 } 962 qemu_opts_del(opts); 963 return fd; 964 } 965 966 int socket_listen(SocketAddress *addr, Error **errp) 967 { 968 QemuOpts *opts; 969 int fd; 970 971 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 972 switch (addr->kind) { 973 case SOCKET_ADDRESS_KIND_INET: 974 inet_addr_to_opts(opts, addr->inet); 975 fd = inet_listen_opts(opts, 0, errp); 976 break; 977 978 case SOCKET_ADDRESS_KIND_UNIX: 979 qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort); 980 fd = unix_listen_opts(opts, errp); 981 break; 982 983 case SOCKET_ADDRESS_KIND_FD: 984 fd = monitor_get_fd(cur_mon, addr->fd->str, errp); 985 break; 986 987 default: 988 abort(); 989 } 990 qemu_opts_del(opts); 991 return fd; 992 } 993 994 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp) 995 { 996 QemuOpts *opts; 997 int fd; 998 999 opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); 1000 switch (remote->kind) { 1001 case SOCKET_ADDRESS_KIND_INET: 1002 inet_addr_to_opts(opts, remote->inet); 1003 if (local) { 1004 qemu_opt_set(opts, "localaddr", local->inet->host, &error_abort); 1005 qemu_opt_set(opts, "localport", local->inet->port, &error_abort); 1006 } 1007 fd = inet_dgram_opts(opts, errp); 1008 break; 1009 1010 default: 1011 error_setg(errp, "socket type unsupported for datagram"); 1012 fd = -1; 1013 } 1014 qemu_opts_del(opts); 1015 return fd; 1016 } 1017