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 "net/socket.h"
  25
  26 #include "config-host.h"
  27
  28 #include "net.h"
  29 #include "monitor.h"
  30 #include "qemu-char.h"
  31 #include "qemu-common.h"
  32 #include "qemu-error.h"
  33 #include "qemu-option.h"
  34 #include "qemu_socket.h"
  35
  36 typedef struct NetSocketState {
  37     VLANClientState nc;
  38     int fd;
  39     int state; /* 0 = getting length, 1 = getting data */
  40     unsigned int index;
  41     unsigned int packet_len;
  42     uint8_t buf[4096];
  43     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
  44 } NetSocketState;
  45
  46 typedef struct NetSocketListenState {
  47     VLANState *vlan;
  48     char *model;
  49     char *name;
  50     int fd;
  51 } NetSocketListenState;
  52
  53 /* XXX: we consider we can send the whole packet without blocking */
  54 static ssize_t net_socket_receive(VLANClientState *nc, const uint8_t *buf, size_t size)
  55 {
  56     NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
  57     uint32_t len;
  58     len = htonl(size);
  59
  60     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
  61     return send_all(s->fd, buf, size);
  62 }
  63
  64 static ssize_t net_socket_receive_dgram(VLANClientState *nc, const uint8_t *buf, size_t size)
  65 {
  66     NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
  67
  68     return sendto(s->fd, (const void *)buf, size, 0,
  69                   (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
  70 }
  71
  72 static void net_socket_send(void *opaque)
  73 {
  74     NetSocketState *s = opaque;
  75     int size, err;
  76     unsigned l;
  77     uint8_t buf1[4096];
  78     const uint8_t *buf;
  79
  80     size = qemu_recv(s->fd, buf1, sizeof(buf1), 0);
  81     if (size < 0) {
  82         err = socket_error();
  83         if (err != EWOULDBLOCK)
  84             goto eoc;
  85     } else if (size == 0) {
  86         /* end of connection */
  87     eoc:
  88         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
  89         closesocket(s->fd);
  90         return;
  91     }
  92     buf = buf1;
  93     while (size > 0) {
  94         /* reassemble a packet from the network */
  95         switch(s->state) {
  96         case 0:
  97             l = 4 - s->index;
  98             if (l > size)
  99                 l = size;
 100             memcpy(s->buf + s->index, buf, l);
 101             buf += l;
 102             size -= l;
 103             s->index += l;
 104             if (s->index == 4) {
 105                 /* got length */
 106                 s->packet_len = ntohl(*(uint32_t *)s->buf);
 107                 s->index = 0;
 108                 s->state = 1;
 109             }
 110             break;
 111         case 1:
 112             l = s->packet_len - s->index;
 113             if (l > size)
 114                 l = size;
 115             if (s->index + l <= sizeof(s->buf)) {
 116                 memcpy(s->buf + s->index, buf, l);
 117             } else {
 118                 fprintf(stderr, "serious error: oversized packet received,"
 119                     "connection terminated.\n");
 120                 s->state = 0;
 121                 goto eoc;
 122             }
 123
 124             s->index += l;
 125             buf += l;
 126             size -= l;
 127             if (s->index >= s->packet_len) {
 128                 qemu_send_packet(&s->nc, s->buf, s->packet_len);
 129                 s->index = 0;
 130                 s->state = 0;
 131             }
 132             break;
 133         }
 134     }
 135 }
 136
 137 static void net_socket_send_dgram(void *opaque)
 138 {
 139     NetSocketState *s = opaque;
 140     int size;
 141
 142     size = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);
 143     if (size < 0)
 144         return;
 145     if (size == 0) {
 146         /* end of connection */
 147         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
 148         return;
 149     }
 150     qemu_send_packet(&s->nc, s->buf, size);
 151 }
 152
 153 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr, struct in_addr *localaddr)
 154 {
 155     struct ip_mreq imr;
 156     int fd;
 157     int val, ret;
 158 #ifdef __OpenBSD__
 159     unsigned char loop;
 160 #else
 161     int loop;
 162 #endif
 163
 164     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
 165         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) "
 166                 "does not contain a multicast address\n",
 167                 inet_ntoa(mcastaddr->sin_addr),
 168                 (int)ntohl(mcastaddr->sin_addr.s_addr));
 169         return -1;
 170
 171     }
 172     fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 173     if (fd < 0) {
 174         perror("socket(PF_INET, SOCK_DGRAM)");
 175         return -1;
 176     }
 177
 178     val = 1;
 179     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
 180                    (const char *)&val, sizeof(val));
 181     if (ret < 0) {
 182         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
 183         goto fail;
 184     }
 185
 186     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
 187     if (ret < 0) {
 188         perror("bind");
 189         goto fail;
 190     }
 191
 192     /* Add host to multicast group */
 193     imr.imr_multiaddr = mcastaddr->sin_addr;
 194     if (localaddr) {
 195         imr.imr_interface = *localaddr;
 196     } else {
 197         imr.imr_interface.s_addr = htonl(INADDR_ANY);
 198     }
 199
 200     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 201                      (const char *)&imr, sizeof(struct ip_mreq));
 202     if (ret < 0) {
 203         perror("setsockopt(IP_ADD_MEMBERSHIP)");
 204         goto fail;
 205     }
 206
 207     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
 208     loop = 1;
 209     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
 210                    (const char *)&loop, sizeof(loop));
 211     if (ret < 0) {
 212         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
 213         goto fail;
 214     }
 215
 216     /* If a bind address is given, only send packets from that address */
 217     if (localaddr != NULL) {
 218         ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
 219                          (const char *)localaddr, sizeof(*localaddr));
 220         if (ret < 0) {
 221             perror("setsockopt(IP_MULTICAST_IF)");
 222             goto fail;
 223         }
 224     }
 225
 226     socket_set_nonblock(fd);
 227     return fd;
 228 fail:
 229     if (fd >= 0)
 230         closesocket(fd);
 231     return -1;
 232 }
 233
 234 static void net_socket_cleanup(VLANClientState *nc)
 235 {
 236     NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
 237     qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
 238     close(s->fd);
 239 }
 240
 241 static NetClientInfo net_dgram_socket_info = {
 242     .type = NET_CLIENT_TYPE_SOCKET,
 243     .size = sizeof(NetSocketState),
 244     .receive = net_socket_receive_dgram,
 245     .cleanup = net_socket_cleanup,
 246 };
 247
 248 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
 249                                                 const char *model,
 250                                                 const char *name,
 251                                                 int fd, int is_connected)
 252 {
 253     struct sockaddr_in saddr;
 254     int newfd;
 255     socklen_t saddr_len;
 256     VLANClientState *nc;
 257     NetSocketState *s;
 258
 259     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
 260      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
 261      * by ONLY ONE process: we must "clone" this dgram socket --jjo
 262      */
 263
 264     if (is_connected) {
 265         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
 266             /* must be bound */
 267             if (saddr.sin_addr.s_addr == 0) {
 268                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, "
 269                         "cannot setup multicast dst addr\n", fd);
 270                 goto err;
 271             }
 272             /* clone dgram socket */
 273             newfd = net_socket_mcast_create(&saddr, NULL);
 274             if (newfd < 0) {
 275                 /* error already reported by net_socket_mcast_create() */
 276                 goto err;
 277             }
 278             /* clone newfd to fd, close newfd */
 279             dup2(newfd, fd);
 280             close(newfd);
 281
 282         } else {
 283             fprintf(stderr,
 284                     "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
 285                     fd, strerror(errno));
 286             goto err;
 287         }
 288     }
 289
 290     nc = qemu_new_net_client(&net_dgram_socket_info, vlan, NULL, model, name);
 291
 292     snprintf(nc->info_str, sizeof(nc->info_str),
 293             "socket: fd=%d (%s mcast=%s:%d)",
 294             fd, is_connected ? "cloned" : "",
 295             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 296
 297     s = DO_UPCAST(NetSocketState, nc, nc);
 298
 299     s->fd = fd;
 300
 301     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
 302
 303     /* mcast: save bound address as dst */
 304     if (is_connected) s->dgram_dst=saddr;
 305
 306     return s;
 307
 308 err:
 309     closesocket(fd);
 310     return NULL;
 311 }
 312
 313 static void net_socket_connect(void *opaque)
 314 {
 315     NetSocketState *s = opaque;
 316     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
 317 }
 318
 319 static NetClientInfo net_socket_info = {
 320     .type = NET_CLIENT_TYPE_SOCKET,
 321     .size = sizeof(NetSocketState),
 322     .receive = net_socket_receive,
 323     .cleanup = net_socket_cleanup,
 324 };
 325
 326 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
 327                                                  const char *model,
 328                                                  const char *name,
 329                                                  int fd, int is_connected)
 330 {
 331     VLANClientState *nc;
 332     NetSocketState *s;
 333
 334     nc = qemu_new_net_client(&net_socket_info, vlan, NULL, model, name);
 335
 336     snprintf(nc->info_str, sizeof(nc->info_str), "socket: fd=%d", fd);
 337
 338     s = DO_UPCAST(NetSocketState, nc, nc);
 339
 340     s->fd = fd;
 341
 342     if (is_connected) {
 343         net_socket_connect(s);
 344     } else {
 345         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
 346     }
 347     return s;
 348 }
 349
 350 static NetSocketState *net_socket_fd_init(VLANState *vlan,
 351                                           const char *model, const char *name,
 352                                           int fd, int is_connected)
 353 {
 354     int so_type = -1, optlen=sizeof(so_type);
 355
 356     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
 357         (socklen_t *)&optlen)< 0) {
 358         fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n",
 359                 fd);
 360         closesocket(fd);
 361         return NULL;
 362     }
 363     switch(so_type) {
 364     case SOCK_DGRAM:
 365         return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
 366     case SOCK_STREAM:
 367         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
 368     default:
 369         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
 370         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
 371         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
 372     }
 373     return NULL;
 374 }
 375
 376 static void net_socket_accept(void *opaque)
 377 {
 378     NetSocketListenState *s = opaque;
 379     NetSocketState *s1;
 380     struct sockaddr_in saddr;
 381     socklen_t len;
 382     int fd;
 383
 384     for(;;) {
 385         len = sizeof(saddr);
 386         fd = qemu_accept(s->fd, (struct sockaddr *)&saddr, &len);
 387         if (fd < 0 && errno != EINTR) {
 388             return;
 389         } else if (fd >= 0) {
 390             break;
 391         }
 392     }
 393     s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
 394     if (s1) {
 395         snprintf(s1->nc.info_str, sizeof(s1->nc.info_str),
 396                  "socket: connection from %s:%d",
 397                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 398     }
 399 }
 400
 401 static int net_socket_listen_init(VLANState *vlan,
 402                                   const char *model,
 403                                   const char *name,
 404                                   const char *host_str)
 405 {
 406     NetSocketListenState *s;
 407     int fd, val, ret;
 408     struct sockaddr_in saddr;
 409
 410     if (parse_host_port(&saddr, host_str) < 0)
 411         return -1;
 412
 413     s = g_malloc0(sizeof(NetSocketListenState));
 414
 415     fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
 416     if (fd < 0) {
 417         perror("socket");
 418         g_free(s);
 419         return -1;
 420     }
 421     socket_set_nonblock(fd);
 422
 423     /* allow fast reuse */
 424     val = 1;
 425     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
 426
 427     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
 428     if (ret < 0) {
 429         perror("bind");
 430         g_free(s);
 431         closesocket(fd);
 432         return -1;
 433     }
 434     ret = listen(fd, 0);
 435     if (ret < 0) {
 436         perror("listen");
 437         g_free(s);
 438         closesocket(fd);
 439         return -1;
 440     }
 441     s->vlan = vlan;
 442     s->model = g_strdup(model);
 443     s->name = name ? g_strdup(name) : NULL;
 444     s->fd = fd;
 445     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
 446     return 0;
 447 }
 448
 449 static int net_socket_connect_init(VLANState *vlan,
 450                                    const char *model,
 451                                    const char *name,
 452                                    const char *host_str)
 453 {
 454     NetSocketState *s;
 455     int fd, connected, ret, err;
 456     struct sockaddr_in saddr;
 457
 458     if (parse_host_port(&saddr, host_str) < 0)
 459         return -1;
 460
 461     fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
 462     if (fd < 0) {
 463         perror("socket");
 464         return -1;
 465     }
 466     socket_set_nonblock(fd);
 467
 468     connected = 0;
 469     for(;;) {
 470         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
 471         if (ret < 0) {
 472             err = socket_error();
 473             if (err == EINTR || err == EWOULDBLOCK) {
 474             } else if (err == EINPROGRESS) {
 475                 break;
 476 #ifdef _WIN32
 477             } else if (err == WSAEALREADY || err == WSAEINVAL) {
 478                 break;
 479 #endif
 480             } else {
 481                 perror("connect");
 482                 closesocket(fd);
 483                 return -1;
 484             }
 485         } else {
 486             connected = 1;
 487             break;
 488         }
 489     }
 490     s = net_socket_fd_init(vlan, model, name, fd, connected);
 491     if (!s)
 492         return -1;
 493     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 494              "socket: connect to %s:%d",
 495              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 496     return 0;
 497 }
 498
 499 static int net_socket_mcast_init(VLANState *vlan,
 500                                  const char *model,
 501                                  const char *name,
 502                                  const char *host_str,
 503                                  const char *localaddr_str)
 504 {
 505     NetSocketState *s;
 506     int fd;
 507     struct sockaddr_in saddr;
 508     struct in_addr localaddr, *param_localaddr;
 509
 510     if (parse_host_port(&saddr, host_str) < 0)
 511         return -1;
 512
 513     if (localaddr_str != NULL) {
 514         if (inet_aton(localaddr_str, &localaddr) == 0)
 515             return -1;
 516         param_localaddr = &localaddr;
 517     } else {
 518         param_localaddr = NULL;
 519     }
 520
 521     fd = net_socket_mcast_create(&saddr, param_localaddr);
 522     if (fd < 0)
 523         return -1;
 524
 525     s = net_socket_fd_init(vlan, model, name, fd, 0);
 526     if (!s)
 527         return -1;
 528
 529     s->dgram_dst = saddr;
 530
 531     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 532              "socket: mcast=%s:%d",
 533              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 534     return 0;
 535
 536 }
 537
 538 static int net_socket_udp_init(VLANState *vlan,
 539                                  const char *model,
 540                                  const char *name,
 541                                  const char *rhost,
 542                                  const char *lhost)
 543 {
 544     NetSocketState *s;
 545     int fd, val, ret;
 546     struct sockaddr_in laddr, raddr;
 547
 548     if (parse_host_port(&laddr, lhost) < 0) {
 549         return -1;
 550     }
 551
 552     if (parse_host_port(&raddr, rhost) < 0) {
 553         return -1;
 554     }
 555
 556     fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 557     if (fd < 0) {
 558         perror("socket(PF_INET, SOCK_DGRAM)");
 559         return -1;
 560     }
 561     val = 1;
 562     ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
 563                    (const char *)&val, sizeof(val));
 564     if (ret < 0) {
 565         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
 566         closesocket(fd);
 567         return -1;
 568     }
 569     ret = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
 570     if (ret < 0) {
 571         perror("bind");
 572         closesocket(fd);
 573         return -1;
 574     }
 575
 576     s = net_socket_fd_init(vlan, model, name, fd, 0);
 577     if (!s) {
 578         return -1;
 579     }
 580
 581     s->dgram_dst = raddr;
 582
 583     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 584              "socket: udp=%s:%d",
 585              inet_ntoa(raddr.sin_addr), ntohs(raddr.sin_port));
 586     return 0;
 587 }
 588
 589 int net_init_socket(QemuOpts *opts, const char *name, VLANState *vlan)
 590 {
 591     if (qemu_opt_get(opts, "fd")) {
 592         int fd;
 593
 594         if (qemu_opt_get(opts, "listen") ||
 595             qemu_opt_get(opts, "connect") ||
 596             qemu_opt_get(opts, "mcast") ||
 597             qemu_opt_get(opts, "localaddr")) {
 598             error_report("listen=, connect=, mcast= and localaddr= is invalid with fd=");
 599             return -1;
 600         }
 601
 602         fd = net_handle_fd_param(cur_mon, qemu_opt_get(opts, "fd"));
 603         if (fd == -1) {
 604             return -1;
 605         }
 606
 607         if (!net_socket_fd_init(vlan, "socket", name, fd, 1)) {
 608             return -1;
 609         }
 610     } else if (qemu_opt_get(opts, "listen")) {
 611         const char *listen;
 612
 613         if (qemu_opt_get(opts, "fd") ||
 614             qemu_opt_get(opts, "connect") ||
 615             qemu_opt_get(opts, "mcast") ||
 616             qemu_opt_get(opts, "localaddr")) {
 617             error_report("fd=, connect=, mcast= and localaddr= is invalid with listen=");
 618             return -1;
 619         }
 620
 621         listen = qemu_opt_get(opts, "listen");
 622
 623         if (net_socket_listen_init(vlan, "socket", name, listen) == -1) {
 624             return -1;
 625         }
 626     } else if (qemu_opt_get(opts, "connect")) {
 627         const char *connect;
 628
 629         if (qemu_opt_get(opts, "fd") ||
 630             qemu_opt_get(opts, "listen") ||
 631             qemu_opt_get(opts, "mcast") ||
 632             qemu_opt_get(opts, "localaddr")) {
 633             error_report("fd=, listen=, mcast= and localaddr= is invalid with connect=");
 634             return -1;
 635         }
 636
 637         connect = qemu_opt_get(opts, "connect");
 638
 639         if (net_socket_connect_init(vlan, "socket", name, connect) == -1) {
 640             return -1;
 641         }
 642     } else if (qemu_opt_get(opts, "mcast")) {
 643         const char *mcast, *localaddr;
 644
 645         if (qemu_opt_get(opts, "fd") ||
 646             qemu_opt_get(opts, "connect") ||
 647             qemu_opt_get(opts, "listen")) {
 648             error_report("fd=, connect= and listen= is invalid with mcast=");
 649             return -1;
 650         }
 651
 652         mcast = qemu_opt_get(opts, "mcast");
 653         localaddr = qemu_opt_get(opts, "localaddr");
 654
 655         if (net_socket_mcast_init(vlan, "socket", name, mcast, localaddr) == -1) {
 656             return -1;
 657         }
 658     } else if (qemu_opt_get(opts, "udp")) {
 659         const char *udp, *localaddr;
 660
 661         if (qemu_opt_get(opts, "fd") ||
 662             qemu_opt_get(opts, "connect") ||
 663             qemu_opt_get(opts, "listen") ||
 664             qemu_opt_get(opts, "mcast")) {
 665             error_report("fd=, connect=, listen="
 666                          " and mcast= is invalid with udp=");
 667             return -1;
 668         }
 669
 670         udp = qemu_opt_get(opts, "udp");
 671         localaddr = qemu_opt_get(opts, "localaddr");
 672         if (localaddr == NULL) {
 673                 error_report("localaddr= is mandatory with udp=");
 674                 return -1;
 675         }
 676
 677         if (net_socket_udp_init(vlan, "udp", name, udp, localaddr) == -1) {
 678             return -1;
 679         }
 680     } else {
 681         error_report("-socket requires fd=, listen=,"
 682                      " connect=, mcast= or udp=");
 683         return -1;
 684     }
 685     return 0;
 686 }