net.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 <unistd.h>
  25 #include <fcntl.h>
  26 #include <signal.h>
  27 #include <time.h>
  28 #include <errno.h>
  29 #include <sys/time.h>
  30 #include <zlib.h>
  31
  32 /* Needed early for CONFIG_BSD etc. */
  33 #include "config-host.h"
  34
  35 #ifndef _WIN32
  36 #include <sys/times.h>
  37 #include <sys/wait.h>
  38 #include <termios.h>
  39 #include <sys/mman.h>
  40 #include <sys/ioctl.h>
  41 #include <sys/resource.h>
  42 #include <sys/socket.h>
  43 #include <netinet/in.h>
  44 #include <net/if.h>
  45 #ifdef __NetBSD__
  46 #include <net/if_tap.h>
  47 #endif
  48 #ifdef __linux__
  49 #include "tap-linux.h"
  50 #endif
  51 #include <arpa/inet.h>
  52 #include <dirent.h>
  53 #include <netdb.h>
  54 #include <sys/select.h>
  55 #ifdef CONFIG_BSD
  56 #include <sys/stat.h>
  57 #if defined(__FreeBSD__) || defined(__DragonFly__)
  58 #include <libutil.h>
  59 #else
  60 #include <util.h>
  61 #endif
  62 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
  63 #include <freebsd/stdlib.h>
  64 #else
  65 #ifdef __linux__
  66 #include <pty.h>
  67 #include <malloc.h>
  68 #include <linux/rtc.h>
  69
  70 /* For the benefit of older linux systems which don't supply it,
  71    we use a local copy of hpet.h. */
  72 /* #include <linux/hpet.h> */
  73 #include "hpet.h"
  74
  75 #include <linux/ppdev.h>
  76 #include <linux/parport.h>
  77 #endif
  78 #ifdef __sun__
  79 #include <sys/stat.h>
  80 #include <sys/ethernet.h>
  81 #include <sys/sockio.h>
  82 #include <netinet/arp.h>
  83 #include <netinet/in.h>
  84 #include <netinet/in_systm.h>
  85 #include <netinet/ip.h>
  86 #include <netinet/ip_icmp.h> // must come after ip.h
  87 #include <netinet/udp.h>
  88 #include <netinet/tcp.h>
  89 #include <net/if.h>
  90 #include <syslog.h>
  91 #include <stropts.h>
  92 #endif
  93 #endif
  94 #endif
  95
  96 #if defined(__OpenBSD__)
  97 #include <util.h>
  98 #endif
  99
 100 #if defined(CONFIG_VDE)
 101 #include <libvdeplug.h>
 102 #endif
 103
 104 // FIXME: #include "qemu-kvm.h"
 105 #include "qemu-common.h"
 106 #include "net.h"
 107 #include "monitor.h"
 108 #include "sysemu.h"
 109 #include "qemu-timer.h"
 110 #include "qemu-char.h"
 111 #include "audio/audio.h"
 112 #include "qemu_socket.h"
 113 #include "qemu-log.h"
 114 #include "qemu-config.h"
 115
 116 #include "slirp/libslirp.h"
 117
 118 static QTAILQ_HEAD(, VLANState) vlans;
 119 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
 120
 121 /***********************************************************/
 122 /* network device redirectors */
 123
 124 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
 125 static void hex_dump(FILE *f, const uint8_t *buf, int size)
 126 {
 127     int len, i, j, c;
 128
 129     for(i=0;i<size;i+=16) {
 130         len = size - i;
 131         if (len > 16)
 132             len = 16;
 133         fprintf(f, "%08x ", i);
 134         for(j=0;j<16;j++) {
 135             if (j < len)
 136                 fprintf(f, " %02x", buf[i+j]);
 137             else
 138                 fprintf(f, "   ");
 139         }
 140         fprintf(f, " ");
 141         for(j=0;j<len;j++) {
 142             c = buf[i+j];
 143             if (c < ' ' || c > '~')
 144                 c = '.';
 145             fprintf(f, "%c", c);
 146         }
 147         fprintf(f, "\n");
 148     }
 149 }
 150 #endif
 151
 152 static int parse_macaddr(uint8_t *macaddr, const char *p)
 153 {
 154     int i;
 155     char *last_char;
 156     long int offset;
 157
 158     errno = 0;
 159     offset = strtol(p, &last_char, 0);
 160     if (0 == errno && '\0' == *last_char &&
 161             offset >= 0 && offset <= 0xFFFFFF) {
 162         macaddr[3] = (offset & 0xFF0000) >> 16;
 163         macaddr[4] = (offset & 0xFF00) >> 8;
 164         macaddr[5] = offset & 0xFF;
 165         return 0;
 166     } else {
 167         for(i = 0; i < 6; i++) {
 168             macaddr[i] = strtol(p, (char **)&p, 16);
 169             if (i == 5) {
 170                 if (*p != '\0')
 171                     return -1;
 172             } else {
 173                 if (*p != ':' && *p != '-')
 174                     return -1;
 175                 p++;
 176             }
 177         }
 178         return 0;
 179     }
 180
 181     return -1;
 182 }
 183
 184 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
 185 {
 186     const char *p, *p1;
 187     int len;
 188     p = *pp;
 189     p1 = strchr(p, sep);
 190     if (!p1)
 191         return -1;
 192     len = p1 - p;
 193     p1++;
 194     if (buf_size > 0) {
 195         if (len > buf_size - 1)
 196             len = buf_size - 1;
 197         memcpy(buf, p, len);
 198         buf[len] = '\0';
 199     }
 200     *pp = p1;
 201     return 0;
 202 }
 203
 204 int parse_host_src_port(struct sockaddr_in *haddr,
 205                         struct sockaddr_in *saddr,
 206                         const char *input_str)
 207 {
 208     char *str = strdup(input_str);
 209     char *host_str = str;
 210     char *src_str;
 211     const char *src_str2;
 212     char *ptr;
 213
 214     /*
 215      * Chop off any extra arguments at the end of the string which
 216      * would start with a comma, then fill in the src port information
 217      * if it was provided else use the "any address" and "any port".
 218      */
 219     if ((ptr = strchr(str,',')))
 220         *ptr = '\0';
 221
 222     if ((src_str = strchr(input_str,'@'))) {
 223         *src_str = '\0';
 224         src_str++;
 225     }
 226
 227     if (parse_host_port(haddr, host_str) < 0)
 228         goto fail;
 229
 230     src_str2 = src_str;
 231     if (!src_str || *src_str == '\0')
 232         src_str2 = ":0";
 233
 234     if (parse_host_port(saddr, src_str2) < 0)
 235         goto fail;
 236
 237     free(str);
 238     return(0);
 239
 240 fail:
 241     free(str);
 242     return -1;
 243 }
 244
 245 int parse_host_port(struct sockaddr_in *saddr, const char *str)
 246 {
 247     char buf[512];
 248     struct hostent *he;
 249     const char *p, *r;
 250     int port;
 251
 252     p = str;
 253     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
 254         return -1;
 255     saddr->sin_family = AF_INET;
 256     if (buf[0] == '\0') {
 257         saddr->sin_addr.s_addr = 0;
 258     } else {
 259         if (qemu_isdigit(buf[0])) {
 260             if (!inet_aton(buf, &saddr->sin_addr))
 261                 return -1;
 262         } else {
 263             if ((he = gethostbyname(buf)) == NULL)
 264                 return - 1;
 265             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 266         }
 267     }
 268     port = strtol(p, (char **)&r, 0);
 269     if (r == p)
 270         return -1;
 271     saddr->sin_port = htons(port);
 272     return 0;
 273 }
 274
 275 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
 276 {
 277     snprintf(vc->info_str, sizeof(vc->info_str),
 278              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 279              vc->model,
 280              macaddr[0], macaddr[1], macaddr[2],
 281              macaddr[3], macaddr[4], macaddr[5]);
 282 }
 283
 284 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 285 {
 286     static int index = 0;
 287     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 288
 289     if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
 290         return;
 291     macaddr->a[0] = 0x52;
 292     macaddr->a[1] = 0x54;
 293     macaddr->a[2] = 0x00;
 294     macaddr->a[3] = 0x12;
 295     macaddr->a[4] = 0x34;
 296     macaddr->a[5] = 0x56 + index++;
 297 }
 298
 299 static char *assign_name(VLANClientState *vc1, const char *model)
 300 {
 301     VLANState *vlan;
 302     char buf[256];
 303     int id = 0;
 304
 305     QTAILQ_FOREACH(vlan, &vlans, next) {
 306         VLANClientState *vc;
 307
 308         QTAILQ_FOREACH(vc, &vlan->clients, next) {
 309             if (vc != vc1 && strcmp(vc->model, model) == 0) {
 310                 id++;
 311             }
 312         }
 313     }
 314
 315     snprintf(buf, sizeof(buf), "%s.%d", model, id);
 316
 317     return qemu_strdup(buf);
 318 }
 319
 320 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 321                                    unsigned flags,
 322                                    const uint8_t *data,
 323                                    size_t size,
 324                                    void *opaque);
 325 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 326                                        unsigned flags,
 327                                        const struct iovec *iov,
 328                                        int iovcnt,
 329                                        void *opaque);
 330
 331 VLANClientState *qemu_new_vlan_client(net_client_type type,
 332                                       VLANState *vlan,
 333                                       VLANClientState *peer,
 334                                       const char *model,
 335                                       const char *name,
 336                                       NetCanReceive *can_receive,
 337                                       NetReceive *receive,
 338                                       NetReceive *receive_raw,
 339                                       NetReceiveIOV *receive_iov,
 340                                       NetCleanup *cleanup,
 341                                       void *opaque)
 342 {
 343     VLANClientState *vc;
 344
 345     vc = qemu_mallocz(sizeof(VLANClientState));
 346
 347     vc->type = type;
 348     vc->model = qemu_strdup(model);
 349     if (name)
 350         vc->name = qemu_strdup(name);
 351     else
 352         vc->name = assign_name(vc, model);
 353     vc->can_receive = can_receive;
 354     vc->receive = receive;
 355     vc->receive_raw = receive_raw;
 356     vc->receive_iov = receive_iov;
 357     vc->cleanup = cleanup;
 358     vc->opaque = opaque;
 359
 360     if (vlan) {
 361         assert(!peer);
 362         vc->vlan = vlan;
 363         QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
 364     } else {
 365         if (peer) {
 366             vc->peer = peer;
 367             peer->peer = vc;
 368         }
 369         QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
 370
 371         vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
 372                                             qemu_deliver_packet_iov,
 373                                             vc);
 374     }
 375
 376     return vc;
 377 }
 378
 379 void qemu_del_vlan_client(VLANClientState *vc)
 380 {
 381     if (vc->vlan) {
 382         QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
 383     } else {
 384         if (vc->send_queue) {
 385             qemu_del_net_queue(vc->send_queue);
 386         }
 387         QTAILQ_REMOVE(&non_vlan_clients, vc, next);
 388         if (vc->peer) {
 389             vc->peer->peer = NULL;
 390         }
 391     }
 392
 393     if (vc->cleanup) {
 394         vc->cleanup(vc);
 395     }
 396
 397     qemu_free(vc->name);
 398     qemu_free(vc->model);
 399     qemu_free(vc);
 400 }
 401
 402 VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
 403 {
 404     VLANClientState *vc;
 405
 406     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 407         if (vc->opaque == opaque) {
 408             return vc;
 409         }
 410     }
 411
 412     return NULL;
 413 }
 414
 415 static VLANClientState *
 416 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
 417                               const char *client_str)
 418 {
 419     VLANState *vlan;
 420     VLANClientState *vc;
 421
 422     vlan = qemu_find_vlan(vlan_id, 0);
 423     if (!vlan) {
 424         monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
 425         return NULL;
 426     }
 427
 428     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 429         if (!strcmp(vc->name, client_str)) {
 430             break;
 431         }
 432     }
 433     if (!vc) {
 434         monitor_printf(mon, "can't find device %s on VLAN %d\n",
 435                        client_str, vlan_id);
 436     }
 437
 438     return vc;
 439 }
 440
 441 int qemu_can_send_packet(VLANClientState *sender)
 442 {
 443     VLANState *vlan = sender->vlan;
 444     VLANClientState *vc;
 445
 446     if (sender->peer) {
 447         if (!sender->peer->can_receive ||
 448             sender->peer->can_receive(sender->peer)) {
 449             return 1;
 450         } else {
 451             return 0;
 452         }
 453     }
 454
 455     if (!sender->vlan) {
 456         return 1;
 457     }
 458
 459     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 460         if (vc == sender) {
 461             continue;
 462         }
 463
 464         /* no can_receive() handler, they can always receive */
 465         if (!vc->can_receive || vc->can_receive(vc)) {
 466             return 1;
 467         }
 468     }
 469     return 0;
 470 }
 471
 472 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 473                                    unsigned flags,
 474                                    const uint8_t *data,
 475                                    size_t size,
 476                                    void *opaque)
 477 {
 478     VLANClientState *vc = opaque;
 479
 480     if (vc->link_down) {
 481         return size;
 482     }
 483
 484     if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->receive_raw)
 485         return vc->receive_raw(vc, data, size);
 486     else
 487         return vc->receive(vc, data, size);
 488 }
 489
 490 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
 491                                         unsigned flags,
 492                                         const uint8_t *buf,
 493                                         size_t size,
 494                                         void *opaque)
 495 {
 496     VLANState *vlan = opaque;
 497     VLANClientState *vc;
 498     int ret = -1;
 499
 500     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 501         ssize_t len;
 502
 503         if (vc == sender) {
 504             continue;
 505         }
 506
 507         if (vc->link_down) {
 508             ret = size;
 509             continue;
 510         }
 511
 512         if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->receive_raw)
 513             len = vc->receive_raw(vc, buf, size);
 514         else
 515             len = vc->receive(vc, buf, size);
 516
 517         ret = (ret >= 0) ? ret : len;
 518     }
 519
 520     return ret;
 521 }
 522
 523 void qemu_purge_queued_packets(VLANClientState *vc)
 524 {
 525     NetQueue *queue;
 526
 527     if (!vc->peer && !vc->vlan) {
 528         return;
 529     }
 530
 531     if (vc->peer) {
 532         queue = vc->peer->send_queue;
 533     } else {
 534         queue = vc->vlan->send_queue;
 535     }
 536
 537     qemu_net_queue_purge(queue, vc);
 538 }
 539
 540 void qemu_flush_queued_packets(VLANClientState *vc)
 541 {
 542     NetQueue *queue;
 543
 544     if (vc->vlan) {
 545         queue = vc->vlan->send_queue;
 546     } else {
 547         queue = vc->send_queue;
 548     }
 549
 550     qemu_net_queue_flush(queue);
 551 }
 552
 553 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
 554                                                  unsigned flags,
 555                                                  const uint8_t *buf, int size,
 556                                                  NetPacketSent *sent_cb)
 557 {
 558     NetQueue *queue;
 559
 560 #ifdef DEBUG_NET
 561     printf("qemu_send_packet_async:\n");
 562     hex_dump(stdout, buf, size);
 563 #endif
 564
 565     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 566         return size;
 567     }
 568
 569     if (sender->peer) {
 570         queue = sender->peer->send_queue;
 571     } else {
 572         queue = sender->vlan->send_queue;
 573     }
 574
 575     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 576 }
 577
 578 ssize_t qemu_send_packet_async(VLANClientState *sender,
 579                                const uint8_t *buf, int size,
 580                                NetPacketSent *sent_cb)
 581 {
 582     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 583                                              buf, size, sent_cb);
 584 }
 585
 586 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
 587 {
 588     qemu_send_packet_async(vc, buf, size, NULL);
 589 }
 590
 591 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
 592 {
 593     return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
 594                                              buf, size, NULL);
 595 }
 596
 597 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
 598                                int iovcnt)
 599 {
 600     uint8_t buffer[4096];
 601     size_t offset = 0;
 602     int i;
 603
 604     for (i = 0; i < iovcnt; i++) {
 605         size_t len;
 606
 607         len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
 608         memcpy(buffer + offset, iov[i].iov_base, len);
 609         offset += len;
 610     }
 611
 612     return vc->receive(vc, buffer, offset);
 613 }
 614
 615 static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
 616 {
 617     size_t offset = 0;
 618     int i;
 619
 620     for (i = 0; i < iovcnt; i++)
 621         offset += iov[i].iov_len;
 622     return offset;
 623 }
 624
 625 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 626                                        unsigned flags,
 627                                        const struct iovec *iov,
 628                                        int iovcnt,
 629                                        void *opaque)
 630 {
 631     VLANClientState *vc = opaque;
 632
 633     if (vc->link_down) {
 634         return calc_iov_length(iov, iovcnt);
 635     }
 636
 637     if (vc->receive_iov) {
 638         return vc->receive_iov(vc, iov, iovcnt);
 639     } else {
 640         return vc_sendv_compat(vc, iov, iovcnt);
 641     }
 642 }
 643
 644 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
 645                                             unsigned flags,
 646                                             const struct iovec *iov,
 647                                             int iovcnt,
 648                                             void *opaque)
 649 {
 650     VLANState *vlan = opaque;
 651     VLANClientState *vc;
 652     ssize_t ret = -1;
 653
 654     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 655         ssize_t len;
 656
 657         if (vc == sender) {
 658             continue;
 659         }
 660
 661         if (vc->link_down) {
 662             ret = calc_iov_length(iov, iovcnt);
 663             continue;
 664         }
 665
 666         assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
 667
 668         if (vc->receive_iov) {
 669             len = vc->receive_iov(vc, iov, iovcnt);
 670         } else {
 671             len = vc_sendv_compat(vc, iov, iovcnt);
 672         }
 673
 674         ret = (ret >= 0) ? ret : len;
 675     }
 676
 677     return ret;
 678 }
 679
 680 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
 681                                 const struct iovec *iov, int iovcnt,
 682                                 NetPacketSent *sent_cb)
 683 {
 684     NetQueue *queue;
 685
 686     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 687         return calc_iov_length(iov, iovcnt);
 688     }
 689
 690     if (sender->peer) {
 691         queue = sender->peer->send_queue;
 692     } else {
 693         queue = sender->vlan->send_queue;
 694     }
 695
 696     return qemu_net_queue_send_iov(queue, sender,
 697                                    QEMU_NET_PACKET_FLAG_NONE,
 698                                    iov, iovcnt, sent_cb);
 699 }
 700
 701 ssize_t
 702 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
 703 {
 704     return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
 705 }
 706
 707 #if defined(CONFIG_SLIRP)
 708
 709 /* slirp network adapter */
 710
 711 #define SLIRP_CFG_HOSTFWD 1
 712 #define SLIRP_CFG_LEGACY  2
 713
 714 struct slirp_config_str {
 715     struct slirp_config_str *next;
 716     int flags;
 717     char str[1024];
 718     int legacy_format;
 719 };
 720
 721 typedef struct SlirpState {
 722     QTAILQ_ENTRY(SlirpState) entry;
 723     VLANClientState *vc;
 724     Slirp *slirp;
 725 #ifndef _WIN32
 726     char smb_dir[128];
 727 #endif
 728 } SlirpState;
 729
 730 static struct slirp_config_str *slirp_configs;
 731 const char *legacy_tftp_prefix;
 732 const char *legacy_bootp_filename;
 733 static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
 734     QTAILQ_HEAD_INITIALIZER(slirp_stacks);
 735
 736 static int slirp_hostfwd(SlirpState *s, const char *redir_str,
 737                          int legacy_format);
 738 static int slirp_guestfwd(SlirpState *s, const char *config_str,
 739                           int legacy_format);
 740
 741 #ifndef _WIN32
 742 static const char *legacy_smb_export;
 743
 744 static int slirp_smb(SlirpState *s, const char *exported_dir,
 745                      struct in_addr vserver_addr);
 746 static void slirp_smb_cleanup(SlirpState *s);
 747 #else
 748 static inline void slirp_smb_cleanup(SlirpState *s) { }
 749 #endif
 750
 751 int slirp_can_output(void *opaque)
 752 {
 753     SlirpState *s = opaque;
 754
 755     return qemu_can_send_packet(s->vc);
 756 }
 757
 758 void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
 759 {
 760     SlirpState *s = opaque;
 761
 762 #ifdef DEBUG_SLIRP
 763     printf("slirp output:\n");
 764     hex_dump(stdout, pkt, pkt_len);
 765 #endif
 766     qemu_send_packet(s->vc, pkt, pkt_len);
 767 }
 768
 769 static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
 770 {
 771     SlirpState *s = vc->opaque;
 772
 773 #ifdef DEBUG_SLIRP
 774     printf("slirp input:\n");
 775     hex_dump(stdout, buf, size);
 776 #endif
 777     slirp_input(s->slirp, buf, size);
 778     return size;
 779 }
 780
 781 static void net_slirp_cleanup(VLANClientState *vc)
 782 {
 783     SlirpState *s = vc->opaque;
 784
 785     slirp_cleanup(s->slirp);
 786     slirp_smb_cleanup(s);
 787     QTAILQ_REMOVE(&slirp_stacks, s, entry);
 788     qemu_free(s);
 789 }
 790
 791 static int net_slirp_init(VLANState *vlan, const char *model,
 792                           const char *name, int restricted,
 793                           const char *vnetwork, const char *vhost,
 794                           const char *vhostname, const char *tftp_export,
 795                           const char *bootfile, const char *vdhcp_start,
 796                           const char *vnameserver, const char *smb_export,
 797                           const char *vsmbserver)
 798 {
 799     /* default settings according to historic slirp */
 800     struct in_addr net  = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
 801     struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
 802     struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
 803     struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
 804     struct in_addr dns  = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
 805 #ifndef _WIN32
 806     struct in_addr smbsrv = { .s_addr = 0 };
 807 #endif
 808     SlirpState *s;
 809     char buf[20];
 810     uint32_t addr;
 811     int shift;
 812     char *end;
 813     struct slirp_config_str *config;
 814
 815     if (!tftp_export) {
 816         tftp_export = legacy_tftp_prefix;
 817     }
 818     if (!bootfile) {
 819         bootfile = legacy_bootp_filename;
 820     }
 821
 822     if (vnetwork) {
 823         if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
 824             if (!inet_aton(vnetwork, &net)) {
 825                 return -1;
 826             }
 827             addr = ntohl(net.s_addr);
 828             if (!(addr & 0x80000000)) {
 829                 mask.s_addr = htonl(0xff000000); /* class A */
 830             } else if ((addr & 0xfff00000) == 0xac100000) {
 831                 mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
 832             } else if ((addr & 0xc0000000) == 0x80000000) {
 833                 mask.s_addr = htonl(0xffff0000); /* class B */
 834             } else if ((addr & 0xffff0000) == 0xc0a80000) {
 835                 mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
 836             } else if ((addr & 0xffff0000) == 0xc6120000) {
 837                 mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
 838             } else if ((addr & 0xe0000000) == 0xe0000000) {
 839                 mask.s_addr = htonl(0xffffff00); /* class C */
 840             } else {
 841                 mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
 842             }
 843         } else {
 844             if (!inet_aton(buf, &net)) {
 845                 return -1;
 846             }
 847             shift = strtol(vnetwork, &end, 10);
 848             if (*end != '\0') {
 849                 if (!inet_aton(vnetwork, &mask)) {
 850                     return -1;
 851                 }
 852             } else if (shift < 4 || shift > 32) {
 853                 return -1;
 854             } else {
 855                 mask.s_addr = htonl(0xffffffff << (32 - shift));
 856             }
 857         }
 858         net.s_addr &= mask.s_addr;
 859         host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
 860         dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
 861         dns.s_addr  = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
 862     }
 863
 864     if (vhost && !inet_aton(vhost, &host)) {
 865         return -1;
 866     }
 867     if ((host.s_addr & mask.s_addr) != net.s_addr) {
 868         return -1;
 869     }
 870
 871     if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
 872         return -1;
 873     }
 874     if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||
 875         dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
 876         return -1;
 877     }
 878
 879     if (vnameserver && !inet_aton(vnameserver, &dns)) {
 880         return -1;
 881     }
 882     if ((dns.s_addr & mask.s_addr) != net.s_addr ||
 883         dns.s_addr == host.s_addr) {
 884         return -1;
 885     }
 886
 887 #ifndef _WIN32
 888     if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
 889         return -1;
 890     }
 891 #endif
 892
 893     s = qemu_mallocz(sizeof(SlirpState));
 894     s->slirp = slirp_init(restricted, net, mask, host, vhostname,
 895                           tftp_export, bootfile, dhcp, dns, s);
 896     QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
 897
 898     for (config = slirp_configs; config; config = config->next) {
 899         if (config->flags & SLIRP_CFG_HOSTFWD) {
 900             if (slirp_hostfwd(s, config->str,
 901                               config->flags & SLIRP_CFG_LEGACY) < 0)
 902                 return -1;
 903         } else {
 904             if (slirp_guestfwd(s, config->str,
 905                                config->flags & SLIRP_CFG_LEGACY) < 0)
 906                 return -1;
 907         }
 908     }
 909 #ifndef _WIN32
 910     if (!smb_export) {
 911         smb_export = legacy_smb_export;
 912     }
 913     if (smb_export) {
 914         if (slirp_smb(s, smb_export, smbsrv) < 0)
 915             return -1;
 916     }
 917 #endif
 918
 919     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_SLIRP,
 920                                  vlan, NULL, model, name, NULL,
 921                                  slirp_receive, NULL, NULL,
 922                                  net_slirp_cleanup, s);
 923     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 924              "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');
 925     return 0;
 926 }
 927
 928 static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
 929                                 const char *stack)
 930 {
 931     VLANClientState *vc;
 932
 933     if (vlan) {
 934         vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
 935         if (!vc) {
 936             return NULL;
 937         }
 938         if (strcmp(vc->model, "user")) {
 939             monitor_printf(mon, "invalid device specified\n");
 940             return NULL;
 941         }
 942         return vc->opaque;
 943     } else {
 944         if (QTAILQ_EMPTY(&slirp_stacks)) {
 945             monitor_printf(mon, "user mode network stack not in use\n");
 946             return NULL;
 947         }
 948         return QTAILQ_FIRST(&slirp_stacks);
 949     }
 950 }
 951
 952 void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
 953 {
 954     struct in_addr host_addr = { .s_addr = INADDR_ANY };
 955     int host_port;
 956     char buf[256] = "";
 957     const char *src_str, *p;
 958     SlirpState *s;
 959     int is_udp = 0;
 960     int err;
 961     const char *arg1 = qdict_get_str(qdict, "arg1");
 962     const char *arg2 = qdict_get_try_str(qdict, "arg2");
 963     const char *arg3 = qdict_get_try_str(qdict, "arg3");
 964
 965     if (arg2) {
 966         s = slirp_lookup(mon, arg1, arg2);
 967         src_str = arg3;
 968     } else {
 969         s = slirp_lookup(mon, NULL, NULL);
 970         src_str = arg1;
 971     }
 972     if (!s) {
 973         return;
 974     }
 975
 976     if (!src_str || !src_str[0])
 977         goto fail_syntax;
 978
 979     p = src_str;
 980     get_str_sep(buf, sizeof(buf), &p, ':');
 981
 982     if (!strcmp(buf, "tcp") || buf[0] == '\0') {
 983         is_udp = 0;
 984     } else if (!strcmp(buf, "udp")) {
 985         is_udp = 1;
 986     } else {
 987         goto fail_syntax;
 988     }
 989
 990     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
 991         goto fail_syntax;
 992     }
 993     if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
 994         goto fail_syntax;
 995     }
 996
 997     host_port = atoi(p);
 998
 999     err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
