1 /* 2 * QEMU System Emulator 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu/osdep.h" 25 26 #include "net/net.h" 27 #include "clients.h" 28 #include "monitor/monitor.h" 29 #include "qapi/error.h" 30 #include "qemu/error-report.h" 31 #include "qemu/option.h" 32 #include "qemu/sockets.h" 33 #include "qemu/iov.h" 34 #include "qemu/main-loop.h" 35 36 typedef struct NetSocketState { 37 NetClientState nc; 38 int listen_fd; 39 int fd; 40 SocketReadState rs; 41 unsigned int send_index; /* number of bytes sent (only SOCK_STREAM) */ 42 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */ 43 IOHandler *send_fn; /* differs between SOCK_STREAM/SOCK_DGRAM */ 44 bool read_poll; /* waiting to receive data? */ 45 bool write_poll; /* waiting to transmit data? */ 46 } NetSocketState; 47 48 static void net_socket_accept(void *opaque); 49 static void net_socket_writable(void *opaque); 50 51 static void net_socket_update_fd_handler(NetSocketState *s) 52 { 53 qemu_set_fd_handler(s->fd, 54 s->read_poll ? s->send_fn : NULL, 55 s->write_poll ? net_socket_writable : NULL, 56 s); 57 } 58 59 static void net_socket_read_poll(NetSocketState *s, bool enable) 60 { 61 s->read_poll = enable; 62 net_socket_update_fd_handler(s); 63 } 64 65 static void net_socket_write_poll(NetSocketState *s, bool enable) 66 { 67 s->write_poll = enable; 68 net_socket_update_fd_handler(s); 69 } 70 71 static void net_socket_writable(void *opaque) 72 { 73 NetSocketState *s = opaque; 74 75 net_socket_write_poll(s, false); 76 77 qemu_flush_queued_packets(&s->nc); 78 } 79 80 static ssize_t net_socket_receive(NetClientState *nc, const uint8_t *buf, size_t size) 81 { 82 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc); 83 uint32_t len = htonl(size); 84 struct iovec iov[] = { 85 { 86 .iov_base = &len, 87 .iov_len = sizeof(len), 88 }, { 89 .iov_base = (void *)buf, 90 .iov_len = size, 91 }, 92 }; 93 size_t remaining; 94 ssize_t ret; 95 96 remaining = iov_size(iov, 2) - s->send_index; 97 ret = iov_send(s->fd, iov, 2, s->send_index, remaining); 98 99 if (ret == -1 && errno == EAGAIN) { 100 ret = 0; /* handled further down */ 101 } 102 if (ret == -1) { 103 s->send_index = 0; 104 return -errno; 105 } 106 if (ret < (ssize_t)remaining) { 107 s->send_index += ret; 108 net_socket_write_poll(s, true); 109 return 0; 110 } 111 s->send_index = 0; 112 return size; 113 } 114 115 static ssize_t net_socket_receive_dgram(NetClientState *nc, const uint8_t *buf, size_t size) 116 { 117 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc); 118 ssize_t ret; 119 120 ret = RETRY_ON_EINTR( 121 s->dgram_dst.sin_family != AF_UNIX ? 122 sendto(s->fd, buf, size, 0, 123 (struct sockaddr *)&s->dgram_dst, 124 sizeof(s->dgram_dst)) : 125 send(s->fd, buf, size, 0) 126 ); 127 128 if (ret == -1 && errno == EAGAIN) { 129 net_socket_write_poll(s, true); 130 return 0; 131 } 132 return ret; 133 } 134 135 static void net_socket_send_completed(NetClientState *nc, ssize_t len) 136 { 137 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc); 138 139 if (!s->read_poll) { 140 net_socket_read_poll(s, true); 141 } 142 } 143 144 static void net_socket_rs_finalize(SocketReadState *rs) 145 { 146 NetSocketState *s = container_of(rs, NetSocketState, rs); 147 148 if (qemu_send_packet_async(&s->nc, rs->buf, 149 rs->packet_len, 150 net_socket_send_completed) == 0) { 151 net_socket_read_poll(s, false); 152 } 153 } 154 155 static void net_socket_send(void *opaque) 156 { 157 NetSocketState *s = opaque; 158 int size; 159 int ret; 160 QEMU_UNINITIALIZED uint8_t buf1[NET_BUFSIZE]; 161 const uint8_t *buf; 162 163 size = recv(s->fd, buf1, sizeof(buf1), 0); 164 if (size < 0) { 165 if (errno != EWOULDBLOCK) 166 goto eoc; 167 } else if (size == 0) { 168 /* end of connection */ 169 eoc: 170 net_socket_read_poll(s, false); 171 net_socket_write_poll(s, false); 172 if (s->listen_fd != -1) { 173 qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s); 174 } 175 close(s->fd); 176 177 s->fd = -1; 178 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false); 179 s->nc.link_down = true; 180 qemu_set_info_str(&s->nc, "%s", ""); 181 182 return; 183 } 184 buf = buf1; 185 186 ret = net_fill_rstate(&s->rs, buf, size); 187 188 if (ret == -1) { 189 goto eoc; 190 } 191 } 192 193 static void net_socket_send_dgram(void *opaque) 194 { 195 NetSocketState *s = opaque; 196 int size; 197 198 size = recv(s->fd, s->rs.buf, sizeof(s->rs.buf), 0); 199 if (size < 0) 200 return; 201 if (size == 0) { 202 /* end of connection */ 203 net_socket_read_poll(s, false); 204 net_socket_write_poll(s, false); 205 return; 206 } 207 if (qemu_send_packet_async(&s->nc, s->rs.buf, size, 208 net_socket_send_completed) == 0) { 209 net_socket_read_poll(s, false); 210 } 211 } 212 213 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr, 214 struct in_addr *localaddr, 215 Error **errp) 216 { 217 struct ip_mreq imr; 218 int fd; 219 int val, ret; 220 #ifdef __OpenBSD__ 221 unsigned char loop; 222 #else 223 int loop; 224 #endif 225 226 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) { 227 error_setg(errp, "specified mcastaddr %s (0x%08x) " 228 "does not contain a multicast address", 229 inet_ntoa(mcastaddr->sin_addr), 230 (int)ntohl(mcastaddr->sin_addr.s_addr)); 231 return -1; 232 } 233 234 fd = qemu_socket(PF_INET, SOCK_DGRAM, 0); 235 if (fd < 0) { 236 error_setg_errno(errp, errno, "can't create datagram socket"); 237 return -1; 238 } 239 240 /* Allow multiple sockets to bind the same multicast ip and port by setting 241 * SO_REUSEADDR. This is the only situation where SO_REUSEADDR should be set 242 * on windows. Use socket_set_fast_reuse otherwise as it sets SO_REUSEADDR 243 * only on posix systems. 244 */ 245 val = 1; 246 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)); 247 if (ret < 0) { 248 error_setg_errno(errp, errno, 249 "can't set socket option SO_REUSEADDR"); 250 goto fail; 251 } 252 253 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr)); 254 if (ret < 0) { 255 error_setg_errno(errp, errno, "can't bind ip=%s to socket", 256 inet_ntoa(mcastaddr->sin_addr)); 257 goto fail; 258 } 259 260 /* Add host to multicast group */ 261 imr.imr_multiaddr = mcastaddr->sin_addr; 262 if (localaddr) { 263 imr.imr_interface = *localaddr; 264 } else { 265 imr.imr_interface.s_addr = htonl(INADDR_ANY); 266 } 267 268 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, 269 &imr, sizeof(struct ip_mreq)); 270 if (ret < 0) { 271 error_setg_errno(errp, errno, 272 "can't add socket to multicast group %s", 273 inet_ntoa(imr.imr_multiaddr)); 274 goto fail; 275 } 276 277 /* Force mcast msgs to loopback (eg. several QEMUs in same host */ 278 loop = 1; 279 ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, 280 &loop, sizeof(loop)); 281 if (ret < 0) { 282 error_setg_errno(errp, errno, 283 "can't force multicast message to loopback"); 284 goto fail; 285 } 286 287 /* If a bind address is given, only send packets from that address */ 288 if (localaddr != NULL) { 289 ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, 290 localaddr, sizeof(*localaddr)); 291 if (ret < 0) { 292 error_setg_errno(errp, errno, 293 "can't set the default network send interface"); 294 goto fail; 295 } 296 } 297 298 if (!qemu_set_blocking(fd, false, errp)) { 299 goto fail; 300 } 301 302 return fd; 303 fail: 304 if (fd >= 0) 305 close(fd); 306 return -1; 307 } 308 309 static void net_socket_cleanup(NetClientState *nc) 310 { 311 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc); 312 if (s->fd != -1) { 313 net_socket_read_poll(s, false); 314 net_socket_write_poll(s, false); 315 close(s->fd); 316 s->fd = -1; 317 } 318 if (s->listen_fd != -1) { 319 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL); 320 close(s->listen_fd); 321 s->listen_fd = -1; 322 } 323 } 324 325 static NetClientInfo net_dgram_socket_info = { 326 .type = NET_CLIENT_DRIVER_SOCKET, 327 .size = sizeof(NetSocketState), 328 .receive = net_socket_receive_dgram, 329 .cleanup = net_socket_cleanup, 330 }; 331 332 static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer, 333 const char *model, 334 const char *name, 335 int fd, int is_connected, 336 const char *mcast, 337 Error **errp) 338 { 339 struct sockaddr_in saddr; 340 int newfd; 341 NetClientState *nc; 342 NetSocketState *s; 343 SocketAddress *sa; 344 SocketAddressType sa_type; 345 346 sa = socket_local_address(fd, errp); 347 if (!sa) { 348 return NULL; 349 } 350 sa_type = sa->type; 351 qapi_free_SocketAddress(sa); 352 353 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it 354 * Because this may be "shared" socket from a "master" process, datagrams would be recv() 355 * by ONLY ONE process: we must "clone" this dgram socket --jjo 356 */ 357 358 if (is_connected && mcast != NULL) { 359 if (parse_host_port(&saddr, mcast, errp) < 0) { 360 goto err; 361 } 362 /* must be bound */ 363 if (saddr.sin_addr.s_addr == 0) { 364 error_setg(errp, "can't setup multicast destination address"); 365 goto err; 366 } 367 /* clone dgram socket */ 368 newfd = net_socket_mcast_create(&saddr, NULL, errp); 369 if (newfd < 0) { 370 goto err; 371 } 372 /* clone newfd to fd, close newfd */ 373 dup2(newfd, fd); 374 close(newfd); 375 376 } 377 378 nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name); 379 380 s = DO_UPCAST(NetSocketState, nc, nc); 381 382 s->fd = fd; 383 s->listen_fd = -1; 384 s->send_fn = net_socket_send_dgram; 385 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false); 386 net_socket_read_poll(s, true); 387 388 /* mcast: save bound address as dst */ 389 if (is_connected && mcast != NULL) { 390 s->dgram_dst = saddr; 391 qemu_set_info_str(nc, "socket: fd=%d (cloned mcast=%s:%d)", fd, 392 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)); 393 } else { 394 if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) { 395 s->dgram_dst.sin_family = AF_UNIX; 396 } 397 398 qemu_set_info_str(nc, "socket: fd=%d %s", fd, 399 SocketAddressType_str(sa_type)); 400 } 401 402 return s; 403 404 err: 405 close(fd); 406 return NULL; 407 } 408 409 static void net_socket_connect(void *opaque) 410 { 411 NetSocketState *s = opaque; 412 s->send_fn = net_socket_send; 413 net_socket_read_poll(s, true); 414 } 415 416 static NetClientInfo net_socket_info = { 417 .type = NET_CLIENT_DRIVER_SOCKET, 418 .size = sizeof(NetSocketState), 419 .receive = net_socket_receive, 420 .cleanup = net_socket_cleanup, 421 }; 422 423 static NetSocketState *net_socket_fd_init_stream(NetClientState *peer, 424 const char *model, 425 const char *name, 426 int fd, int is_connected) 427 { 428 NetClientState *nc; 429 NetSocketState *s; 430 431 nc = qemu_new_net_client(&net_socket_info, peer, model, name); 432 433 qemu_set_info_str(nc, "socket: fd=%d", fd); 434 435 s = DO_UPCAST(NetSocketState, nc, nc); 436 437 s->fd = fd; 438 s->listen_fd = -1; 439 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false); 440 441 /* Disable Nagle algorithm on TCP sockets to reduce latency */ 442 socket_set_nodelay(fd); 443 444 if (is_connected) { 445 net_socket_connect(s); 446 } else { 447 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s); 448 } 449 return s; 450 } 451 452 static int net_socket_fd_check(int fd, Error **errp) 453 { 454 int so_type, optlen = sizeof(so_type); 455 456 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, 457 (socklen_t *)&optlen) < 0) { 458 error_setg(errp, "can't get socket option SO_TYPE"); 459 return -1; 460 } 461 if (so_type != SOCK_DGRAM && so_type != SOCK_STREAM) { 462 error_setg(errp, "socket type=%d for fd=%d must be either" 463 " SOCK_DGRAM or SOCK_STREAM", so_type, fd); 464 return -1; 465 } 466 return so_type; 467 } 468 469 static void net_socket_accept(void *opaque) 470 { 471 NetSocketState *s = opaque; 472 struct sockaddr_in saddr; 473 socklen_t len; 474 int fd; 475 476 for(;;) { 477 len = sizeof(saddr); 478 fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len); 479 if (fd < 0 && errno != EINTR) { 480 return; 481 } else if (fd >= 0) { 482 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL); 483 break; 484 } 485 } 486 487 s->fd = fd; 488 s->nc.link_down = false; 489 net_socket_connect(s); 490 qemu_set_info_str(&s->nc, "socket: connection from %s:%d", 491 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)); 492 } 493 494 static int net_socket_listen_init(NetClientState *peer, 495 const char *model, 496 const char *name, 497 const char *host_str, 498 Error **errp) 499 { 500 NetClientState *nc; 501 NetSocketState *s; 502 struct sockaddr_in saddr; 503 int fd, ret; 504 505 if (parse_host_port(&saddr, host_str, errp) < 0) { 506 return -1; 507 } 508 509 fd = qemu_socket(PF_INET, SOCK_STREAM, 0); 510 if (fd < 0) { 511 error_setg_errno(errp, errno, "can't create stream socket"); 512 return -1; 513 } 514 if (!qemu_set_blocking(fd, false, errp)) { 515 close(fd); 516 return -1; 517 } 518 519 socket_set_fast_reuse(fd); 520 521 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)); 522 if (ret < 0) { 523 error_setg_errno(errp, errno, "can't bind ip=%s to socket", 524 inet_ntoa(saddr.sin_addr)); 525 close(fd); 526 return -1; 527 } 528 ret = listen(fd, 0); 529 if (ret < 0) { 530 error_setg_errno(errp, errno, "can't listen on socket"); 531 close(fd); 532 return -1; 533 } 534 535 nc = qemu_new_net_client(&net_socket_info, peer, model, name); 536 s = DO_UPCAST(NetSocketState, nc, nc); 537 s->fd = -1; 538 s->listen_fd = fd; 539 s->nc.link_down = true; 540 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false); 541 542 qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s); 543 return 0; 544 } 545 546 static int net_socket_connect_init(NetClientState *peer, 547 const char *model, 548 const char *name, 549 const char *host_str, 550 Error **errp) 551 { 552 NetSocketState *s; 553 int fd, connected, ret; 554 struct sockaddr_in saddr; 555 556 if (parse_host_port(&saddr, host_str, errp) < 0) { 557 return -1; 558 } 559 560 fd = qemu_socket(PF_INET, SOCK_STREAM, 0); 561 if (fd < 0) { 562 error_setg_errno(errp, errno, "can't create stream socket"); 563 return -1; 564 } 565 if (!qemu_set_blocking(fd, false, errp)) { 566 close(fd); 567 return -1; 568 } 569 570 connected = 0; 571 for(;;) { 572 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr)); 573 if (ret < 0) { 574 if (errno == EINTR || errno == EWOULDBLOCK) { 575 /* continue */ 576 } else if (errno == EINPROGRESS || 577 errno == EALREADY) { 578 break; 579 } else { 580 error_setg_errno(errp, errno, "can't connect socket"); 581 close(fd); 582 return -1; 583 } 584 } else { 585 connected = 1; 586 break; 587 } 588 } 589 s = net_socket_fd_init_stream(peer, model, name, fd, connected); 590 if (!s) { 591 return -1; 592 } 593 594 qemu_set_info_str(&s->nc, "socket: connect to %s:%d", 595 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)); 596 return 0; 597 } 598 599 static int net_socket_mcast_init(NetClientState *peer, 600 const char *model, 601 const char *name, 602 const char *host_str, 603 const char *localaddr_str, 604 Error **errp) 605 { 606 NetSocketState *s; 607 int fd; 608 struct sockaddr_in saddr; 609 struct in_addr localaddr, *param_localaddr; 610 611 if (parse_host_port(&saddr, host_str, errp) < 0) { 612 return -1; 613 } 614 615 if (localaddr_str != NULL) { 616 if (inet_aton(localaddr_str, &localaddr) == 0) { 617 error_setg(errp, "localaddr '%s' is not a valid IPv4 address", 618 localaddr_str); 619 return -1; 620 } 621 param_localaddr = &localaddr; 622 } else { 623 param_localaddr = NULL; 624 } 625 626 fd = net_socket_mcast_create(&saddr, param_localaddr, errp); 627 if (fd < 0) { 628 return -1; 629 } 630 631 s = net_socket_fd_init_dgram(peer, model, name, fd, 0, NULL, errp); 632 if (!s) { 633 return -1; 634 } 635 636 s->dgram_dst = saddr; 637 638 qemu_set_info_str(&s->nc, "socket: mcast=%s:%d", 639 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)); 640 return 0; 641 642 } 643 644 static int net_socket_udp_init(NetClientState *peer, 645 const char *model, 646 const char *name, 647 const char *rhost, 648 const char *lhost, 649 Error **errp) 650 { 651 NetSocketState *s; 652 int fd, ret; 653 struct sockaddr_in laddr, raddr; 654 655 if (parse_host_port(&laddr, lhost, errp) < 0) { 656 return -1; 657 } 658 659 if (parse_host_port(&raddr, rhost, errp) < 0) { 660 return -1; 661 } 662 663 fd = qemu_socket(PF_INET, SOCK_DGRAM, 0); 664 if (fd < 0) { 665 error_setg_errno(errp, errno, "can't create datagram socket"); 666 return -1; 667 } 668 669 ret = socket_set_fast_reuse(fd); 670 if (ret < 0) { 671 error_setg_errno(errp, errno, 672 "can't set socket option SO_REUSEADDR"); 673 close(fd); 674 return -1; 675 } 676 ret = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr)); 677 if (ret < 0) { 678 error_setg_errno(errp, errno, "can't bind ip=%s to socket", 679 inet_ntoa(laddr.sin_addr)); 680 close(fd); 681 return -1; 682 } 683 if (!qemu_set_blocking(fd, false, errp)) { 684 close(fd); 685 return -1; 686 } 687 688 s = net_socket_fd_init_dgram(peer, model, name, fd, 0, NULL, errp); 689 if (!s) { 690 return -1; 691 } 692 693 s->dgram_dst = raddr; 694 695 qemu_set_info_str(&s->nc, "socket: udp=%s:%d", inet_ntoa(raddr.sin_addr), 696 ntohs(raddr.sin_port)); 697 return 0; 698 } 699 700 int net_init_socket(const Netdev *netdev, const char *name, 701 NetClientState *peer, Error **errp) 702 { 703 const NetdevSocketOptions *sock; 704 705 assert(netdev->type == NET_CLIENT_DRIVER_SOCKET); 706 sock = &netdev->u.socket; 707 708 if (!!sock->fd + !!sock->listen + !!sock->connect + !!sock->mcast + 709 !!sock->udp != 1) { 710 error_setg(errp, "exactly one of listen=, connect=, mcast= or udp=" 711 " is required"); 712 return -1; 713 } 714 715 if (sock->localaddr && !sock->mcast && !sock->udp) { 716 error_setg(errp, "localaddr= is only valid with mcast= or udp="); 717 return -1; 718 } 719 720 if (sock->fd) { 721 int fd, so_type; 722 723 fd = monitor_fd_param(monitor_cur(), sock->fd, errp); 724 if (fd == -1) { 725 return -1; 726 } 727 so_type = net_socket_fd_check(fd, errp); 728 if (so_type < 0) { 729 return -1; 730 } 731 if (!qemu_set_blocking(fd, false, errp)) { 732 return -1; 733 } 734 switch (so_type) { 735 case SOCK_DGRAM: 736 if (!net_socket_fd_init_dgram(peer, "socket", name, fd, 1, 737 sock->mcast, errp)) { 738 return -1; 739 } 740 break; 741 case SOCK_STREAM: 742 if (!net_socket_fd_init_stream(peer, "socket", name, fd, 1)) { 743 return -1; 744 } 745 break; 746 } 747 return 0; 748 } 749 750 if (sock->listen) { 751 if (net_socket_listen_init(peer, "socket", name, sock->listen, errp) 752 < 0) { 753 return -1; 754 } 755 return 0; 756 } 757 758 if (sock->connect) { 759 if (net_socket_connect_init(peer, "socket", name, sock->connect, errp) 760 < 0) { 761 return -1; 762 } 763 return 0; 764 } 765 766 if (sock->mcast) { 767 /* if sock->localaddr is missing, it has been initialized to "all bits 768 * zero" */ 769 if (net_socket_mcast_init(peer, "socket", name, sock->mcast, 770 sock->localaddr, errp) < 0) { 771 return -1; 772 } 773 return 0; 774 } 775 776 assert(sock->udp); 777 if (!sock->localaddr) { 778 error_setg(errp, "localaddr= is mandatory with udp="); 779 return -1; 780 } 781 if (net_socket_udp_init(peer, "socket", name, sock->udp, sock->localaddr, 782 errp) < 0) { 783 return -1; 784 } 785 return 0; 786 } 787