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