1000                                host_addr, host_port);
1001
1002     monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
1003                    err ? "removed" : "not found");
1004     return;
1005
1006  fail_syntax:
1007     monitor_printf(mon, "invalid format\n");
1008 }
1009
1010 static int slirp_hostfwd(SlirpState *s, const char *redir_str,
1011                          int legacy_format)
1012 {
1013     struct in_addr host_addr = { .s_addr = INADDR_ANY };
1014     struct in_addr guest_addr = { .s_addr = 0 };
1015     int host_port, guest_port;
1016     const char *p;
1017     char buf[256];
1018     int is_udp;
1019     char *end;
1020
1021     p = redir_str;
1022     if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1023         goto fail_syntax;
1024     }
1025     if (!strcmp(buf, "tcp") || buf[0] == '\0') {
1026         is_udp = 0;
1027     } else if (!strcmp(buf, "udp")) {
1028         is_udp = 1;
1029     } else {
1030         goto fail_syntax;
1031     }
1032
1033     if (!legacy_format) {
1034         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1035             goto fail_syntax;
1036         }
1037         if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
1038             goto fail_syntax;
1039         }
1040     }
1041
1042     if (get_str_sep(buf, sizeof(buf), &p, legacy_format ? ':' : '-') < 0) {
1043         goto fail_syntax;
1044     }
1045     host_port = strtol(buf, &end, 0);
1046     if (*end != '\0' || host_port < 1 || host_port > 65535) {
1047         goto fail_syntax;
1048     }
1049
1050     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1051         goto fail_syntax;
1052     }
1053     if (buf[0] != '\0' && !inet_aton(buf, &guest_addr)) {
1054         goto fail_syntax;
1055     }
1056
1057     guest_port = strtol(p, &end, 0);
1058     if (*end != '\0' || guest_port < 1 || guest_port > 65535) {
1059         goto fail_syntax;
1060     }
1061
1062     if (slirp_add_hostfwd(s->slirp, is_udp, host_addr, host_port, guest_addr,
1063                           guest_port) < 0) {
1064         qemu_error("could not set up host forwarding rule '%s'\n",
1065                    redir_str);
1066         return -1;
1067     }
1068     return 0;
1069
1070  fail_syntax:
1071     qemu_error("invalid host forwarding rule '%s'\n", redir_str);
1072     return -1;
1073 }
1074
1075 void net_slirp_hostfwd_add(Monitor *mon, const QDict *qdict)
1076 {
1077     const char *redir_str;
1078     SlirpState *s;
1079     const char *arg1 = qdict_get_str(qdict, "arg1");
1080     const char *arg2 = qdict_get_try_str(qdict, "arg2");
1081     const char *arg3 = qdict_get_try_str(qdict, "arg3");
1082
1083     if (arg2) {
1084         s = slirp_lookup(mon, arg1, arg2);
1085         redir_str = arg3;
1086     } else {
1087         s = slirp_lookup(mon, NULL, NULL);
1088         redir_str = arg1;
1089     }
1090     if (s) {
1091         slirp_hostfwd(s, redir_str, 0);
1092     }
1093
1094 }
1095
1096 int net_slirp_redir(const char *redir_str)
1097 {
1098     struct slirp_config_str *config;
1099
1100     if (QTAILQ_EMPTY(&slirp_stacks)) {
1101         config = qemu_malloc(sizeof(*config));
1102         pstrcpy(config->str, sizeof(config->str), redir_str);
1103         config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
1104         config->next = slirp_configs;
1105         slirp_configs = config;
1106         return 0;
1107     }
1108
1109     return slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), redir_str, 1);
1110 }
1111
1112 #ifndef _WIN32
1113
1114 /* automatic user mode samba server configuration */
1115 static void slirp_smb_cleanup(SlirpState *s)
1116 {
1117     char cmd[128];
1118
1119     if (s->smb_dir[0] != '\0') {
1120         snprintf(cmd, sizeof(cmd), "rm -rf %s", s->smb_dir);
1121         system(cmd);
1122         s->smb_dir[0] = '\0';
1123     }
1124 }
1125
1126 static int slirp_smb(SlirpState* s, const char *exported_dir,
1127                      struct in_addr vserver_addr)
1128 {
1129     static int instance;
1130     char smb_conf[128];
1131     char smb_cmdline[128];
1132     FILE *f;
1133
1134     snprintf(s->smb_dir, sizeof(s->smb_dir), "/tmp/qemu-smb.%ld-%d",
1135              (long)getpid(), instance++);
1136     if (mkdir(s->smb_dir, 0700) < 0) {
1137         qemu_error("could not create samba server dir '%s'\n", s->smb_dir);
1138         return -1;
1139     }
1140     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", s->smb_dir, "smb.conf");
1141
1142     f = fopen(smb_conf, "w");
1143     if (!f) {
1144         slirp_smb_cleanup(s);
1145         qemu_error("could not create samba server configuration file '%s'\n",
1146                    smb_conf);
1147         return -1;
1148     }
1149     fprintf(f,
1150             "[global]\n"
1151             "private dir=%s\n"
1152             "smb ports=0\n"
1153             "socket address=127.0.0.1\n"
1154             "pid directory=%s\n"
1155             "lock directory=%s\n"
1156             "log file=%s/log.smbd\n"
1157             "smb passwd file=%s/smbpasswd\n"
1158             "security = share\n"
1159             "[qemu]\n"
1160             "path=%s\n"
1161             "read only=no\n"
1162             "guest ok=yes\n",
1163             s->smb_dir,
1164             s->smb_dir,
1165             s->smb_dir,
1166             s->smb_dir,
1167             s->smb_dir,
1168             exported_dir
1169             );
1170     fclose(f);
1171
1172     snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
1173              SMBD_COMMAND, smb_conf);
1174
1175     if (slirp_add_exec(s->slirp, 0, smb_cmdline, &vserver_addr, 139) < 0) {
1176         slirp_smb_cleanup(s);
1177         qemu_error("conflicting/invalid smbserver address\n");
1178         return -1;
1179     }
1180     return 0;
1181 }
1182
1183 /* automatic user mode samba server configuration (legacy interface) */
1184 int net_slirp_smb(const char *exported_dir)
1185 {
1186     struct in_addr vserver_addr = { .s_addr = 0 };
1187
1188     if (legacy_smb_export) {
1189         fprintf(stderr, "-smb given twice\n");
1190         return -1;
1191     }
1192     legacy_smb_export = exported_dir;
1193     if (!QTAILQ_EMPTY(&slirp_stacks)) {
1194         return slirp_smb(QTAILQ_FIRST(&slirp_stacks), exported_dir,
1195                          vserver_addr);
1196     }
1197     return 0;
1198 }
1199
1200 #endif /* !defined(_WIN32) */
1201
1202 struct GuestFwd {
1203     CharDriverState *hd;
1204     struct in_addr server;
1205     int port;
1206     Slirp *slirp;
1207 };
1208
1209 static int guestfwd_can_read(void *opaque)
1210 {
1211     struct GuestFwd *fwd = opaque;
1212     return slirp_socket_can_recv(fwd->slirp, fwd->server, fwd->port);
1213 }
1214
1215 static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
1216 {
1217     struct GuestFwd *fwd = opaque;
1218     slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
1219 }
1220
1221 static int slirp_guestfwd(SlirpState *s, const char *config_str,
1222                           int legacy_format)
1223 {
1224     struct in_addr server = { .s_addr = 0 };
1225     struct GuestFwd *fwd;
1226     const char *p;
1227     char buf[128];
1228     char *end;
1229     int port;
1230
1231     p = config_str;
1232     if (legacy_format) {
1233         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1234             goto fail_syntax;
1235         }
1236     } else {
1237         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1238             goto fail_syntax;
1239         }
1240         if (strcmp(buf, "tcp") && buf[0] != '\0') {
1241             goto fail_syntax;
1242         }
1243         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1244             goto fail_syntax;
1245         }
1246         if (buf[0] != '\0' && !inet_aton(buf, &server)) {
1247             goto fail_syntax;
1248         }
1249         if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
1250             goto fail_syntax;
1251         }
1252     }
1253     port = strtol(buf, &end, 10);
1254     if (*end != '\0' || port < 1 || port > 65535) {
1255         goto fail_syntax;
1256     }
1257
1258     fwd = qemu_malloc(sizeof(struct GuestFwd));
1259     snprintf(buf, sizeof(buf), "guestfwd.tcp:%d", port);
1260     fwd->hd = qemu_chr_open(buf, p, NULL);
1261     if (!fwd->hd) {
1262         qemu_error("could not open guest forwarding device '%s'\n", buf);
1263         qemu_free(fwd);
1264         return -1;
1265     }
1266
1267     if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) {
1268         qemu_error("conflicting/invalid host:port in guest forwarding "
1269                    "rule '%s'\n", config_str);
1270         qemu_free(fwd);
1271         return -1;
1272     }
1273     fwd->server = server;
1274     fwd->port = port;
1275     fwd->slirp = s->slirp;
1276
1277     qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
1278                           NULL, fwd);
1279     return 0;
1280
1281  fail_syntax:
1282     qemu_error("invalid guest forwarding rule '%s'\n", config_str);
1283     return -1;
1284 }
1285
1286 void do_info_usernet(Monitor *mon)
1287 {
1288     SlirpState *s;
1289
1290     QTAILQ_FOREACH(s, &slirp_stacks, entry) {
1291         monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
1292         slirp_connection_info(s->slirp, mon);
1293     }
1294 }
1295
1296 #endif /* CONFIG_SLIRP */
1297
1298 #if defined(_WIN32)
1299 int tap_has_vnet_hdr(VLANClientState *vc)
1300 {
1301     return 0;
1302 }
1303 void tap_using_vnet_hdr(VLANClientState *vc, int using_vnet_hdr)
1304 {
1305 }
1306 void tap_set_offload(VLANClientState *vc, int csum, int tso4, int tso6, int ecn, int ufo)
1307 {
1308 }
1309 #else /* !defined(_WIN32) */
1310
1311 /* Maximum GSO packet size (64k) plus plenty of room for
1312  * the ethernet and virtio_net headers
1313  */
1314 #define TAP_BUFSIZE (4096 + 65536)
1315
1316 typedef struct TAPState {
1317     VLANClientState *vc;
1318     int fd;
1319     char down_script[1024];
1320     char down_script_arg[128];
1321     uint8_t buf[TAP_BUFSIZE];
1322     unsigned int read_poll : 1;
1323     unsigned int write_poll : 1;
1324     unsigned int has_vnet_hdr : 1;
1325     unsigned int using_vnet_hdr : 1;
1326     unsigned int has_ufo: 1;
1327 } TAPState;
1328
1329 static int launch_script(const char *setup_script, const char *ifname, int fd);
1330
1331 static int tap_can_send(void *opaque);
1332 static void tap_send(void *opaque);
1333 static void tap_writable(void *opaque);
1334
1335 static void tap_update_fd_handler(TAPState *s)
1336 {
1337     qemu_set_fd_handler2(s->fd,
1338                          s->read_poll  ? tap_can_send : NULL,
1339                          s->read_poll  ? tap_send     : NULL,
1340                          s->write_poll ? tap_writable : NULL,
1341                          s);
1342 }
1343
1344 static void tap_read_poll(TAPState *s, int enable)
1345 {
1346     s->read_poll = !!enable;
1347     tap_update_fd_handler(s);
1348 }
1349
1350 static void tap_write_poll(TAPState *s, int enable)
1351 {
1352     s->write_poll = !!enable;
1353     tap_update_fd_handler(s);
1354 }
1355
1356 static void tap_writable(void *opaque)
1357 {
1358     TAPState *s = opaque;
1359
1360     tap_write_poll(s, 0);
1361
1362     qemu_flush_queued_packets(s->vc);
1363 }
1364
1365 static ssize_t tap_write_packet(TAPState *s, const struct iovec *iov, int iovcnt)
1366 {
1367     ssize_t len;
1368
1369     do {
1370         len = writev(s->fd, iov, iovcnt);
1371     } while (len == -1 && errno == EINTR);
1372
1373     if (len == -1 && errno == EAGAIN) {
1374         tap_write_poll(s, 1);
1375         return 0;
1376     }
1377
1378     return len;
1379 }
1380
1381 static ssize_t tap_receive_iov(VLANClientState *vc, const struct iovec *iov,
1382                                int iovcnt)
1383 {
1384     TAPState *s = vc->opaque;
1385     const struct iovec *iovp = iov;
1386     struct iovec iov_copy[iovcnt + 1];
1387     struct virtio_net_hdr hdr = { 0, };
1388
1389     if (s->has_vnet_hdr && !s->using_vnet_hdr) {
1390         iov_copy[0].iov_base = &hdr;
1391         iov_copy[0].iov_len =  sizeof(hdr);
1392         memcpy(&iov_copy[1], iov, iovcnt * sizeof(*iov));
1393         iovp = iov_copy;
1394         iovcnt++;
1395     }
1396
1397     return tap_write_packet(s, iovp, iovcnt);
1398 }
1399
1400 static ssize_t tap_receive_raw(VLANClientState *vc, const uint8_t *buf, size_t size)
1401 {
1402     TAPState *s = vc->opaque;
1403     struct iovec iov[2];
1404     int iovcnt = 0;
1405     struct virtio_net_hdr hdr = { 0, };
1406
1407     if (s->has_vnet_hdr) {
1408         iov[iovcnt].iov_base = &hdr;
1409         iov[iovcnt].iov_len  = sizeof(hdr);
1410         iovcnt++;
1411     }
1412
1413     iov[iovcnt].iov_base = (char *)buf;
1414     iov[iovcnt].iov_len  = size;
1415     iovcnt++;
1416
1417     return tap_write_packet(s, iov, iovcnt);
1418 }
1419
1420 static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1421 {
1422     TAPState *s = vc->opaque;
1423     struct iovec iov[1];
1424
1425     if (s->has_vnet_hdr && !s->using_vnet_hdr) {
1426         return tap_receive_raw(vc, buf, size);
1427     }
1428
1429     iov[0].iov_base = (char *)buf;
1430     iov[0].iov_len  = size;
1431
1432     return tap_write_packet(s, iov, 1);
1433 }
1434
1435 static int tap_can_send(void *opaque)
1436 {
1437     TAPState *s = opaque;
1438
1439     return qemu_can_send_packet(s->vc);
1440 }
1441
1442 #ifdef __sun__
1443 static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1444 {
1445     struct strbuf sbuf;
1446     int f = 0;
1447
1448     sbuf.maxlen = maxlen;
1449     sbuf.buf = (char *)buf;
1450
1451     return getmsg(tapfd, NULL, &sbuf, &f) >= 0 ? sbuf.len : -1;
1452 }
1453 #else
1454 static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1455 {
1456     return read(tapfd, buf, maxlen);
1457 }
1458 #endif
1459
1460 static void tap_send_completed(VLANClientState *vc, ssize_t len)
1461 {
1462     TAPState *s = vc->opaque;
1463     tap_read_poll(s, 1);
1464 }
1465
1466 static void tap_send(void *opaque)
1467 {
1468     TAPState *s = opaque;
1469     int size;
1470
1471     do {
1472         uint8_t *buf = s->buf;
1473
1474         size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
1475         if (size <= 0) {
1476             break;
1477         }
1478
1479         if (s->has_vnet_hdr && !s->using_vnet_hdr) {
1480             buf  += sizeof(struct virtio_net_hdr);
1481             size -= sizeof(struct virtio_net_hdr);
1482         }
1483
1484         size = qemu_send_packet_async(s->vc, buf, size, tap_send_completed);
1485         if (size == 0) {
1486             tap_read_poll(s, 0);
1487         }
1488     } while (size > 0);
1489 }
1490
1491 /* sndbuf should be set to a value lower than the tx queue
1492  * capacity of any destination network interface.
1493  * Ethernet NICs generally have txqueuelen=1000, so 1Mb is
1494  * a good default, given a 1500 byte MTU.
1495  */
1496 #define TAP_DEFAULT_SNDBUF 1024*1024
1497
1498 static int tap_set_sndbuf(TAPState *s, QemuOpts *opts)
1499 {
1500     int sndbuf;
1501
1502     sndbuf = qemu_opt_get_size(opts, "sndbuf", TAP_DEFAULT_SNDBUF);
1503     if (!sndbuf) {
1504         sndbuf = INT_MAX;
1505     }
1506
1507     if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1 && qemu_opt_get(opts, "sndbuf")) {
1508         qemu_error("TUNSETSNDBUF ioctl failed: %s\n", strerror(errno));
1509         return -1;
1510     }
1511     return 0;
1512 }
1513
1514 int tap_has_vnet_hdr(VLANClientState *vc)
1515 {
1516     TAPState *s = vc->opaque;
1517
1518     assert(vc->type == NET_CLIENT_TYPE_TAP);
1519
1520     return s->has_vnet_hdr;
1521 }
1522
1523 void tap_using_vnet_hdr(VLANClientState *vc, int using_vnet_hdr)
1524 {
1525     TAPState *s = vc->opaque;
1526
1527     using_vnet_hdr = using_vnet_hdr != 0;
1528
1529     assert(vc->type == NET_CLIENT_TYPE_TAP);
1530     assert(s->has_vnet_hdr == using_vnet_hdr);
1531
1532     s->using_vnet_hdr = using_vnet_hdr;
1533 }
1534
1535 static int tap_probe_vnet_hdr(int fd)
1536 {
1537     struct ifreq ifr;
1538
1539     if (ioctl(fd, TUNGETIFF, &ifr) != 0) {
1540         qemu_error("TUNGETIFF ioctl() failed: %s\n", strerror(errno));
1541         return 0;
1542     }
1543
1544     return ifr.ifr_flags & IFF_VNET_HDR;
1545 }
1546
1547 int tap_has_ufo(void *opaque)
1548 {
1549     VLANClientState *vc = opaque;
1550     TAPState *s = vc->opaque;
1551
1552     return s ? s->has_ufo : 0;
1553 }
1554
1555 void tap_set_offload(VLANClientState *vc, int csum, int tso4, int tso6, int ecn, int ufo)
1556 {
1557     TAPState *s = vc->opaque;
1558     unsigned int offload = 0;
1559
1560     if (csum) {
1561         offload |= TUN_F_CSUM;
1562         if (tso4)
1563             offload |= TUN_F_TSO4;
1564         if (tso6)
1565             offload |= TUN_F_TSO6;
1566         if ((tso4 || tso6) && ecn)
1567             offload |= TUN_F_TSO_ECN;
1568         if (ufo)
1569             offload |= TUN_F_UFO;
1570     }
1571
1572     if (ioctl(s->fd, TUNSETOFFLOAD, offload) != 0) {
1573         offload &= ~TUN_F_UFO;
1574         if (ioctl(s->fd, TUNSETOFFLOAD, offload) != 0) {
1575             fprintf(stderr, "TUNSETOFFLOAD ioctl() failed: %s\n",
1576                     strerror(errno));
1577         }
1578     }
1579 }
1580
1581 static void tap_cleanup(VLANClientState *vc)
1582 {
1583     TAPState *s = vc->opaque;
1584
1585     qemu_purge_queued_packets(vc);
1586
1587     if (s->down_script[0])
1588         launch_script(s->down_script, s->down_script_arg, s->fd);
1589
1590     tap_read_poll(s, 0);
1591     tap_write_poll(s, 0);
1592     close(s->fd);
1593     qemu_free(s);
1594 }
1595
1596 /* fd support */
1597
1598 static TAPState *net_tap_fd_init(VLANState *vlan,
1599                                  const char *model,
1600                                  const char *name,
1601                                  int fd,
1602                                  int vnet_hdr)
1603 {
1604     TAPState *s;
1605     unsigned int offload;
1606
1607     s = qemu_mallocz(sizeof(TAPState));
1608     s->fd = fd;
1609     s->has_vnet_hdr = vnet_hdr != 0;
1610     s->using_vnet_hdr = 0;
1611     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_TAP,
1612                                  vlan, NULL, model, name, NULL,
1613                                  tap_receive, tap_receive_raw,
1614                                  tap_receive_iov, tap_cleanup, s);
1615
1616     s->has_ufo = 0;
1617     /* Check if tap supports UFO */
1618     offload = TUN_F_CSUM | TUN_F_UFO;
1619     if (ioctl(s->fd, TUNSETOFFLOAD, offload) == 0)
1620        s->has_ufo = 1;
1621
1622     tap_set_offload(s->vc, 0, 0, 0, 0, 0);
1623
1624     tap_read_poll(s, 1);
1625     return s;
1626 }
1627
1628 #if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__)
1629 static int tap_open(char *ifname, int ifname_size,
1630                     int *vnet_hdr, int vnet_hdr_required)
1631 {
1632     int fd;
1633     char *dev;
1634     struct stat s;
1635
1636     TFR(fd = open("/dev/tap", O_RDWR));
1637     if (fd < 0) {
1638         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1639         return -1;
1640     }
1641
1642     fstat(fd, &s);
1643     dev = devname(s.st_rdev, S_IFCHR);
1644     pstrcpy(ifname, ifname_size, dev);
1645
1646     fcntl(fd, F_SETFL, O_NONBLOCK);
1647     return fd;
1648 }
1649 #elif defined(__sun__)
1650 #define TUNNEWPPA       (('T'<<16) | 0x0001)
1651 /*
1652  * Allocate TAP device, returns opened fd.
1653  * Stores dev name in the first arg(must be large enough).
1654  */
1655 static int tap_alloc(char *dev, size_t dev_size)
1656 {
1657     int tap_fd, if_fd, ppa = -1;
1658     static int ip_fd = 0;
1659     char *ptr;
1660
1661     static int arp_fd = 0;
1662     int ip_muxid, arp_muxid;
1663     struct strioctl  strioc_if, strioc_ppa;
1664     int link_type = I_PLINK;;
1665     struct lifreq ifr;
1666     char actual_name[32] = "";
1667
1668     memset(&ifr, 0x0, sizeof(ifr));
1669
1670     if( *dev ){
1671        ptr = dev;
1672        while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
1673        ppa = atoi(ptr);
1674     }
1675
1676     /* Check if IP device was opened */
1677     if( ip_fd )
1678        close(ip_fd);
1679
1680     TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
1681     if (ip_fd < 0) {
1682        syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
1683        return -1;
1684     }
1685
1686     TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
1687     if (tap_fd < 0) {
1688        syslog(LOG_ERR, "Can't open /dev/tap");
1689        return -1;
1690     }
1691
1692     /* Assign a new PPA and get its unit number. */
1693     strioc_ppa.ic_cmd = TUNNEWPPA;
1694     strioc_ppa.ic_timout = 0;
1695     strioc_ppa.ic_len = sizeof(ppa);
1696     strioc_ppa.ic_dp = (char *)&ppa;
1697     if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
1698        syslog (LOG_ERR, "Can't assign new interface");
1699
1700     TFR(if_fd = open("/dev/tap", O_RDWR, 0));
1701     if (if_fd < 0) {
1702        syslog(LOG_ERR, "Can't open /dev/tap (2)");
1703        return -1;
1704     }
1705     if(ioctl(if_fd, I_PUSH, "ip") < 0){
1706        syslog(LOG_ERR, "Can't push IP module");
1707        return -1;
1708     }
1709
1710     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
1711         syslog(LOG_ERR, "Can't get flags\n");
1712
1713     snprintf (actual_name, 32, "tap%d", ppa);
1714     pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1715
1716     ifr.lifr_ppa = ppa;
1717     /* Assign ppa according to the unit number returned by tun device */
1718
1719     if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
1720         syslog (LOG_ERR, "Can't set PPA %d", ppa);
1721     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
1722         syslog (LOG_ERR, "Can't get flags\n");
1723     /* Push arp module to if_fd */
1724     if (ioctl (if_fd, I_PUSH, "arp") < 0)
1725         syslog (LOG_ERR, "Can't push ARP module (2)");
1726
1727     /* Push arp module to ip_fd */
1728     if (ioctl (ip_fd, I_POP, NULL) < 0)
1729         syslog (LOG_ERR, "I_POP failed\n");
1730     if (ioctl (ip_fd, I_PUSH, "arp") < 0)
1731         syslog (LOG_ERR, "Can't push ARP module (3)\n");
1732     /* Open arp_fd */
1733     TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
1734     if (arp_fd < 0)
1735        syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
1736
1737     /* Set ifname to arp */
1738     strioc_if.ic_cmd = SIOCSLIFNAME;
1739     strioc_if.ic_timout = 0;
1740     strioc_if.ic_len = sizeof(ifr);
1741     strioc_if.ic_dp = (char *)&ifr;
1742     if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
1743         syslog (LOG_ERR, "Can't set ifname to arp\n");
1744     }
1745
1746     if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
1747        syslog(LOG_ERR, "Can't link TAP device to IP");
1748        return -1;
1749     }
1750
1751     if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
1752         syslog (LOG_ERR, "Can't link TAP device to ARP");
1753
1754     close (if_fd);
1755
1756     memset(&ifr, 0x0, sizeof(ifr));
1757     pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1758     ifr.lifr_ip_muxid  = ip_muxid;
1759     ifr.lifr_arp_muxid = arp_muxid;
1760
1761     if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
1762     {
1763       ioctl (ip_fd, I_PUNLINK , arp_muxid);
1764       ioctl (ip_fd, I_PUNLINK, ip_muxid);
1765       syslog (LOG_ERR, "Can't set multiplexor id");
1766     }
1767
1768     snprintf(dev, dev_size, "tap%d", ppa);
1769     return tap_fd;
1770 }
1771
1772 static int tap_open(char *ifname, int ifname_size,
1773                     int *vnet_hdr, int vnet_hdr_required)
1774 {
1775     char  dev[10]="";
1776     int fd;
1777     if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
1778        fprintf(stderr, "Cannot allocate TAP device\n");
1779        return -1;
1780     }
1781     pstrcpy(ifname, ifname_size, dev);
1782     fcntl(fd, F_SETFL, O_NONBLOCK);
1783     return fd;
1784 }
1785 #elif defined (_AIX)
1786 static int tap_open(char *ifname, int ifname_size,
1787                     int *vnet_hdr, int vnet_hdr_required)
1788 {
1789     fprintf (stderr, "no tap on AIX\n");
1790     return -1;
1791 }
1792 #else
1793 static int tap_open(char *ifname, int ifname_size,
1794                     int *vnet_hdr, int vnet_hdr_required)
1795 {
1796     struct ifreq ifr;
1797     int fd, ret;
1798
1799     TFR(fd = open("/dev/net/tun", O_RDWR));
1800     if (fd < 0) {
1801         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1802         return -1;
1803     }
1804     memset(&ifr, 0, sizeof(ifr));
1805     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1806
1807     if (*vnet_hdr) {
1808         unsigned int features;
1809
1810         if (ioctl(fd, TUNGETFEATURES, &features) == 0 &&
1811             features & IFF_VNET_HDR) {
1812             *vnet_hdr = 1;
1813             ifr.ifr_flags |= IFF_VNET_HDR;
1814         }
1815
1816         if (vnet_hdr_required && !*vnet_hdr) {
1817             qemu_error("vnet_hdr=1 requested, but no kernel "
1818                        "support for IFF_VNET_HDR available");
1819             close(fd);
1820             return -1;
1821         }
1822     }
1823
1824     if (ifname[0] != '\0')
1825         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
1826     else
1827         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
1828     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1829     if (ret != 0) {
1830         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1831         close(fd);
1832         return -1;
1833     }
1834     pstrcpy(ifname, ifname_size, ifr.ifr_name);
1835     fcntl(fd, F_SETFL, O_NONBLOCK);
1836     return fd;
1837 }
1838 #endif
1839
1840 static int launch_script(const char *setup_script, const char *ifname, int fd)
1841 {
1842     sigset_t oldmask, mask;
1843     int pid, status;
1844     char *args[3];
1845     char **parg;
1846
1847     sigemptyset(&mask);
1848     sigaddset(&mask, SIGCHLD);
1849     sigprocmask(SIG_BLOCK, &mask, &oldmask);
1850
1851     /* try to launch network script */
1852     pid = fork();
1853     if (pid == 0) {
1854         int open_max = sysconf(_SC_OPEN_MAX), i;
1855
1856         for (i = 0; i < open_max; i++) {
1857             if (i != STDIN_FILENO &&
1858                 i != STDOUT_FILENO &&
1859                 i != STDERR_FILENO &&
1860                 i != fd) {
1861                 close(i);
1862             }
1863         }
1864         parg = args;
1865         *parg++ = (char *)setup_script;
1866         *parg++ = (char *)ifname;
1867         *parg++ = NULL;
1868         execv(setup_script, args);
1869         _exit(1);
1870     } else if (pid > 0) {
1871         while (waitpid(pid, &status, 0) != pid) {
1872             /* loop */
1873         }
1874         sigprocmask(SIG_SETMASK, &oldmask, NULL);
1875
1876         if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
1877             return 0;
1878         }
1879     }
1880     fprintf(stderr, "%s: could not launch network script\n", setup_script);
1881     return -1;
1882 }
1883
1884 static int net_tap_init(QemuOpts *opts, int *vnet_hdr)
1885 {
1886     int fd, vnet_hdr_required;
1887     char ifname[128] = {0,};
1888     const char *setup_script;
1889
1890     if (qemu_opt_get(opts, "ifname")) {
1891         pstrcpy(ifname, sizeof(ifname), qemu_opt_get(opts, "ifname"));
1892     }
1893
1894     *vnet_hdr = qemu_opt_get_bool(opts, "vnet_hdr", 1);
1895     if (qemu_opt_get(opts, "vnet_hdr")) {
1896         vnet_hdr_required = *vnet_hdr;
1897     } else {
1898         vnet_hdr_required = 0;
1899     }
1900
1901     TFR(fd = tap_open(ifname, sizeof(ifname), vnet_hdr, vnet_hdr_required));
1902     if (fd < 0) {
1903         return -1;
1904     }
1905
1906     setup_script = qemu_opt_get(opts, "script");
1907     if (setup_script &&
1908         setup_script[0] != '\0' &&
1909         strcmp(setup_script, "no") != 0 &&
1910         launch_script(setup_script, ifname, fd)) {
1911         close(fd);
1912         return -1;
1913     }
1914
1915     qemu_opt_set(opts, "ifname", ifname);
1916
1917     return fd;
1918 }
1919
1920 #endif /* !_WIN32 */
1921
1922 #if defined(CONFIG_VDE)
1923 typedef struct VDEState {
1924     VLANClientState *vc;
1925     VDECONN *vde;
1926 } VDEState;
1927
1928 static void vde_to_qemu(void *opaque)
1929 {
1930     VDEState *s = opaque;
1931     uint8_t buf[4096];
1932     int size;
1933
1934     size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
1935     if (size > 0) {
1936         qemu_send_packet(s->vc, buf, size);
1937     }
1938 }
1939
1940 static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1941 {
1942     VDEState *s = vc->opaque;
1943     ssize_t ret;
1944
1945     do {
1946       ret = vde_send(s->vde, (const char *)buf, size, 0);
1947     } while (ret < 0 && errno == EINTR);
1948
1949     return ret;
1950 }
1951
1952 static void vde_cleanup(VLANClientState *vc)
1953 {
1954     VDEState *s = vc->opaque;
1955     qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
1956     vde_close(s->vde);
1957     qemu_free(s);
1958 }
1959
1960 static int net_vde_init(VLANState *vlan, const char *model,
1961                         const char *name, const char *sock,
1962                         int port, const char *group, int mode)
1963 {
1964     VDEState *s;
1965     char *init_group = (char *)group;
1966     char *init_sock = (char *)sock;
1967
1968     struct vde_open_args args = {
1969         .port = port,
1970         .group = init_group,
1971         .mode = mode,
1972     };
1973
1974     s = qemu_mallocz(sizeof(VDEState));
1975     s->vde = vde_open(init_sock, (char *)"QEMU", &args);
1976     if (!s->vde){
1977         free(s);
1978         return -1;
1979     }
1980     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_VDE,
1981                                  vlan, NULL, model, name, NULL,
1982                                  vde_receive, NULL, NULL,
1983                                  vde_cleanup, s);
1984     qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
1985     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
1986              sock, vde_datafd(s->vde));
1987     return 0;
1988 }
1989 #endif
1990
1991 /* network connection */
1992 typedef struct NetSocketState {
1993     VLANClientState *vc;
1994     int fd;
1995     int state; /* 0 = getting length, 1 = getting data */
1996     unsigned int index;
1997     unsigned int packet_len;
1998     uint8_t buf[4096];
1999     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
2000 } NetSocketState;
2001
2002 typedef struct NetSocketListenState {
2003     VLANState *vlan;
2004     char *model;
2005     char *name;
2006     int fd;
2007 } NetSocketListenState;
2008
2009 /* XXX: we consider we can send the whole packet without blocking */
2010 static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
2011 {
2012     NetSocketState *s = vc->opaque;
2013     uint32_t len;
2014     len = htonl(size);
2015
2016     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
2017     return send_all(s->fd, buf, size);
2018 }
2019
2020 static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
2021 {
2022     NetSocketState *s = vc->opaque;
2023
2024     return sendto(s->fd, (const void *)buf, size, 0,
2025                   (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
2026 }
2027
2028 static void net_socket_send(void *opaque)
2029 {
2030     NetSocketState *s = opaque;
2031     int size, err;
2032     unsigned l;
2033     uint8_t buf1[4096];
2034     const uint8_t *buf;
2035
2036     size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
2037     if (size < 0) {
2038         err = socket_error();
2039         if (err != EWOULDBLOCK)
2040             goto eoc;
2041     } else if (size == 0) {
2042         /* end of connection */
2043     eoc:
2044         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2045         closesocket(s->fd);
2046         return;
2047     }
2048     buf = buf1;
2049     while (size > 0) {
2050         /* reassemble a packet from the network */
2051         switch(s->state) {
2052         case 0:
2053             l = 4 - s->index;
2054             if (l > size)
2055                 l = size;
2056             memcpy(s->buf + s->index, buf, l);
2057             buf += l;
2058             size -= l;
2059             s->index += l;
2060             if (s->index == 4) {
2061                 /* got length */
2062                 s->packet_len = ntohl(*(uint32_t *)s->buf);
2063                 s->index = 0;
2064                 s->state = 1;
2065             }
2066             break;
2067         case 1:
2068             l = s->packet_len - s->index;
2069             if (l > size)
2070                 l = size;
2071             if (s->index + l <= sizeof(s->buf)) {
2072                 memcpy(s->buf + s->index, buf, l);
2073             } else {
2074                 fprintf(stderr, "serious error: oversized packet received,"
2075                     "connection terminated.\n");
2076                 s->state = 0;
2077                 goto eoc;
2078             }
2079
2080             s->index += l;
2081             buf += l;
2082             size -= l;
2083             if (s->index >= s->packet_len) {
2084                 qemu_send_packet(s->vc, s->buf, s->packet_len);
2085                 s->index = 0;
2086                 s->state = 0;
2087             }
2088             break;
2089         }
2090     }
2091 }
2092
2093 static void net_socket_send_dgram(void *opaque)
2094 {
2095     NetSocketState *s = opaque;
2096     int size;
2097
2098     size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
2099     if (size < 0)
2100         return;
2101     if (size == 0) {
2102         /* end of connection */
2103         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2104         return;
2105     }
2106     qemu_send_packet(s->vc, s->buf, size);
2107 }
2108
2109 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
2110 {
2111     struct ip_mreq imr;
2112     int fd;
2113     int val, ret;
2114     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
2115         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
2116                 inet_ntoa(mcastaddr->sin_addr),
2117                 (int)ntohl(mcastaddr->sin_addr.s_addr));
2118         return -1;
2119
2120     }
2121     fd = socket(PF_INET, SOCK_DGRAM, 0);
2122     if (fd < 0) {
2123         perror("socket(PF_INET, SOCK_DGRAM)");
2124         return -1;
2125     }
2126
2127     val = 1;
2128     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2129                    (const char *)&val, sizeof(val));
2130     if (ret < 0) {
2131         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
2132         goto fail;
2133     }
2134
2135     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
2136     if (ret < 0) {
2137         perror("bind");
2138         goto fail;
2139     }
2140
2141     /* Add host to multicast group */
2142     imr.imr_multiaddr = mcastaddr->sin_addr;
2143     imr.imr_interface.s_addr = htonl(INADDR_ANY);
2144
2145     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
2146                      (const char *)&imr, sizeof(struct ip_mreq));
2147     if (ret < 0) {
2148         perror("setsockopt(IP_ADD_MEMBERSHIP)");
2149         goto fail;
2150     }
2151
2152     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
2153     val = 1;
2154     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
2155                    (const char *)&val, sizeof(val));
2156     if (ret < 0) {
2157         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
2158         goto fail;
2159     }
2160
2161     socket_set_nonblock(fd);
2162     return fd;
2163 fail:
2164     if (fd >= 0)
2165         closesocket(fd);
2166     return -1;
2167 }
2168
2169 static void net_socket_cleanup(VLANClientState *vc)
2170 {
2171     NetSocketState *s = vc->opaque;
2172     qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2173     close(s->fd);
2174     qemu_free(s);
2175 }
2176
2177 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
2178                                                 const char *model,
2179                                                 const char *name,
2180                                                 int fd, int is_connected)
2181 {
2182     struct sockaddr_in saddr;
2183     int newfd;
2184     socklen_t saddr_len;
2185     NetSocketState *s;
2186
2187     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
2188      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
2189      * by ONLY ONE process: we must "clone" this dgram socket --jjo
2190      */
2191
2192     if (is_connected) {
2193         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
2194             /* must be bound */
2195             if (saddr.sin_addr.s_addr==0) {
2196                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
2197                         fd);
2198                 return NULL;
2199             }
2200             /* clone dgram socket */
2201             newfd = net_socket_mcast_create(&saddr);
2202             if (newfd < 0) {
2203                 /* error already reported by net_socket_mcast_create() */
2204                 close(fd);
2205                 return NULL;
2206             }
2207             /* clone newfd to fd, close newfd */
2208             dup2(newfd, fd);
2209             close(newfd);
2210
2211         } else {
2212             fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
2213                     fd, strerror(errno));
2214             return NULL;
2215         }
2216     }
2217
2218     s = qemu_mallocz(sizeof(NetSocketState));
2219     s->fd = fd;
2220
2221     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_SOCKET,
2222                                  vlan, NULL, model, name, NULL,
2223                                  net_socket_receive_dgram, NULL, NULL,
2224                                  net_socket_cleanup, s);
2225     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2226
2227     /* mcast: save bound address as dst */
2228     if (is_connected) s->dgram_dst=saddr;
2229
2230     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2231             "socket: fd=%d (%s mcast=%s:%d)",
2232             fd, is_connected? "cloned" : "",
2233             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2234     return s;
2235 }
2236
2237 static void net_socket_connect(void *opaque)
2238 {
2239     NetSocketState *s = opaque;
2240     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2241 }
2242
2243 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
2244                                                  const char *model,
2245                                                  const char *name,
2246                                                  int fd, int is_connected)
2247 {
2248     NetSocketState *s;
2249     s = qemu_mallocz(sizeof(NetSocketState));
2250     s->fd = fd;
2251     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_SOCKET,
2252                                  vlan, NULL, model, name, NULL,
2253                                  net_socket_receive, NULL, NULL,
2254                                  net_socket_cleanup, s);
2255     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2256              "socket: fd=%d", fd);
2257     if (is_connected) {
2258         net_socket_connect(s);
2259     } else {
2260         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2261     }
2262     return s;
2263 }
2264
2265 static NetSocketState *net_socket_fd_init(VLANState *vlan,
2266                                           const char *model, const char *name,
2267                                           int fd, int is_connected)
2268 {
2269     int so_type = -1, optlen=sizeof(so_type);
2270
2271     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
2272         (socklen_t *)&optlen)< 0) {
2273         fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
2274         return NULL;
2275     }
2276     switch(so_type) {
2277     case SOCK_DGRAM:
2278         return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
2279     case SOCK_STREAM:
2280         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
2281     default:
2282         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2283         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
2284         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
2285     }
2286     return NULL;
2287 }
2288
2289 static void net_socket_accept(void *opaque)
2290 {
2291     NetSocketListenState *s = opaque;
2292     NetSocketState *s1;
2293     struct sockaddr_in saddr;
2294     socklen_t len;
2295     int fd;
2296
2297     for(;;) {
2298         len = sizeof(saddr);
2299         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2300         if (fd < 0 && errno != EINTR) {
2301             return;
2302         } else if (fd >= 0) {
2303             break;
2304         }
2305     }
2306     s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
2307     if (!s1) {
2308         closesocket(fd);
2309     } else {
2310         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2311                  "socket: connection from %s:%d",
2312                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2313     }
2314 }
2315
2316 static int net_socket_listen_init(VLANState *vlan,
2317                                   const char *model,
2318                                   const char *name,
2319                                   const char *host_str)
2320 {
2321     NetSocketListenState *s;
2322     int fd, val, ret;
2323     struct sockaddr_in saddr;
2324
2325     if (parse_host_port(&saddr, host_str) < 0)
2326         return -1;
2327
2328     s = qemu_mallocz(sizeof(NetSocketListenState));
2329
2330     fd = socket(PF_INET, SOCK_STREAM, 0);
2331     if (fd < 0) {
2332         perror("socket");
2333         return -1;
2334     }
2335     socket_set_nonblock(fd);
2336
2337     /* allow fast reuse */
2338     val = 1;
2339     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2340
2341     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2342     if (ret < 0) {
2343         perror("bind");
2344         return -1;
2345     }
2346     ret = listen(fd, 0);
2347     if (ret < 0) {
2348         perror("listen");
2349         return -1;
2350     }
2351     s->vlan = vlan;
2352     s->model = qemu_strdup(model);
2353     s->name = name ? qemu_strdup(name) : NULL;
2354     s->fd = fd;
2355     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2356     return 0;
2357 }
2358
2359 static int net_socket_connect_init(VLANState *vlan,
2360                                    const char *model,
2361                                    const char *name,
2362                                    const char *host_str)
2363 {
2364     NetSocketState *s;
2365     int fd, connected, ret, err;
2366     struct sockaddr_in saddr;
2367
2368     if (parse_host_port(&saddr, host_str) < 0)
2369         return -1;
2370
2371     fd = socket(PF_INET, SOCK_STREAM, 0);
2372     if (fd < 0) {
2373         perror("socket");
2374         return -1;
2375     }
2376     socket_set_nonblock(fd);
2377
2378     connected = 0;
2379     for(;;) {
2380         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2381         if (ret < 0) {
2382             err = socket_error();
2383             if (err == EINTR || err == EWOULDBLOCK) {
2384             } else if (err == EINPROGRESS) {
2385                 break;
2386 #ifdef _WIN32
2387             } else if (err == WSAEALREADY) {
2388                 break;
2389 #endif
2390             } else {
2391                 perror("connect");
2392                 closesocket(fd);
2393                 return -1;
2394             }
2395         } else {
2396             connected = 1;
2397             break;
2398         }
2399     }
2400     s = net_socket_fd_init(vlan, model, name, fd, connected);
2401     if (!s)
2402         return -1;
2403     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2404              "socket: connect to %s:%d",
2405              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2406     return 0;
2407 }
2408
2409 static int net_socket_mcast_init(VLANState *vlan,
2410                                  const char *model,
2411                                  const char *name,
2412                                  const char *host_str)
2413 {
2414     NetSocketState *s;
2415     int fd;
2416     struct sockaddr_in saddr;
2417
2418     if (parse_host_port(&saddr, host_str) < 0)
2419         return -1;
2420
2421
2422     fd = net_socket_mcast_create(&saddr);
2423     if (fd < 0)
2424         return -1;
2425
2426     s = net_socket_fd_init(vlan, model, name, fd, 0);
2427     if (!s)
2428         return -1;
2429
2430     s->dgram_dst = saddr;
2431
2432     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2433              "socket: mcast=%s:%d",
2434              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2435     return 0;
2436
2437 }
2438
2439 typedef struct DumpState {
2440     VLANClientState *pcap_vc;
2441     int fd;
2442     int pcap_caplen;
2443 } DumpState;
2444
2445 #define PCAP_MAGIC 0xa1b2c3d4
2446
2447 struct pcap_file_hdr {
2448     uint32_t magic;
2449     uint16_t version_major;
2450     uint16_t version_minor;
2451     int32_t thiszone;
2452     uint32_t sigfigs;
2453     uint32_t snaplen;
2454     uint32_t linktype;
2455 };
2456
2457 struct pcap_sf_pkthdr {
2458     struct {
2459         int32_t tv_sec;
2460         int32_t tv_usec;
2461     } ts;
2462     uint32_t caplen;
2463     uint32_t len;
2464 };
2465
2466 static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
2467 {
2468     DumpState *s = vc->opaque;
2469     struct pcap_sf_pkthdr hdr;
2470     int64_t ts;
2471     int caplen;
2472
2473     /* Early return in case of previous error. */
2474     if (s->fd < 0) {
2475         return size;
2476     }
2477
2478     ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
2479     caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
2480
2481     hdr.ts.tv_sec = ts / 1000000;
2482     hdr.ts.tv_usec = ts % 1000000;
2483     hdr.caplen = caplen;
2484     hdr.len = size;
2485     if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
2486         write(s->fd, buf, caplen) != caplen) {
2487         qemu_log("-net dump write error - stop dump\n");
2488         close(s->fd);
2489         s->fd = -1;
2490     }
2491
2492     return size;
2493 }
2494
2495 static void net_dump_cleanup(VLANClientState *vc)
2496 {
2497     DumpState *s = vc->opaque;
2498
2499     close(s->fd);
2500     qemu_free(s);
2501 }
2502
2503 static int net_dump_init(VLANState *vlan, const char *device,
2504                          const char *name, const char *filename, int len)
2505 {
2506     struct pcap_file_hdr hdr;
2507     DumpState *s;
2508
2509     s = qemu_malloc(sizeof(DumpState));
2510
2511     s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
2512     if (s->fd < 0) {
2513         qemu_error("-net dump: can't open %s\n", filename);
2514         return -1;
2515     }
2516
2517     s->pcap_caplen = len;
2518
2519     hdr.magic = PCAP_MAGIC;
2520     hdr.version_major = 2;
2521     hdr.version_minor = 4;
2522     hdr.thiszone = 0;
2523     hdr.sigfigs = 0;
2524     hdr.snaplen = s->pcap_caplen;
2525     hdr.linktype = 1;
2526
2527     if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
2528         qemu_error("-net dump write error: %s\n", strerror(errno));
2529         close(s->fd);
2530         qemu_free(s);
2531         return -1;
2532     }
2533
2534     s->pcap_vc = qemu_new_vlan_client(NET_CLIENT_TYPE_DUMP,
2535                                       vlan, NULL, device, name, NULL,
2536                                       dump_receive, NULL, NULL,
2537                                       net_dump_cleanup, s);
2538     snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str),
2539              "dump to %s (len=%d)", filename, len);
2540     return 0;
2541 }
2542
2543 /* find or alloc a new VLAN */
2544 VLANState *qemu_find_vlan(int id, int allocate)
2545 {
2546     VLANState *vlan;
2547
2548     QTAILQ_FOREACH(vlan, &vlans, next) {
2549         if (vlan->id == id) {
2550             return vlan;
2551         }
2552     }
2553
2554     if (!allocate) {
2555         return NULL;
2556     }
2557
2558     vlan = qemu_mallocz(sizeof(VLANState));
2559     vlan->id = id;
2560     QTAILQ_INIT(&vlan->clients);
2561
2562     vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
2563                                           qemu_vlan_deliver_packet_iov,
2564                                           vlan);
2565
2566     QTAILQ_INSERT_TAIL(&vlans, vlan, next);
2567
2568     return vlan;
2569 }
2570
2571 VLANClientState *qemu_find_netdev(const char *id)
2572 {
2573     VLANClientState *vc;
2574
2575     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
2576         if (!strcmp(vc->name, id)) {
2577             return vc;
2578         }
2579     }
2580
2581     return NULL;
2582 }
2583
2584 static int nic_get_free_idx(void)
2585 {
2586     int index;
2587
2588     for (index = 0; index < MAX_NICS; index++)
2589         if (!nd_table[index].used)
2590             return index;
2591     return -1;
2592 }
2593
2594 int qemu_show_nic_models(const char *arg, const char *const *models)
2595 {
2596     int i;
2597
2598     if (!arg || strcmp(arg, "?"))
2599         return 0;
2600
2601     fprintf(stderr, "qemu: Supported NIC models: ");
2602     for (i = 0 ; models[i]; i++)
2603         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
2604     return 1;
2605 }
2606
2607 void qemu_check_nic_model(NICInfo *nd, const char *model)
2608 {
2609     const char *models[2];
2610
2611     models[0] = model;
2612     models[1] = NULL;
2613
2614     if (qemu_show_nic_models(nd->model, models))
2615         exit(0);
2616     if (qemu_find_nic_model(nd, models, model) < 0)
2617         exit(1);
2618 }
2619
2620 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
2621                         const char *default_model)
2622 {
2623     int i;
2624
2625     if (!nd->model)
2626         nd->model = qemu_strdup(default_model);
2627
2628     for (i = 0 ; models[i]; i++) {
2629         if (strcmp(nd->model, models[i]) == 0)
2630             return i;
2631     }
2632
2633     qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
2634     return -1;
2635 }
2636
2637 static int net_handle_fd_param(Monitor *mon, const char *param)
2638 {
2639     if (!qemu_isdigit(param[0])) {
2640         int fd;
2641
2642         fd = monitor_get_fd(mon, param);
2643         if (fd == -1) {
2644             qemu_error("No file descriptor named %s found", param);
2645             return -1;
2646         }
2647
2648         return fd;
2649     } else {
2650         return strtol(param, NULL, 0);
2651     }
2652 }
2653
2654 static int net_init_nic(QemuOpts *opts,
2655                         Monitor *mon,
2656                         const char *name,
2657                         VLANState *vlan)
2658 {
2659     int idx;
2660     NICInfo *nd;
2661     const char *netdev;
2662
2663     idx = nic_get_free_idx();
2664     if (idx == -1 || nb_nics >= MAX_NICS) {
2665         qemu_error("Too Many NICs\n");
2666         return -1;
2667     }
2668
2669     nd = &nd_table[idx];
2670
2671     memset(nd, 0, sizeof(*nd));
2672
2673     if ((netdev = qemu_opt_get(opts, "netdev"))) {
2674         nd->netdev = qemu_find_netdev(netdev);
2675         if (!nd->netdev) {
2676             qemu_error("netdev '%s' not found\n", netdev);
2677             return -1;
2678         }
2679     } else {
2680         assert(vlan);
2681         nd->vlan = vlan;
2682     }
2683     if (name) {
2684         nd->name = qemu_strdup(name);
2685     }
2686     if (qemu_opt_get(opts, "model")) {
2687         nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
2688     }
2689     if (qemu_opt_get(opts, "addr")) {
2690         nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
2691     }
2692
2693     nd->macaddr[0] = 0x52;
2694     nd->macaddr[1] = 0x54;
2695     nd->macaddr[2] = 0x00;
2696     nd->macaddr[3] = 0x12;
2697     nd->macaddr[4] = 0x34;
2698     nd->macaddr[5] = 0x56 + idx;
2699
2700     if (qemu_opt_get(opts, "macaddr") &&
2701         parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
2702         qemu_error("invalid syntax for ethernet address\n");
2703         return -1;
2704     }
2705
2706     nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
2707     if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
2708         (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
2709         qemu_error("invalid # of vectors: %d\n", nd->nvectors);
2710         return -1;
2711     }
2712
2713     nd->used = 1;
2714     if (vlan) {
2715         nd->vlan->nb_guest_devs++;
2716     }
2717     nb_nics++;
2718
2719     return idx;
2720 }
2721
2722 #if defined(CONFIG_SLIRP)
2723 static int net_init_slirp_configs(const char *name, const char *value, void *opaque)
2724 {
2725     struct slirp_config_str *config;
2726
2727     if (strcmp(name, "hostfwd") != 0 && strcmp(name, "guestfwd") != 0) {
2728         return 0;
2729     }
2730
2731     config = qemu_mallocz(sizeof(*config));
2732
2733     pstrcpy(config->str, sizeof(config->str), value);
2734
2735     if (!strcmp(name, "hostfwd")) {
2736         config->flags = SLIRP_CFG_HOSTFWD;
2737     }
2738
2739     config->next = slirp_configs;
2740     slirp_configs = config;
2741
2742     return 0;
2743 }
2744
2745 static int net_init_slirp(QemuOpts *opts,
2746                           Monitor *mon,
2747                           const char *name,
2748                           VLANState *vlan)
2749 {
2750     struct slirp_config_str *config;
2751     const char *vhost;
2752     const char *vhostname;
2753     const char *vdhcp_start;
2754     const char *vnamesrv;
2755     const char *tftp_export;
2756     const char *bootfile;
2757     const char *smb_export;
2758     const char *vsmbsrv;
2759     char *vnet = NULL;
2760     int restricted = 0;
2761     int ret;
2762
2763     vhost       = qemu_opt_get(opts, "host");
2764     vhostname   = qemu_opt_get(opts, "hostname");
2765     vdhcp_start = qemu_opt_get(opts, "dhcpstart");
2766     vnamesrv    = qemu_opt_get(opts, "dns");
2767     tftp_export = qemu_opt_get(opts, "tftp");
2768     bootfile    = qemu_opt_get(opts, "bootfile");
2769     smb_export  = qemu_opt_get(opts, "smb");
2770     vsmbsrv     = qemu_opt_get(opts, "smbserver");
2771
2772     if (qemu_opt_get(opts, "ip")) {
2773         const char *ip = qemu_opt_get(opts, "ip");
2774         int l = strlen(ip) + strlen("/24") + 1;
2775
2776         vnet = qemu_malloc(l);
2777
2778         /* emulate legacy ip= parameter */
2779         pstrcpy(vnet, l, ip);
2780         pstrcat(vnet, l, "/24");
2781     }
2782
2783     if (qemu_opt_get(opts, "net")) {
2784         if (vnet) {
2785             qemu_free(vnet);
2786         }
2787         vnet = qemu_strdup(qemu_opt_get(opts, "net"));
2788     }
2789
2790     if (qemu_opt_get(opts, "restrict") &&
2791         qemu_opt_get(opts, "restrict")[0] == 'y') {
2792         restricted = 1;
2793     }
2794
2795     qemu_opt_foreach(opts, net_init_slirp_configs, NULL, 0);
2796
2797     ret = net_slirp_init(vlan, "user", name, restricted, vnet, vhost,
2798                          vhostname, tftp_export, bootfile, vdhcp_start,
2799                          vnamesrv, smb_export, vsmbsrv);
2800
2801     while (slirp_configs) {
2802         config = slirp_configs;
2803         slirp_configs = config->next;
2804         qemu_free(config);
2805     }
2806
2807     if (ret != -1 && vlan) {
2808         vlan->nb_host_devs++;
2809     }
2810
2811     qemu_free(vnet);
2812
2813     return ret;
2814 }
2815 #endif /* CONFIG_SLIRP */
2816
2817 #ifdef _WIN32
2818 static int net_init_tap_win32(QemuOpts *opts,
2819                               Monitor *mon,
2820                               const char *name,
2821                               VLANState *vlan)
2822 {
2823     const char *ifname;
2824
2825     ifname = qemu_opt_get(opts, "ifname");
2826
2827     if (!ifname) {
2828         qemu_error("tap: no interface name\n");
2829         return -1;
2830     }
2831
2832     if (tap_win32_init(vlan, "tap", name, ifname) == -1) {
2833         return -1;
2834     }
2835
2836     if (vlan) {
2837         vlan->nb_host_devs++;
2838     }
2839
2840     return 0;
2841 }
2842 #elif !defined(_AIX)
2843 static int net_init_tap(QemuOpts *opts,
2844                         Monitor *mon,
2845                         const char *name,
2846                         VLANState *vlan)
2847 {
2848     TAPState *s;
2849     int fd, vnet_hdr;
2850
2851     if (qemu_opt_get(opts, "fd")) {
2852         if (qemu_opt_get(opts, "ifname") ||
2853             qemu_opt_get(opts, "script") ||
2854             qemu_opt_get(opts, "downscript") ||
2855             qemu_opt_get(opts, "vnet_hdr")) {
2856             qemu_error("ifname=, script=, downscript= and vnet_hdr= is invalid with fd=\n");
2857             return -1;
2858         }
2859
2860         fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2861         if (fd == -1) {
2862             return -1;
2863         }
2864
2865         fcntl(fd, F_SETFL, O_NONBLOCK);
2866
2867         vnet_hdr = tap_probe_vnet_hdr(fd);
2868     } else {
2869         if (!qemu_opt_get(opts, "script")) {
2870             qemu_opt_set(opts, "script", DEFAULT_NETWORK_SCRIPT);
2871         }
2872
2873         if (!qemu_opt_get(opts, "downscript")) {
2874             qemu_opt_set(opts, "downscript", DEFAULT_NETWORK_DOWN_SCRIPT);
2875         }
2876
2877         fd = net_tap_init(opts, &vnet_hdr);
2878     }
2879
2880     s = net_tap_fd_init(vlan, "tap", name, fd, vnet_hdr);
2881     if (!s) {
2882         close(fd);
2883         return -1;
2884     }
2885
2886     if (tap_set_sndbuf(s, opts) < 0) {
2887         return -1;
2888     }
2889
2890     if (qemu_opt_get(opts, "fd")) {
2891         snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
2892     } else {
2893         const char *ifname, *script, *downscript;
2894
2895         ifname     = qemu_opt_get(opts, "ifname");
2896         script     = qemu_opt_get(opts, "script");
2897         downscript = qemu_opt_get(opts, "downscript");
2898
2899         snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2900                  "ifname=%s,script=%s,downscript=%s",
2901                  ifname, script, downscript);
2902
2903         if (strcmp(downscript, "no") != 0) {
2904             snprintf(s->down_script, sizeof(s->down_script), "%s", downscript);
2905             snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
2906         }
2907     }
2908
2909     if (vlan) {
2910         vlan->nb_host_devs++;
2911     }
2912
2913     return 0;
2914 }
2915 #endif
2916
2917 static int net_init_socket(QemuOpts *opts,
2918                            Monitor *mon,
2919                            const char *name,
2920                            VLANState *vlan)
2921 {
2922     if (qemu_opt_get(opts, "fd")) {
2923         int fd;
2924
2925         if (qemu_opt_get(opts, "listen") ||
2926             qemu_opt_get(opts, "connect") ||
2927             qemu_opt_get(opts, "mcast")) {
2928             qemu_error("listen=, connect= and mcast= is invalid with fd=\n");
2929             return -1;
2930         }
2931
2932         fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2933         if (fd == -1) {
2934             return -1;
2935         }
2936
2937         if (!net_socket_fd_init(vlan, "socket", name, fd, 1)) {
2938             close(fd);
2939             return -1;
2940         }
2941     } else if (qemu_opt_get(opts, "listen")) {
2942         const char *listen;
2943
2944         if (qemu_opt_get(opts, "fd") ||
2945             qemu_opt_get(opts, "connect") ||
2946             qemu_opt_get(opts, "mcast")) {
2947             qemu_error("fd=, connect= and mcast= is invalid with listen=\n");
2948             return -1;
2949         }
2950
2951         listen = qemu_opt_get(opts, "listen");
2952
2953         if (net_socket_listen_init(vlan, "socket", name, listen) == -1) {
2954             return -1;
2955         }
2956     } else if (qemu_opt_get(opts, "connect")) {
2957         const char *connect;
2958
2959         if (qemu_opt_get(opts, "fd") ||
2960             qemu_opt_get(opts, "listen") ||
2961             qemu_opt_get(opts, "mcast")) {
2962             qemu_error("fd=, listen= and mcast= is invalid with connect=\n");
2963             return -1;
2964         }
2965
2966         connect = qemu_opt_get(opts, "connect");
2967
2968         if (net_socket_connect_init(vlan, "socket", name, connect) == -1) {
2969             return -1;
2970         }
2971     } else if (qemu_opt_get(opts, "mcast")) {
2972         const char *mcast;
2973
2974         if (qemu_opt_get(opts, "fd") ||
2975             qemu_opt_get(opts, "connect") ||
2976             qemu_opt_get(opts, "listen")) {
2977             qemu_error("fd=, connect= and listen= is invalid with mcast=\n");
2978             return -1;
2979         }
2980
2981         mcast = qemu_opt_get(opts, "mcast");
2982
2983         if (net_socket_mcast_init(vlan, "socket", name, mcast) == -1) {
2984             return -1;
2985         }
2986     } else {
2987         qemu_error("-socket requires fd=, listen=, connect= or mcast=\n");
2988         return -1;
2989     }
2990
2991     if (vlan) {
2992         vlan->nb_host_devs++;
2993     }
2994
2995     return 0;
2996 }
2997
2998 #ifdef CONFIG_VDE
2999 static int net_init_vde(QemuOpts *opts,
3000                         Monitor *mon,
3001                         const char *name,
3002                         VLANState *vlan)
3003 {
3004     const char *sock;
3005     const char *group;
3006     int port, mode;
3007
3008     sock  = qemu_opt_get(opts, "sock");
3009     group = qemu_opt_get(opts, "group");
3010
3011     port = qemu_opt_get_number(opts, "port", 0);
3012     mode = qemu_opt_get_number(opts, "mode", 0700);
3013
3014     if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
3015         return -1;
3016     }
3017
3018     if (vlan) {
3019         vlan->nb_host_devs++;
3020     }
3021
3022     return 0;
3023 }
3024 #endif
3025
3026 static int net_init_dump(QemuOpts *opts,
3027                          Monitor *mon,
3028                          const char *name,
3029                          VLANState *vlan)
3030 {
3031     int len;
3032     const char *file;
3033     char def_file[128];
3034
3035     assert(vlan);
3036
3037     file = qemu_opt_get(opts, "file");
3038     if (!file) {
3039         snprintf(def_file, sizeof(def_file), "qemu-vlan%d.pcap", vlan->id);
3040         file = def_file;
3041     }
3042
3043     len = qemu_opt_get_size(opts, "len", 65536);
3044
3045     return net_dump_init(vlan, "dump", name, file, len);
3046 }
3047
3048 #define NET_COMMON_PARAMS_DESC                     \
3049     {                                              \
3050         .name = "type",                            \
3051         .type = QEMU_OPT_STRING,                   \
3052         .help = "net client type (nic, tap etc.)", \
3053      }, {                                          \
3054         .name = "vlan",                            \
3055         .type = QEMU_OPT_NUMBER,                   \
3056         .help = "vlan number",                     \
3057      }, {                                          \
3058         .name = "name",                            \
3059         .type = QEMU_OPT_STRING,                   \
3060         .help = "identifier for monitor commands", \
3061      }
3062
3063 typedef int (*net_client_init_func)(QemuOpts *opts,
3064                                     Monitor *mon,
3065                                     const char *name,
3066                                     VLANState *vlan);
3067
3068 /* magic number, but compiler will warn if too small */
3069 #define NET_MAX_DESC 20
3070
3071 static struct {
3072     const char *type;
3073     net_client_init_func init;
3074     QemuOptDesc desc[NET_MAX_DESC];
3075 } net_client_types[] = {
3076     {
3077         .type = "none",
3078         .desc = {
3079             NET_COMMON_PARAMS_DESC,
3080             { /* end of list */ }
3081         },
3082     }, {
3083         .type = "nic",
3084         .init = net_init_nic,
3085         .desc = {
3086             NET_COMMON_PARAMS_DESC,
3087             {
3088                 .name = "netdev",
3089                 .type = QEMU_OPT_STRING,
3090                 .help = "id of -netdev to connect to",
3091             },
3092             {
3093                 .name = "macaddr",
3094                 .type = QEMU_OPT_STRING,
3095                 .help = "MAC address",
3096             }, {
3097                 .name = "model",
3098                 .type = QEMU_OPT_STRING,
3099                 .help = "device model (e1000, rtl8139, virtio etc.)",
3100             }, {
3101                 .name = "addr",
3102                 .type = QEMU_OPT_STRING,
3103                 .help = "PCI device address",
3104             }, {
3105                 .name = "vectors",
3106                 .type = QEMU_OPT_NUMBER,
3107                 .help = "number of MSI-x vectors, 0 to disable MSI-X",
3108             },
3109             { /* end of list */ }
3110         },
3111 #ifdef CONFIG_SLIRP
3112     }, {
3113         .type = "user",
3114         .init = net_init_slirp,
3115         .desc = {
3116             NET_COMMON_PARAMS_DESC,
3117             {
3118                 .name = "hostname",
3119                 .type = QEMU_OPT_STRING,
3120                 .help = "client hostname reported by the builtin DHCP server",
3121             }, {
3122                 .name = "restrict",
3123                 .type = QEMU_OPT_STRING,
3124                 .help = "isolate the guest from the host (y|yes|n|no)",
3125             }, {
3126                 .name = "ip",
3127                 .type = QEMU_OPT_STRING,
3128                 .help = "legacy parameter, use net= instead",
3129             }, {
3130                 .name = "net",
3131                 .type = QEMU_OPT_STRING,
3132                 .help = "IP address and optional netmask",
3133             }, {
3134                 .name = "host",
3135                 .type = QEMU_OPT_STRING,
3136                 .help = "guest-visible address of the host",
3137             }, {
3138                 .name = "tftp",
3139                 .type = QEMU_OPT_STRING,
3140                 .help = "root directory of the built-in TFTP server",
3141             }, {
3142                 .name = "bootfile",
3143                 .type = QEMU_OPT_STRING,
3144                 .help = "BOOTP filename, for use with tftp=",
3145             }, {
3146                 .name = "dhcpstart",
3147                 .type = QEMU_OPT_STRING,
3148                 .help = "the first of the 16 IPs the built-in DHCP server can assign",
3149             }, {
3150                 .name = "dns",
3151                 .type = QEMU_OPT_STRING,
3152                 .help = "guest-visible address of the virtual nameserver",
3153             }, {
3154                 .name = "smb",
3155                 .type = QEMU_OPT_STRING,
3156                 .help = "root directory of the built-in SMB server",
3157             }, {
3158                 .name = "smbserver",
3159                 .type = QEMU_OPT_STRING,
3160                 .help = "IP address of the built-in SMB server",
3161             }, {
3162                 .name = "hostfwd",
3163                 .type = QEMU_OPT_STRING,
3164                 .help = "guest port number to forward incoming TCP or UDP connections",
3165             }, {
3166                 .name = "guestfwd",
3167                 .type = QEMU_OPT_STRING,
3168                 .help = "IP address and port to forward guest TCP connections",
3169             },
3170             { /* end of list */ }
3171         },
3172 #endif
3173 #ifdef _WIN32
3174     }, {
3175         .type = "tap",
3176         .init = net_init_tap_win32,
3177         .desc = {
3178             NET_COMMON_PARAMS_DESC,
3179             {
3180                 .name = "ifname",
3181                 .type = QEMU_OPT_STRING,
3182                 .help = "interface name",
3183             },
3184             { /* end of list */ }
3185         },
3186 #elif !defined(_AIX)
3187     }, {
3188         .type = "tap",
3189         .init = net_init_tap,
3190         .desc = {
3191             NET_COMMON_PARAMS_DESC,
3192             {
3193                 .name = "fd",
3194                 .type = QEMU_OPT_STRING,
3195                 .help = "file descriptor of an already opened tap",
3196             }, {
3197                 .name = "ifname",
3198                 .type = QEMU_OPT_STRING,
3199                 .help = "interface name",
3200             }, {
3201                 .name = "script",
3202                 .type = QEMU_OPT_STRING,
3203                 .help = "script to initialize the interface",
3204             }, {
3205                 .name = "downscript",
3206                 .type = QEMU_OPT_STRING,
3207                 .help = "script to shut down the interface",
3208             }, {
3209                 .name = "sndbuf",
3210                 .type = QEMU_OPT_SIZE,
3211                 .help = "send buffer limit"
3212             }, {
3213                 .name = "vnet_hdr",
3214                 .type = QEMU_OPT_BOOL,
3215                 .help = "enable the IFF_VNET_HDR flag on the tap interface"
3216             },
3217             { /* end of list */ }
3218         },
3219 #endif
3220     }, {
3221         .type = "socket",
3222         .init = net_init_socket,
3223         .desc = {
3224             NET_COMMON_PARAMS_DESC,
3225             {
3226                 .name = "fd",
3227                 .type = QEMU_OPT_STRING,
3228                 .help = "file descriptor of an already opened socket",
3229             }, {
3230                 .name = "listen",
3231                 .type = QEMU_OPT_STRING,
3232                 .help = "port number, and optional hostname, to listen on",
3233             }, {
3234                 .name = "connect",
3235                 .type = QEMU_OPT_STRING,
3236                 .help = "port number, and optional hostname, to connect to",
3237             }, {
3238                 .name = "mcast",
3239                 .type = QEMU_OPT_STRING,
3240                 .help = "UDP multicast address and port number",
3241             },
3242             { /* end of list */ }
3243         },
3244 #ifdef CONFIG_VDE
3245     }, {
3246         .type = "vde",
3247         .init = net_init_vde,
3248         .desc = {
3249             NET_COMMON_PARAMS_DESC,
3250             {
3251                 .name = "sock",
3252                 .type = QEMU_OPT_STRING,
3253                 .help = "socket path",
3254             }, {
3255                 .name = "port",
3256                 .type = QEMU_OPT_NUMBER,
3257                 .help = "port number",
3258             }, {
3259                 .name = "group",
3260                 .type = QEMU_OPT_STRING,
3261                 .help = "group owner of socket",
3262             }, {
3263                 .name = "mode",
3264                 .type = QEMU_OPT_NUMBER,
3265                 .help = "permissions for socket",
3266             },
3267             { /* end of list */ }
3268         },
3269 #endif
3270     }, {
3271         .type = "dump",
3272         .init = net_init_dump,
3273         .desc = {
3274             NET_COMMON_PARAMS_DESC,
3275             {
3276                 .name = "len",
3277                 .type = QEMU_OPT_SIZE,
3278                 .help = "per-packet size limit (64k default)",
3279             }, {
3280                 .name = "file",
3281                 .type = QEMU_OPT_STRING,
3282                 .help = "dump file path (default is qemu-vlan0.pcap)",
3283             },
3284             { /* end of list */ }
3285         },
3286     },
3287     { /* end of list */ }
3288 };
3289
3290 int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
3291 {
3292     const char *name;
3293     const char *type;
3294     int i;
3295
3296     type = qemu_opt_get(opts, "type");
3297     if (!type) {
3298         qemu_error("No type specified for -net\n");
3299         return -1;
3300     }
3301
3302     if (is_netdev) {
3303         if (strcmp(type, "tap") != 0 &&
3304 #ifdef CONFIG_SLIRP
3305             strcmp(type, "user") != 0 &&
3306 #endif
3307 #ifdef CONFIG_VDE
3308             strcmp(type, "vde") != 0 &&
3309 #endif
3310             strcmp(type, "socket") != 0) {
3311             qemu_error("The '%s' network backend type is not valid with -netdev\n",
3312                        type);
3313             return -1;
3314         }
3315
3316         if (qemu_opt_get(opts, "vlan")) {
3317             qemu_error("The 'vlan' parameter is not valid with -netdev\n");
3318             return -1;
3319         }
3320         if (qemu_opt_get(opts, "name")) {
3321             qemu_error("The 'name' parameter is not valid with -netdev\n");
3322             return -1;
3323         }
3324         if (!qemu_opts_id(opts)) {
3325             qemu_error("The id= parameter is required with -netdev\n");
3326             return -1;
3327         }
3328     }
3329
3330     name = qemu_opts_id(opts);
3331     if (!name) {
3332         name = qemu_opt_get(opts, "name");
3333     }
3334
3335     for (i = 0; net_client_types[i].type != NULL; i++) {
3336         if (!strcmp(net_client_types[i].type, type)) {
3337             VLANState *vlan = NULL;
3338
3339             if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
3340                 return -1;
3341             }
3342
3343             /* Do not add to a vlan if it's a -netdev or a nic with a
3344              * netdev= parameter. */
3345             if (!(is_netdev ||
3346                   (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
3347                 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
3348             }
3349
3350             if (net_client_types[i].init) {
3351                 return net_client_types[i].init(opts, mon, name, vlan);
3352             } else {
3353                 return 0;
3354             }
3355         }
3356     }
3357
3358     qemu_error("Invalid -net type '%s'\n", type);
3359     return -1;
3360 }
3361
3362 void net_client_uninit(NICInfo *nd)
3363 {
3364     if (nd->vlan) {
3365         nd->vlan->nb_guest_devs--;
3366     }
3367     nb_nics--;
3368
3369     qemu_free(nd->model);
3370     qemu_free(nd->name);
3371     qemu_free(nd->devaddr);
3372
3373     nd->used = 0;
3374 }
3375
3376 static int net_host_check_device(const char *device)
3377 {
3378     int i;
3379     const char *valid_param_list[] = { "tap", "socket", "dump"
3380 #ifdef CONFIG_SLIRP
3381                                        ,"user"
3382 #endif
3383 #ifdef CONFIG_VDE
3384                                        ,"vde"
3385 #endif
3386     };
3387     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
3388         if (!strncmp(valid_param_list[i], device,
3389                      strlen(valid_param_list[i])))
3390             return 1;
3391     }
3392
3393     return 0;
3394 }
3395
3396 void net_host_device_add(Monitor *mon, const QDict *qdict)
3397 {
3398     const char *device = qdict_get_str(qdict, "device");
3399     const char *opts_str = qdict_get_try_str(qdict, "opts");
3400     QemuOpts *opts;
3401
3402     if (!net_host_check_device(device)) {
3403         monitor_printf(mon, "invalid host network device %s\n", device);
3404         return;
3405     }
3406
3407     opts = qemu_opts_parse(&qemu_net_opts, opts_str ? opts_str : "", NULL);
3408     if (!opts) {
3409         monitor_printf(mon, "parsing network options '%s' failed\n",
3410                        opts_str ? opts_str : "");
3411         return;
3412     }
3413
3414     qemu_opt_set(opts, "type", device);
3415
3416     if (net_client_init(mon, opts, 0) < 0) {
3417         monitor_printf(mon, "adding host network device %s failed\n", device);
3418     }
3419 }
3420
3421 void net_host_device_remove(Monitor *mon, const QDict *qdict)
3422 {
3423     VLANClientState *vc;
3424     int vlan_id = qdict_get_int(qdict, "vlan_id");
3425     const char *device = qdict_get_str(qdict, "device");
3426
3427     vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
3428     if (!vc) {
3429         return;
3430     }
3431     if (!net_host_check_device(vc->model)) {
3432         monitor_printf(mon, "invalid host network device %s\n", device);
3433         return;
3434     }
3435     qemu_del_vlan_client(vc);
3436 }
3437
3438 void net_set_boot_mask(int net_boot_mask)
3439 {
3440     int i;
3441
3442     /* Only the first four NICs may be bootable */
3443     net_boot_mask = net_boot_mask & 0xF;
3444
3445     for (i = 0; i < nb_nics; i++) {
3446         if (net_boot_mask & (1 << i)) {
3447             nd_table[i].bootable = 1;
3448             net_boot_mask &= ~(1 << i);
3449         }
3450     }
3451
3452     if (net_boot_mask) {
3453         fprintf(stderr, "Cannot boot from non-existent NIC\n");
3454         exit(1);
3455     }
3456 }
3457
3458 void do_info_network(Monitor *mon)
3459 {
3460     VLANState *vlan;
3461
3462     QTAILQ_FOREACH(vlan, &vlans, next) {
3463         VLANClientState *vc;
3464
3465         monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
3466
3467         QTAILQ_FOREACH(vc, &vlan->clients, next) {
3468             monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
3469         }
3470     }
3471 }
3472
3473 void do_set_link(Monitor *mon, const QDict *qdict)
3474 {
3475     VLANState *vlan;
3476     VLANClientState *vc = NULL;
3477     const char *name = qdict_get_str(qdict, "name");
3478     const char *up_or_down = qdict_get_str(qdict, "up_or_down");
3479
3480     QTAILQ_FOREACH(vlan, &vlans, next) {
3481         QTAILQ_FOREACH(vc, &vlan->clients, next) {
3482             if (strcmp(vc->name, name) == 0) {
3483                 goto done;
3484             }
3485         }
3486     }
3487 done:
3488
3489     if (!vc) {
3490         monitor_printf(mon, "could not find network device '%s'\n", name);
3491         return;
3492     }
3493
3494     if (strcmp(up_or_down, "up") == 0)
3495         vc->link_down = 0;
3496     else if (strcmp(up_or_down, "down") == 0)
3497         vc->link_down = 1;
3498     else
3499         monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
3500                        "valid\n", up_or_down);
3501
3502     if (vc->link_status_changed)
3503         vc->link_status_changed(vc);
3504 }
3505
3506 void net_cleanup(void)
3507 {
3508     VLANState *vlan;
3509     VLANClientState *vc, *next_vc;
3510
3511     QTAILQ_FOREACH(vlan, &vlans, next) {
3512         QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
3513             qemu_del_vlan_client(vc);
3514         }
3515     }
3516
3517     QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
3518         qemu_del_vlan_client(vc);
3519     }
3520 }
3521
3522 static void net_check_clients(void)
3523 {
3524     VLANState *vlan;
3525
3526     QTAILQ_FOREACH(vlan, &vlans, next) {
3527         if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
3528             continue;
3529         if (vlan->nb_guest_devs == 0)
3530             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
3531         if (vlan->nb_host_devs == 0)
3532             fprintf(stderr,
3533                     "Warning: vlan %d is not connected to host network\n",
3534                     vlan->id);
3535     }
3536 }
3537
3538 static int net_init_client(QemuOpts *opts, void *dummy)
3539 {
3540     if (net_client_init(NULL, opts, 0) < 0)
3541         return -1;
3542     return 0;
3543 }
3544
3545 static int net_init_netdev(QemuOpts *opts, void *dummy)
3546 {
3547     return net_client_init(NULL, opts, 1);
3548 }
3549
3550 int net_init_clients(void)
3551 {
3552     if (QTAILQ_EMPTY(&qemu_net_opts.head)) {
3553         /* if no clients, we use a default config */
3554         qemu_opts_set(&qemu_net_opts, NULL, "type", "nic");
3555 #ifdef CONFIG_SLIRP
3556         qemu_opts_set(&qemu_net_opts, NULL, "type", "user");
3557 #endif
3558     }
3559
3560     QTAILQ_INIT(&vlans);
3561     QTAILQ_INIT(&non_vlan_clients);
3562
3563     if (qemu_opts_foreach(&qemu_netdev_opts, net_init_netdev, NULL, 1) == -1)
3564         return -1;
3565
3566     if (qemu_opts_foreach(&qemu_net_opts, net_init_client, NULL, 1) == -1) {
3567         return -1;
3568     }
3569
3570     net_check_clients();
3571
3572     return 0;
3573 }
3574
3575 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
3576 {
3577 #if defined(CONFIG_SLIRP)
3578     /* handle legacy -net channel,port:chr */
3579     if (!strcmp(opts_list->name, "net") &&
3580         !strncmp(optarg, "channel,", strlen("channel,"))) {
3581         int ret;
3582
3583         optarg += strlen("channel,");
3584
3585         if (QTAILQ_EMPTY(&slirp_stacks)) {
3586             struct slirp_config_str *config;
3587
3588             config = qemu_malloc(sizeof(*config));
3589             pstrcpy(config->str, sizeof(config->str), optarg);
3590             config->flags = SLIRP_CFG_LEGACY;
3591             config->next = slirp_configs;
3592             slirp_configs = config;
3593             ret = 0;
3594         } else {
3595             ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), optarg, 1);
3596         }
3597
3598         return ret;
3599     }
3600 #endif
3601     if (!qemu_opts_parse(opts_list, optarg, "type")) {
3602         return -1;
3603     }
3604
3605     return 0;
3606 }