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