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