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