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