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