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