net/socket.c

   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-common.h"
  31 #include "qemu/error-report.h"
  32 #include "qemu/option.h"
  33 #include "qemu/sockets.h"
  34 #include "qemu/iov.h"
  35 #include "qemu/main-loop.h"
  36
  37 typedef struct NetSocketState {
  38     NetClientState nc;
  39     int listen_fd;
  40     int fd;
  41     SocketReadState rs;
  42     unsigned int send_index;      /* number of bytes sent (only SOCK_STREAM) */
  43     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
  44     IOHandler *send_fn;           /* differs between SOCK_STREAM/SOCK_DGRAM */
  45     bool read_poll;               /* waiting to receive data? */
  46     bool write_poll;              /* waiting to transmit data? */
  47 } NetSocketState;
  48
  49 static void net_socket_accept(void *opaque);
  50 static void net_socket_writable(void *opaque);
  51
  52 static void net_socket_update_fd_handler(NetSocketState *s)
  53 {
  54     qemu_set_fd_handler(s->fd,
  55                         s->read_poll ? s->send_fn : NULL,
  56                         s->write_poll ? net_socket_writable : NULL,
  57                         s);
  58 }
  59
  60 static void net_socket_read_poll(NetSocketState *s, bool enable)
  61 {
  62     s->read_poll = enable;
  63     net_socket_update_fd_handler(s);
  64 }
  65
  66 static void net_socket_write_poll(NetSocketState *s, bool enable)
  67 {
  68     s->write_poll = enable;
  69     net_socket_update_fd_handler(s);
  70 }
  71
  72 static void net_socket_writable(void *opaque)
  73 {
  74     NetSocketState *s = opaque;
  75
  76     net_socket_write_poll(s, false);
  77
  78     qemu_flush_queued_packets(&s->nc);
  79 }
  80
  81 static ssize_t net_socket_receive(NetClientState *nc, const uint8_t *buf, size_t size)
  82 {
  83     NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
  84     uint32_t len = htonl(size);
  85     struct iovec iov[] = {
  86         {
  87             .iov_base = &len,
  88             .iov_len  = sizeof(len),
  89         }, {
  90             .iov_base = (void *)buf,
  91             .iov_len  = size,
  92         },
  93     };
  94     size_t remaining;
  95     ssize_t ret;
  96
  97     remaining = iov_size(iov, 2) - s->send_index;
  98     ret = iov_send(s->fd, iov, 2, s->send_index, remaining);
  99
 100     if (ret == -1 && errno == EAGAIN) {
 101         ret = 0; /* handled further down */
 102     }
 103     if (ret == -1) {
 104         s->send_index = 0;
 105         return -errno;
 106     }
 107     if (ret < (ssize_t)remaining) {
 108         s->send_index += ret;
 109         net_socket_write_poll(s, true);
 110         return 0;
 111     }
 112     s->send_index = 0;
 113     return size;
 114 }
 115
 116 static ssize_t net_socket_receive_dgram(NetClientState *nc, const uint8_t *buf, size_t size)
 117 {
 118     NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
 119     ssize_t ret;
 120
 121     do {
 122         if (s->dgram_dst.sin_family != AF_UNIX) {
 123             ret = qemu_sendto(s->fd, buf, size, 0,
 124                               (struct sockaddr *)&s->dgram_dst,
 125                               sizeof(s->dgram_dst));
 126         } else {
 127             ret = send(s->fd, buf, size, 0);
 128         }
 129     } while (ret == -1 && errno == EINTR);
 130
 131     if (ret == -1 && errno == EAGAIN) {
 132         net_socket_write_poll(s, true);
 133         return 0;
 134     }
 135     return ret;
 136 }
 137
 138 static void net_socket_send_completed(NetClientState *nc, ssize_t len)
 139 {
 140     NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
 141
 142     if (!s->read_poll) {
 143         net_socket_read_poll(s, true);
 144     }
 145 }
 146
 147 static void net_socket_rs_finalize(SocketReadState *rs)
 148 {
 149     NetSocketState *s = container_of(rs, NetSocketState, rs);
 150
 151     if (qemu_send_packet_async(&s->nc, rs->buf,
 152                                rs->packet_len,
 153                                net_socket_send_completed) == 0) {
 154         net_socket_read_poll(s, false);
 155     }
 156 }
 157
 158 static void net_socket_send(void *opaque)
 159 {
 160     NetSocketState *s = opaque;
 161     int size;
 162     int ret;
 163     uint8_t buf1[NET_BUFSIZE];
 164     const uint8_t *buf;
 165
 166     size = qemu_recv(s->fd, buf1, sizeof(buf1), 0);
 167     if (size < 0) {
 168         if (errno != EWOULDBLOCK)
 169             goto eoc;
 170     } else if (size == 0) {
 171         /* end of connection */
 172     eoc:
 173         net_socket_read_poll(s, false);
 174         net_socket_write_poll(s, false);
 175         if (s->listen_fd != -1) {
 176             qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
 177         }
 178         closesocket(s->fd);
 179
 180         s->fd = -1;
 181         net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
 182         s->nc.link_down = true;
 183         memset(s->nc.info_str, 0, sizeof(s->nc.info_str));
 184
 185         return;
 186     }
 187     buf = buf1;
 188
 189     ret = net_fill_rstate(&s->rs, buf, size);
 190
 191     if (ret == -1) {
 192         goto eoc;
 193     }
 194 }
 195
 196 static void net_socket_send_dgram(void *opaque)
 197 {
 198     NetSocketState *s = opaque;
 199     int size;
 200
 201     size = qemu_recv(s->fd, s->rs.buf, sizeof(s->rs.buf), 0);
 202     if (size < 0)
 203         return;
 204     if (size == 0) {
 205         /* end of connection */
 206         net_socket_read_poll(s, false);
 207         net_socket_write_poll(s, false);
 208         return;
 209     }
 210     if (qemu_send_packet_async(&s->nc, s->rs.buf, size,
 211                                net_socket_send_completed) == 0) {
 212         net_socket_read_poll(s, false);
 213     }
 214 }
 215
 216 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr,
 217                                    struct in_addr *localaddr,
 218                                    Error **errp)
 219 {
 220     struct ip_mreq imr;
 221     int fd;
 222     int val, ret;
 223 #ifdef __OpenBSD__
 224     unsigned char loop;
 225 #else
 226     int loop;
 227 #endif
 228
 229     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
 230         error_setg(errp, "specified mcastaddr %s (0x%08x) "
 231                    "does not contain a multicast address",
 232                    inet_ntoa(mcastaddr->sin_addr),
 233                    (int)ntohl(mcastaddr->sin_addr.s_addr));
 234         return -1;
 235     }
 236
 237     fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 238     if (fd < 0) {
 239         error_setg_errno(errp, errno, "can't create datagram socket");
 240         return -1;
 241     }
 242
 243     /* Allow multiple sockets to bind the same multicast ip and port by setting
 244      * SO_REUSEADDR. This is the only situation where SO_REUSEADDR should be set
 245      * on windows. Use socket_set_fast_reuse otherwise as it sets SO_REUSEADDR
 246      * only on posix systems.
 247      */
 248     val = 1;
 249     ret = qemu_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
 250     if (ret < 0) {
 251         error_setg_errno(errp, errno,
 252                          "can't set socket option SO_REUSEADDR");
 253         goto fail;
 254     }
 255
 256     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
 257     if (ret < 0) {
 258         error_setg_errno(errp, errno, "can't bind ip=%s to socket",
 259                          inet_ntoa(mcastaddr->sin_addr));
 260         goto fail;
 261     }
 262
 263     /* Add host to multicast group */
 264     imr.imr_multiaddr = mcastaddr->sin_addr;
 265     if (localaddr) {
 266         imr.imr_interface = *localaddr;
 267     } else {
 268         imr.imr_interface.s_addr = htonl(INADDR_ANY);
 269     }
 270
 271     ret = qemu_setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 272                           &imr, sizeof(struct ip_mreq));
 273     if (ret < 0) {
 274         error_setg_errno(errp, errno,
 275                          "can't add socket to multicast group %s",
 276                          inet_ntoa(imr.imr_multiaddr));
 277         goto fail;
 278     }
 279
 280     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
 281     loop = 1;
 282     ret = qemu_setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
 283                           &loop, sizeof(loop));
 284     if (ret < 0) {
 285         error_setg_errno(errp, errno,
 286                          "can't force multicast message to loopback");
 287         goto fail;
 288     }
 289
 290     /* If a bind address is given, only send packets from that address */
 291     if (localaddr != NULL) {
 292         ret = qemu_setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
 293                               localaddr, sizeof(*localaddr));
 294         if (ret < 0) {
 295             error_setg_errno(errp, errno,
 296                              "can't set the default network send interface");
 297             goto fail;
 298         }
 299     }
 300
 301     qemu_set_nonblock(fd);
 302     return fd;
 303 fail:
 304     if (fd >= 0)
 305         closesocket(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         closesocket(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     NetdevSocketOptions *stored;
 346
 347     sa = socket_local_address(fd, errp);
 348     if (!sa) {
 349         return NULL;
 350     }
 351     sa_type = sa->type;
 352     qapi_free_SocketAddress(sa);
 353
 354     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
 355      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
 356      * by ONLY ONE process: we must "clone" this dgram socket --jjo
 357      */
 358
 359     if (is_connected && mcast != NULL) {
 360             if (parse_host_port(&saddr, mcast, errp) < 0) {
 361                 goto err;
 362             }
 363             /* must be bound */
 364             if (saddr.sin_addr.s_addr == 0) {
 365                 error_setg(errp, "can't setup multicast destination address");
 366                 goto err;
 367             }
 368             /* clone dgram socket */
 369             newfd = net_socket_mcast_create(&saddr, NULL, errp);
 370             if (newfd < 0) {
 371                 goto err;
 372             }
 373             /* clone newfd to fd, close newfd */
 374             dup2(newfd, fd);
 375             close(newfd);
 376
 377     }
 378
 379     nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
 380
 381     s = DO_UPCAST(NetSocketState, nc, nc);
 382
 383     s->fd = fd;
 384     s->listen_fd = -1;
 385     s->send_fn = net_socket_send_dgram;
 386     net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
 387     net_socket_read_poll(s, true);
 388
 389     /* Store startup parameters */
 390     nc->stored_config = g_new0(NetdevInfo, 1);
 391     nc->stored_config->type = NET_BACKEND_SOCKET;
 392     stored = &nc->stored_config->u.socket;
 393
 394     stored->has_fd = true;
 395     stored->fd = g_strdup_printf("%d", fd);
 396
 397     /* mcast: save bound address as dst */
 398     if (is_connected && mcast != NULL) {
 399         stored->has_mcast = true;
 400         stored->mcast = g_strdup(mcast);
 401
 402         s->dgram_dst = saddr;
 403         snprintf(nc->info_str, sizeof(nc->info_str),
 404                  "socket: fd=%d (cloned mcast=%s:%d)",
 405                  fd, inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 406     } else {
 407         if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) {
 408             s->dgram_dst.sin_family = AF_UNIX;
 409         }
 410
 411         snprintf(nc->info_str, sizeof(nc->info_str),
 412                  "socket: fd=%d %s", fd, SocketAddressType_str(sa_type));
 413     }
 414
 415     return s;
 416
 417 err:
 418     closesocket(fd);
 419     return NULL;
 420 }
 421
 422 static void net_socket_connect(void *opaque)
 423 {
 424     NetSocketState *s = opaque;
 425     s->send_fn = net_socket_send;
 426     net_socket_read_poll(s, true);
 427 }
 428
 429 static NetClientInfo net_socket_info = {
 430     .type = NET_CLIENT_DRIVER_SOCKET,
 431     .size = sizeof(NetSocketState),
 432     .receive = net_socket_receive,
 433     .cleanup = net_socket_cleanup,
 434 };
 435
 436 static NetSocketState *net_socket_fd_init_stream(NetClientState *peer,
 437                                                  const char *model,
 438                                                  const char *name,
 439                                                  int fd, int is_connected)
 440 {
 441     NetClientState *nc;
 442     NetSocketState *s;
 443     NetdevSocketOptions *stored;
 444
 445     nc = qemu_new_net_client(&net_socket_info, peer, model, name);
 446
 447     snprintf(nc->info_str, sizeof(nc->info_str), "socket: fd=%d", fd);
 448
 449     s = DO_UPCAST(NetSocketState, nc, nc);
 450
 451     s->fd = fd;
 452     s->listen_fd = -1;
 453     net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
 454
 455     /* Disable Nagle algorithm on TCP sockets to reduce latency */
 456     socket_set_nodelay(fd);
 457
 458     if (is_connected) {
 459         net_socket_connect(s);
 460     } else {
 461         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
 462     }
 463
 464     /* Store startup parameters */
 465     nc->stored_config = g_new0(NetdevInfo, 1);
 466     nc->stored_config->type = NET_BACKEND_SOCKET;
 467     stored = &nc->stored_config->u.socket;
 468
 469     stored->has_fd = true;
 470     stored->fd = g_strdup_printf("%d", fd);
 471
 472     return s;
 473 }
 474
 475 static NetSocketState *net_socket_fd_init(NetClientState *peer,
 476                                           const char *model, const char *name,
 477                                           int fd, int is_connected,
 478                                           const char *mc, Error **errp)
 479 {
 480     int so_type = -1, optlen=sizeof(so_type);
 481
 482     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
 483         (socklen_t *)&optlen)< 0) {
 484         error_setg(errp, "can't get socket option SO_TYPE");
 485         closesocket(fd);
 486         return NULL;
 487     }
 488     switch(so_type) {
 489     case SOCK_DGRAM:
 490         return net_socket_fd_init_dgram(peer, model, name, fd, is_connected,
 491                                         mc, errp);
 492     case SOCK_STREAM:
 493         return net_socket_fd_init_stream(peer, model, name, fd, is_connected);
 494     default:
 495         error_setg(errp, "socket type=%d for fd=%d must be either"
 496                    " SOCK_DGRAM or SOCK_STREAM", so_type, fd);
 497         closesocket(fd);
 498     }
 499     return NULL;
 500 }
 501
 502 static void net_socket_accept(void *opaque)
 503 {
 504     NetSocketState *s = opaque;
 505     struct sockaddr_in saddr;
 506     socklen_t len;
 507     int fd;
 508     NetdevSocketOptions *stored;
 509
 510     for(;;) {
 511         len = sizeof(saddr);
 512         fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
 513         if (fd < 0 && errno != EINTR) {
 514             return;
 515         } else if (fd >= 0) {
 516             qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
 517             break;
 518         }
 519     }
 520
 521     s->fd = fd;
 522     s->nc.link_down = false;
 523     net_socket_connect(s);
 524
 525     /* Store additional startup parameters (extend net_socket_listen_init) */
 526     stored = &s->nc.stored_config->u.socket;
 527
 528     stored->has_fd = true;
 529     stored->fd = g_strdup_printf("%d", fd);
 530
 531     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 532              "socket: connection from %s:%d",
 533              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 534 }
 535
 536 static int net_socket_listen_init(NetClientState *peer,
 537                                   const char *model,
 538                                   const char *name,
 539                                   const char *host_str,
 540                                   Error **errp)
 541 {
 542     NetClientState *nc;
 543     NetSocketState *s;
 544     struct sockaddr_in saddr;
 545     int fd, ret;
 546     NetdevSocketOptions *stored;
 547
 548     if (parse_host_port(&saddr, host_str, errp) < 0) {
 549         return -1;
 550     }
 551
 552     fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
 553     if (fd < 0) {
 554         error_setg_errno(errp, errno, "can't create stream socket");
 555         return -1;
 556     }
 557     qemu_set_nonblock(fd);
 558
 559     socket_set_fast_reuse(fd);
 560
 561     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
 562     if (ret < 0) {
 563         error_setg_errno(errp, errno, "can't bind ip=%s to socket",
 564                          inet_ntoa(saddr.sin_addr));
 565         closesocket(fd);
 566         return -1;
 567     }
 568     ret = listen(fd, 0);
 569     if (ret < 0) {
 570         error_setg_errno(errp, errno, "can't listen on socket");
 571         closesocket(fd);
 572         return -1;
 573     }
 574
 575     nc = qemu_new_net_client(&net_socket_info, peer, model, name);
 576     s = DO_UPCAST(NetSocketState, nc, nc);
 577     s->fd = -1;
 578     s->listen_fd = fd;
 579     s->nc.link_down = true;
 580     net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
 581
 582     qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
 583
 584     /* Store startup parameters */
 585     nc->stored_config = g_new0(NetdevInfo, 1);
 586     nc->stored_config->type = NET_BACKEND_SOCKET;
 587     stored = &nc->stored_config->u.socket;
 588
 589     stored->has_listen = true;
 590     stored->listen = g_strdup(host_str);
 591
 592     return 0;
 593 }
 594
 595 static int net_socket_connect_init(NetClientState *peer,
 596                                    const char *model,
 597                                    const char *name,
 598                                    const char *host_str,
 599                                    Error **errp)
 600 {
 601     NetSocketState *s;
 602     int fd, connected, ret;
 603     struct sockaddr_in saddr;
 604     NetdevSocketOptions *stored;
 605
 606     if (parse_host_port(&saddr, host_str, errp) < 0) {
 607         return -1;
 608     }
 609
 610     fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
 611     if (fd < 0) {
 612         error_setg_errno(errp, errno, "can't create stream socket");
 613         return -1;
 614     }
 615     qemu_set_nonblock(fd);
 616
 617     connected = 0;
 618     for(;;) {
 619         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
 620         if (ret < 0) {
 621             if (errno == EINTR || errno == EWOULDBLOCK) {
 622                 /* continue */
 623             } else if (errno == EINPROGRESS ||
 624                        errno == EALREADY ||
 625                        errno == EINVAL) {
 626                 break;
 627             } else {
 628                 error_setg_errno(errp, errno, "can't connect socket");
 629                 closesocket(fd);
 630                 return -1;
 631             }
 632         } else {
 633             connected = 1;
 634             break;
 635         }
 636     }
 637     s = net_socket_fd_init(peer, model, name, fd, connected, NULL, errp);
 638     if (!s) {
 639         return -1;
 640     }
 641
 642     /* Store additional startup parameters (extend net_socket_fd_init) */
 643     stored = &s->nc.stored_config->u.socket;
 644
 645     stored->has_connect = true;
 646     stored->connect = g_strdup(host_str);
 647
 648     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 649              "socket: connect to %s:%d",
 650              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 651     return 0;
 652 }
 653
 654 static int net_socket_mcast_init(NetClientState *peer,
 655                                  const char *model,
 656                                  const char *name,
 657                                  const char *host_str,
 658                                  const char *localaddr_str,
 659                                  Error **errp)
 660 {
 661     NetSocketState *s;
 662     int fd;
 663     struct sockaddr_in saddr;
 664     struct in_addr localaddr, *param_localaddr;
 665     NetdevSocketOptions *stored;
 666
 667     if (parse_host_port(&saddr, host_str, errp) < 0) {
 668         return -1;
 669     }
 670
 671     if (localaddr_str != NULL) {
 672         if (inet_aton(localaddr_str, &localaddr) == 0) {
 673             error_setg(errp, "localaddr '%s' is not a valid IPv4 address",
 674                        localaddr_str);
 675             return -1;
 676         }
 677         param_localaddr = &localaddr;
 678     } else {
 679         param_localaddr = NULL;
 680     }
 681
 682     fd = net_socket_mcast_create(&saddr, param_localaddr, errp);
 683     if (fd < 0) {
 684         return -1;
 685     }
 686
 687     s = net_socket_fd_init(peer, model, name, fd, 0, NULL, errp);
 688     if (!s) {
 689         return -1;
 690     }
 691
 692     s->dgram_dst = saddr;
 693
 694     /* Store additional startup parameters (extend net_socket_fd_init) */
 695     stored = &s->nc.stored_config->u.socket;
 696
 697     if (!stored->has_mcast) {
 698         stored->has_mcast = true;
 699         stored->mcast = g_strdup(host_str);
 700     }
 701
 702     if (localaddr_str) {
 703         stored->has_localaddr = true;
 704         stored->localaddr = g_strdup(localaddr_str);
 705     }
 706
 707     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 708              "socket: mcast=%s:%d",
 709              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 710     return 0;
 711
 712 }
 713
 714 static int net_socket_udp_init(NetClientState *peer,
 715                                  const char *model,
 716                                  const char *name,
 717                                  const char *rhost,
 718                                  const char *lhost,
 719                                  Error **errp)
 720 {
 721     NetSocketState *s;
 722     int fd, ret;
 723     struct sockaddr_in laddr, raddr;
 724     NetdevSocketOptions *stored;
 725
 726     if (parse_host_port(&laddr, lhost, errp) < 0) {
 727         return -1;
 728     }
 729
 730     if (parse_host_port(&raddr, rhost, errp) < 0) {
 731         return -1;
 732     }
 733
 734     fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 735     if (fd < 0) {
 736         error_setg_errno(errp, errno, "can't create datagram socket");
 737         return -1;
 738     }
 739
 740     ret = socket_set_fast_reuse(fd);
 741     if (ret < 0) {
 742         error_setg_errno(errp, errno,
 743                          "can't set socket option SO_REUSEADDR");
 744         closesocket(fd);
 745         return -1;
 746     }
 747     ret = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
 748     if (ret < 0) {
 749         error_setg_errno(errp, errno, "can't bind ip=%s to socket",
 750                          inet_ntoa(laddr.sin_addr));
 751         closesocket(fd);
 752         return -1;
 753     }
 754     qemu_set_nonblock(fd);
 755
 756     s = net_socket_fd_init(peer, model, name, fd, 0, NULL, errp);
 757     if (!s) {
 758         return -1;
 759     }
 760
 761     s->dgram_dst = raddr;
 762
 763     /* Store additional startup parameters (extend net_socket_fd_init) */
 764     stored = &s->nc.stored_config->u.socket;
 765
 766     stored->has_localaddr = true;
 767     stored->localaddr = g_strdup(lhost);
 768
 769     stored->has_udp = true;
 770     stored->udp = g_strdup(rhost);
 771
 772     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 773              "socket: udp=%s:%d",
 774              inet_ntoa(raddr.sin_addr), ntohs(raddr.sin_port));
 775     return 0;
 776 }
 777
 778 int net_init_socket(const Netdev *netdev, const char *name,
 779                     NetClientState *peer, Error **errp)
 780 {
 781     const NetdevSocketOptions *sock;
 782
 783     assert(netdev->type == NET_CLIENT_DRIVER_SOCKET);
 784     sock = &netdev->u.socket;
 785
 786     if (sock->has_fd + sock->has_listen + sock->has_connect + sock->has_mcast +
 787         sock->has_udp != 1) {
 788         error_setg(errp, "exactly one of listen=, connect=, mcast= or udp="
 789                    " is required");
 790         return -1;
 791     }
 792
 793     if (sock->has_localaddr && !sock->has_mcast && !sock->has_udp) {
 794         error_setg(errp, "localaddr= is only valid with mcast= or udp=");
 795         return -1;
 796     }
 797
 798     if (sock->has_fd) {
 799         int fd, ret;
 800
 801         fd = monitor_fd_param(monitor_cur(), sock->fd, errp);
 802         if (fd == -1) {
 803             return -1;
 804         }
 805         ret = qemu_try_set_nonblock(fd);
 806         if (ret < 0) {
 807             error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
 808                              name, fd);
 809             return -1;
 810         }
 811         if (!net_socket_fd_init(peer, "socket", name, fd, 1, sock->mcast,
 812                                 errp)) {
 813             return -1;
 814         }
 815         return 0;
 816     }
 817
 818     if (sock->has_listen) {
 819         if (net_socket_listen_init(peer, "socket", name, sock->listen, errp)
 820             < 0) {
 821             return -1;
 822         }
 823         return 0;
 824     }
 825
 826     if (sock->has_connect) {
 827         if (net_socket_connect_init(peer, "socket", name, sock->connect, errp)
 828             < 0) {
 829             return -1;
 830         }
 831         return 0;
 832     }
 833
 834     if (sock->has_mcast) {
 835         /* if sock->localaddr is missing, it has been initialized to "all bits
 836          * zero" */
 837         if (net_socket_mcast_init(peer, "socket", name, sock->mcast,
 838                                   sock->localaddr, errp) < 0) {
 839             return -1;
 840         }
 841         return 0;
 842     }
 843
 844     assert(sock->has_udp);
 845     if (!sock->has_localaddr) {
 846         error_setg(errp, "localaddr= is mandatory with udp=");
 847         return -1;
 848     }
 849     if (net_socket_udp_init(peer, "socket", name, sock->udp, sock->localaddr,
 850                             errp) < 0) {
 851         return -1;
 852     }
 853     return 0;
 854 }