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 CONFIG_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 "tap-linux.h"
  50 #endif
  51 #include <arpa/inet.h>
  52 #include <dirent.h>
  53 #include <netdb.h>
  54 #include <sys/select.h>
  55 #ifdef CONFIG_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 #include "qemu-common.h"
 105 #include "net.h"
 106 #include "monitor.h"
 107 #include "sysemu.h"
 108 #include "qemu-timer.h"
 109 #include "qemu-char.h"
 110 #include "audio/audio.h"
 111 #include "qemu_socket.h"
 112 #include "qemu-log.h"
 113 #include "qemu-config.h"
 114
 115 #include "slirp/libslirp.h"
 116
 117 static QTAILQ_HEAD(, VLANState) vlans;
 118 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
 119
 120 /***********************************************************/
 121 /* network device redirectors */
 122
 123 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
 124 static void hex_dump(FILE *f, const uint8_t *buf, int size)
 125 {
 126     int len, i, j, c;
 127
 128     for(i=0;i<size;i+=16) {
 129         len = size - i;
 130         if (len > 16)
 131             len = 16;
 132         fprintf(f, "%08x ", i);
 133         for(j=0;j<16;j++) {
 134             if (j < len)
 135                 fprintf(f, " %02x", buf[i+j]);
 136             else
 137                 fprintf(f, "   ");
 138         }
 139         fprintf(f, " ");
 140         for(j=0;j<len;j++) {
 141             c = buf[i+j];
 142             if (c < ' ' || c > '~')
 143                 c = '.';
 144             fprintf(f, "%c", c);
 145         }
 146         fprintf(f, "\n");
 147     }
 148 }
 149 #endif
 150
 151 static int parse_macaddr(uint8_t *macaddr, const char *p)
 152 {
 153     int i;
 154     char *last_char;
 155     long int offset;
 156
 157     errno = 0;
 158     offset = strtol(p, &last_char, 0);
 159     if (0 == errno && '\0' == *last_char &&
 160             offset >= 0 && offset <= 0xFFFFFF) {
 161         macaddr[3] = (offset & 0xFF0000) >> 16;
 162         macaddr[4] = (offset & 0xFF00) >> 8;
 163         macaddr[5] = offset & 0xFF;
 164         return 0;
 165     } else {
 166         for(i = 0; i < 6; i++) {
 167             macaddr[i] = strtol(p, (char **)&p, 16);
 168             if (i == 5) {
 169                 if (*p != '\0')
 170                     return -1;
 171             } else {
 172                 if (*p != ':' && *p != '-')
 173                     return -1;
 174                 p++;
 175             }
 176         }
 177         return 0;
 178     }
 179
 180     return -1;
 181 }
 182
 183 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
 184 {
 185     const char *p, *p1;
 186     int len;
 187     p = *pp;
 188     p1 = strchr(p, sep);
 189     if (!p1)
 190         return -1;
 191     len = p1 - p;
 192     p1++;
 193     if (buf_size > 0) {
 194         if (len > buf_size - 1)
 195             len = buf_size - 1;
 196         memcpy(buf, p, len);
 197         buf[len] = '\0';
 198     }
 199     *pp = p1;
 200     return 0;
 201 }
 202
 203 int parse_host_src_port(struct sockaddr_in *haddr,
 204                         struct sockaddr_in *saddr,
 205                         const char *input_str)
 206 {
 207     char *str = strdup(input_str);
 208     char *host_str = str;
 209     char *src_str;
 210     const char *src_str2;
 211     char *ptr;
 212
 213     /*
 214      * Chop off any extra arguments at the end of the string which
 215      * would start with a comma, then fill in the src port information
 216      * if it was provided else use the "any address" and "any port".
 217      */
 218     if ((ptr = strchr(str,',')))
 219         *ptr = '\0';
 220
 221     if ((src_str = strchr(input_str,'@'))) {
 222         *src_str = '\0';
 223         src_str++;
 224     }
 225
 226     if (parse_host_port(haddr, host_str) < 0)
 227         goto fail;
 228
 229     src_str2 = src_str;
 230     if (!src_str || *src_str == '\0')
 231         src_str2 = ":0";
 232
 233     if (parse_host_port(saddr, src_str2) < 0)
 234         goto fail;
 235
 236     free(str);
 237     return(0);
 238
 239 fail:
 240     free(str);
 241     return -1;
 242 }
 243
 244 int parse_host_port(struct sockaddr_in *saddr, const char *str)
 245 {
 246     char buf[512];
 247     struct hostent *he;
 248     const char *p, *r;
 249     int port;
 250
 251     p = str;
 252     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
 253         return -1;
 254     saddr->sin_family = AF_INET;
 255     if (buf[0] == '\0') {
 256         saddr->sin_addr.s_addr = 0;
 257     } else {
 258         if (qemu_isdigit(buf[0])) {
 259             if (!inet_aton(buf, &saddr->sin_addr))
 260                 return -1;
 261         } else {
 262             if ((he = gethostbyname(buf)) == NULL)
 263                 return - 1;
 264             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 265         }
 266     }
 267     port = strtol(p, (char **)&r, 0);
 268     if (r == p)
 269         return -1;
 270     saddr->sin_port = htons(port);
 271     return 0;
 272 }
 273
 274 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
 275 {
 276     snprintf(vc->info_str, sizeof(vc->info_str),
 277              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 278              vc->model,
 279              macaddr[0], macaddr[1], macaddr[2],
 280              macaddr[3], macaddr[4], macaddr[5]);
 281 }
 282
 283 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 284 {
 285     static int index = 0;
 286     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 287
 288     if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
 289         return;
 290     macaddr->a[0] = 0x52;
 291     macaddr->a[1] = 0x54;
 292     macaddr->a[2] = 0x00;
 293     macaddr->a[3] = 0x12;
 294     macaddr->a[4] = 0x34;
 295     macaddr->a[5] = 0x56 + index++;
 296 }
 297
 298 static char *assign_name(VLANClientState *vc1, const char *model)
 299 {
 300     VLANState *vlan;
 301     char buf[256];
 302     int id = 0;
 303
 304     QTAILQ_FOREACH(vlan, &vlans, next) {
 305         VLANClientState *vc;
 306
 307         QTAILQ_FOREACH(vc, &vlan->clients, next) {
 308             if (vc != vc1 && strcmp(vc->model, model) == 0) {
 309                 id++;
 310             }
 311         }
 312     }
 313
 314     snprintf(buf, sizeof(buf), "%s.%d", model, id);
 315
 316     return qemu_strdup(buf);
 317 }
 318
 319 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 320                                    unsigned flags,
 321                                    const uint8_t *data,
 322                                    size_t size,
 323                                    void *opaque);
 324 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 325                                        unsigned flags,
 326                                        const struct iovec *iov,
 327                                        int iovcnt,
 328                                        void *opaque);
 329
 330 VLANClientState *qemu_new_vlan_client(net_client_type type,
 331                                       VLANState *vlan,
 332                                       VLANClientState *peer,
 333                                       const char *model,
 334                                       const char *name,
 335                                       NetCanReceive *can_receive,
 336                                       NetReceive *receive,
 337                                       NetReceive *receive_raw,
 338                                       NetReceiveIOV *receive_iov,
 339                                       NetCleanup *cleanup,
 340                                       void *opaque)
 341 {
 342     VLANClientState *vc;
 343
 344     vc = qemu_mallocz(sizeof(VLANClientState));
 345
 346     vc->type = type;
 347     vc->model = qemu_strdup(model);
 348     if (name)
 349         vc->name = qemu_strdup(name);
 350     else
 351         vc->name = assign_name(vc, model);
 352     vc->can_receive = can_receive;
 353     vc->receive = receive;
 354     vc->receive_raw = receive_raw;
 355     vc->receive_iov = receive_iov;
 356     vc->cleanup = cleanup;
 357     vc->opaque = opaque;
 358
 359     if (vlan) {
 360         assert(!peer);
 361         vc->vlan = vlan;
 362         QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
 363     } else {
 364         if (peer) {
 365             vc->peer = peer;
 366             peer->peer = vc;
 367         }
 368         QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
 369
 370         vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
 371                                             qemu_deliver_packet_iov,
 372                                             vc);
 373     }
 374
 375     return vc;
 376 }
 377
 378 void qemu_del_vlan_client(VLANClientState *vc)
 379 {
 380     if (vc->vlan) {
 381         QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
 382     } else {
 383         if (vc->send_queue) {
 384             qemu_del_net_queue(vc->send_queue);
 385         }
 386         QTAILQ_REMOVE(&non_vlan_clients, vc, next);
 387         if (vc->peer) {
 388             vc->peer->peer = NULL;
 389         }
 390     }
 391
 392     if (vc->cleanup) {
 393         vc->cleanup(vc);
 394     }
 395
 396     qemu_free(vc->name);
 397     qemu_free(vc->model);
 398     qemu_free(vc);
 399 }
 400
 401 VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
 402 {
 403     VLANClientState *vc;
 404
 405     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 406         if (vc->opaque == opaque) {
 407             return vc;
 408         }
 409     }
 410
 411     return NULL;
 412 }
 413
 414 static VLANClientState *
 415 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
 416                               const char *client_str)
 417 {
 418     VLANState *vlan;
 419     VLANClientState *vc;
 420
 421     vlan = qemu_find_vlan(vlan_id, 0);
 422     if (!vlan) {
 423         monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
 424         return NULL;
 425     }
 426
 427     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 428         if (!strcmp(vc->name, client_str)) {
 429             break;
 430         }
 431     }
 432     if (!vc) {
 433         monitor_printf(mon, "can't find device %s on VLAN %d\n",
 434                        client_str, vlan_id);
 435     }
 436
 437     return vc;
 438 }
 439
 440 int qemu_can_send_packet(VLANClientState *sender)
 441 {
 442     VLANState *vlan = sender->vlan;
 443     VLANClientState *vc;
 444
 445     if (sender->peer) {
 446         if (!sender->peer->can_receive ||
 447             sender->peer->can_receive(sender->peer)) {
 448             return 1;
 449         } else {
 450             return 0;
 451         }
 452     }
 453
 454     if (!sender->vlan) {
 455         return 1;
 456     }
 457
 458     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 459         if (vc == sender) {
 460             continue;
 461         }
 462
 463         /* no can_receive() handler, they can always receive */
 464         if (!vc->can_receive || vc->can_receive(vc)) {
 465             return 1;
 466         }
 467     }
 468     return 0;
 469 }
 470
 471 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 472                                    unsigned flags,
 473                                    const uint8_t *data,
 474                                    size_t size,
 475                                    void *opaque)
 476 {
 477     VLANClientState *vc = opaque;
 478
 479     if (vc->link_down) {
 480         return size;
 481     }
 482
 483     if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->receive_raw)
 484         return vc->receive_raw(vc, data, size);
 485     else
 486         return vc->receive(vc, data, size);
 487 }
 488
 489 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
 490                                         unsigned flags,
 491                                         const uint8_t *buf,
 492                                         size_t size,
 493                                         void *opaque)
 494 {
 495     VLANState *vlan = opaque;
 496     VLANClientState *vc;
 497     int ret = -1;
 498
 499     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 500         ssize_t len;
 501
 502         if (vc == sender) {
 503             continue;
 504         }
 505
 506         if (vc->link_down) {
 507             ret = size;
 508             continue;
 509         }
 510
 511         if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->receive_raw)
 512             len = vc->receive_raw(vc, buf, size);
 513         else
 514             len = vc->receive(vc, buf, size);
 515
 516         ret = (ret >= 0) ? ret : len;
 517     }
 518
 519     return ret;
 520 }
 521
 522 void qemu_purge_queued_packets(VLANClientState *vc)
 523 {
 524     NetQueue *queue;
 525
 526     if (!vc->peer && !vc->vlan) {
 527         return;
 528     }
 529
 530     if (vc->peer) {
 531         queue = vc->peer->send_queue;
 532     } else {
 533         queue = vc->vlan->send_queue;
 534     }
 535
 536     qemu_net_queue_purge(queue, vc);
 537 }
 538
 539 void qemu_flush_queued_packets(VLANClientState *vc)
 540 {
 541     NetQueue *queue;
 542
 543     if (vc->vlan) {
 544         queue = vc->vlan->send_queue;
 545     } else {
 546         queue = vc->send_queue;
 547     }
 548
 549     qemu_net_queue_flush(queue);
 550 }
 551
 552 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
 553                                                  unsigned flags,
 554                                                  const uint8_t *buf, int size,
 555                                                  NetPacketSent *sent_cb)
 556 {
 557     NetQueue *queue;
 558
 559 #ifdef DEBUG_NET
 560     printf("qemu_send_packet_async:\n");
 561     hex_dump(stdout, buf, size);
 562 #endif
 563
 564     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 565         return size;
 566     }
 567
 568     if (sender->peer) {
 569         queue = sender->peer->send_queue;
 570     } else {
 571         queue = sender->vlan->send_queue;
 572     }
 573
 574     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 575 }
 576
 577 ssize_t qemu_send_packet_async(VLANClientState *sender,
 578                                const uint8_t *buf, int size,
 579                                NetPacketSent *sent_cb)
 580 {
 581     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 582                                              buf, size, sent_cb);
 583 }
 584
 585 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
 586 {
 587     qemu_send_packet_async(vc, buf, size, NULL);
 588 }
 589
 590 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
 591 {
 592     return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
 593                                              buf, size, NULL);
 594 }
 595
 596 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
 597                                int iovcnt)
 598 {
 599     uint8_t buffer[4096];
 600     size_t offset = 0;
 601     int i;
 602
 603     for (i = 0; i < iovcnt; i++) {
 604         size_t len;
 605
 606         len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
 607         memcpy(buffer + offset, iov[i].iov_base, len);
 608         offset += len;
 609     }
 610
 611     return vc->receive(vc, buffer, offset);
 612 }
 613
 614 static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
 615 {
 616     size_t offset = 0;
 617     int i;
 618
 619     for (i = 0; i < iovcnt; i++)
 620         offset += iov[i].iov_len;
 621     return offset;
 622 }
 623
 624 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 625                                        unsigned flags,
 626                                        const struct iovec *iov,
 627                                        int iovcnt,
 628                                        void *opaque)
 629 {
 630     VLANClientState *vc = opaque;
 631
 632     if (vc->link_down) {
 633         return calc_iov_length(iov, iovcnt);
 634     }
 635
 636     if (vc->receive_iov) {
 637         return vc->receive_iov(vc, iov, iovcnt);
 638     } else {
 639         return vc_sendv_compat(vc, iov, iovcnt);
 640     }
 641 }
 642
 643 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
 644                                             unsigned flags,
 645                                             const struct iovec *iov,
 646                                             int iovcnt,
 647                                             void *opaque)
 648 {
 649     VLANState *vlan = opaque;
 650     VLANClientState *vc;
 651     ssize_t ret = -1;
 652
 653     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 654         ssize_t len;
 655
 656         if (vc == sender) {
 657             continue;
 658         }
 659
 660         if (vc->link_down) {
 661             ret = calc_iov_length(iov, iovcnt);
 662             continue;
 663         }
 664
 665         assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
 666
 667         if (vc->receive_iov) {
 668             len = vc->receive_iov(vc, iov, iovcnt);
 669         } else {
 670             len = vc_sendv_compat(vc, iov, iovcnt);
 671         }
 672
 673         ret = (ret >= 0) ? ret : len;
 674     }
 675
 676     return ret;
 677 }
 678
 679 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
 680                                 const struct iovec *iov, int iovcnt,
 681                                 NetPacketSent *sent_cb)
 682 {
 683     NetQueue *queue;
 684
 685     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 686         return calc_iov_length(iov, iovcnt);
 687     }
 688
 689     if (sender->peer) {
 690         queue = sender->peer->send_queue;
 691     } else {
 692         queue = sender->vlan->send_queue;
 693     }
 694
 695     return qemu_net_queue_send_iov(queue, sender,
 696                                    QEMU_NET_PACKET_FLAG_NONE,
 697                                    iov, iovcnt, sent_cb);
 698 }
 699
 700 ssize_t
 701 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
 702 {
 703     return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
 704 }
 705
 706 #if defined(CONFIG_SLIRP)
 707
 708 /* slirp network adapter */
 709
 710 #define SLIRP_CFG_HOSTFWD 1
 711 #define SLIRP_CFG_LEGACY  2
 712
 713 struct slirp_config_str {
 714     struct slirp_config_str *next;
 715     int flags;
 716     char str[1024];
 717     int legacy_format;
 718 };
 719
 720 typedef struct SlirpState {
 721     QTAILQ_ENTRY(SlirpState) entry;
 722     VLANClientState *vc;
 723     Slirp *slirp;
 724 #ifndef _WIN32
 725     char smb_dir[128];
 726 #endif
 727 } SlirpState;
 728
 729 static struct slirp_config_str *slirp_configs;
 730 const char *legacy_tftp_prefix;
 731 const char *legacy_bootp_filename;
 732 static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
 733     QTAILQ_HEAD_INITIALIZER(slirp_stacks);
 734
 735 static int slirp_hostfwd(SlirpState *s, const char *redir_str,
 736                          int legacy_format);
 737 static int slirp_guestfwd(SlirpState *s, const char *config_str,
 738                           int legacy_format);
 739
 740 #ifndef _WIN32
 741 static const char *legacy_smb_export;
 742
 743 static int slirp_smb(SlirpState *s, const char *exported_dir,
 744                      struct in_addr vserver_addr);
 745 static void slirp_smb_cleanup(SlirpState *s);
 746 #else
 747 static inline void slirp_smb_cleanup(SlirpState *s) { }
 748 #endif
 749
 750 int slirp_can_output(void *opaque)
 751 {
 752     SlirpState *s = opaque;
 753
 754     return qemu_can_send_packet(s->vc);
 755 }
 756
 757 void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
 758 {
 759     SlirpState *s = opaque;
 760
 761 #ifdef DEBUG_SLIRP
 762     printf("slirp output:\n");
 763     hex_dump(stdout, pkt, pkt_len);
 764 #endif
 765     qemu_send_packet(s->vc, pkt, pkt_len);
 766 }
 767
 768 static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
 769 {
 770     SlirpState *s = vc->opaque;
 771
 772 #ifdef DEBUG_SLIRP
 773     printf("slirp input:\n");
 774     hex_dump(stdout, buf, size);
 775 #endif
 776     slirp_input(s->slirp, buf, size);
 777     return size;
 778 }
 779
 780 static void net_slirp_cleanup(VLANClientState *vc)
 781 {
 782     SlirpState *s = vc->opaque;
 783
 784     slirp_cleanup(s->slirp);
 785     slirp_smb_cleanup(s);
 786     QTAILQ_REMOVE(&slirp_stacks, s, entry);
 787     qemu_free(s);
 788 }
 789
 790 static int net_slirp_init(VLANState *vlan, const char *model,
 791                           const char *name, int restricted,
 792                           const char *vnetwork, const char *vhost,
 793                           const char *vhostname, const char *tftp_export,
 794                           const char *bootfile, const char *vdhcp_start,
 795                           const char *vnameserver, const char *smb_export,
 796                           const char *vsmbserver)
 797 {
 798     /* default settings according to historic slirp */
 799     struct in_addr net  = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
 800     struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
 801     struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
 802     struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
 803     struct in_addr dns  = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
 804 #ifndef _WIN32
 805     struct in_addr smbsrv = { .s_addr = 0 };
 806 #endif
 807     SlirpState *s;
 808     char buf[20];
 809     uint32_t addr;
 810     int shift;
 811     char *end;
 812     struct slirp_config_str *config;
 813
 814     if (!tftp_export) {
 815         tftp_export = legacy_tftp_prefix;
 816     }
 817     if (!bootfile) {
 818         bootfile = legacy_bootp_filename;
 819     }
 820
 821     if (vnetwork) {
 822         if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
 823             if (!inet_aton(vnetwork, &net)) {
 824                 return -1;
 825             }
 826             addr = ntohl(net.s_addr);
 827             if (!(addr & 0x80000000)) {
 828                 mask.s_addr = htonl(0xff000000); /* class A */
 829             } else if ((addr & 0xfff00000) == 0xac100000) {
 830                 mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
 831             } else if ((addr & 0xc0000000) == 0x80000000) {
 832                 mask.s_addr = htonl(0xffff0000); /* class B */
 833             } else if ((addr & 0xffff0000) == 0xc0a80000) {
 834                 mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
 835             } else if ((addr & 0xffff0000) == 0xc6120000) {
 836                 mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
 837             } else if ((addr & 0xe0000000) == 0xe0000000) {
 838                 mask.s_addr = htonl(0xffffff00); /* class C */
 839             } else {
 840                 mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
 841             }
 842         } else {
 843             if (!inet_aton(buf, &net)) {
 844                 return -1;
 845             }
 846             shift = strtol(vnetwork, &end, 10);
 847             if (*end != '\0') {
 848                 if (!inet_aton(vnetwork, &mask)) {
 849                     return -1;
 850                 }
 851             } else if (shift < 4 || shift > 32) {
 852                 return -1;
 853             } else {
 854                 mask.s_addr = htonl(0xffffffff << (32 - shift));
 855             }
 856         }
 857         net.s_addr &= mask.s_addr;
 858         host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
 859         dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
 860         dns.s_addr  = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
 861     }
 862
 863     if (vhost && !inet_aton(vhost, &host)) {
 864         return -1;
 865     }
 866     if ((host.s_addr & mask.s_addr) != net.s_addr) {
 867         return -1;
 868     }
 869
 870     if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
 871         return -1;
 872     }
 873     if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||
 874         dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
 875         return -1;
 876     }
 877
 878     if (vnameserver && !inet_aton(vnameserver, &dns)) {
 879         return -1;
 880     }
 881     if ((dns.s_addr & mask.s_addr) != net.s_addr ||
 882         dns.s_addr == host.s_addr) {
 883         return -1;
 884     }
 885
 886 #ifndef _WIN32
 887     if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
 888         return -1;
 889     }
 890 #endif
 891
 892     s = qemu_mallocz(sizeof(SlirpState));
 893     s->slirp = slirp_init(restricted, net, mask, host, vhostname,
 894                           tftp_export, bootfile, dhcp, dns, s);
 895     QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
 896
 897     for (config = slirp_configs; config; config = config->next) {
 898         if (config->flags & SLIRP_CFG_HOSTFWD) {
 899             if (slirp_hostfwd(s, config->str,
 900                               config->flags & SLIRP_CFG_LEGACY) < 0)
 901                 return -1;
 902         } else {
 903             if (slirp_guestfwd(s, config->str,
 904                                config->flags & SLIRP_CFG_LEGACY) < 0)
 905                 return -1;
 906         }
 907     }
 908 #ifndef _WIN32
 909     if (!smb_export) {
 910         smb_export = legacy_smb_export;
 911     }
 912     if (smb_export) {
 913         if (slirp_smb(s, smb_export, smbsrv) < 0)
 914             return -1;
 915     }
 916 #endif
 917
 918     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_SLIRP,
 919                                  vlan, NULL, model, name, NULL,
 920                                  slirp_receive, NULL, NULL,
 921                                  net_slirp_cleanup, s);
 922     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 923              "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');
 924     return 0;
 925 }
 926
 927 static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
 928                                 const char *stack)
 929 {
 930     VLANClientState *vc;
 931
 932     if (vlan) {
 933         vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
 934         if (!vc) {
 935             return NULL;
 936         }
 937         if (strcmp(vc->model, "user")) {
 938             monitor_printf(mon, "invalid device specified\n");
 939             return NULL;
 940         }
 941         return vc->opaque;
 942     } else {
 943         if (QTAILQ_EMPTY(&slirp_stacks)) {
 944             monitor_printf(mon, "user mode network stack not in use\n");
 945             return NULL;
 946         }
 947         return QTAILQ_FIRST(&slirp_stacks);
 948     }
 949 }
 950
 951 void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
 952 {
 953     struct in_addr host_addr = { .s_addr = INADDR_ANY };
 954     int host_port;
 955     char buf[256] = "";
 956     const char *src_str, *p;
 957     SlirpState *s;
 958     int is_udp = 0;
 959     int err;
 960     const char *arg1 = qdict_get_str(qdict, "arg1");
 961     const char *arg2 = qdict_get_try_str(qdict, "arg2");
 962     const char *arg3 = qdict_get_try_str(qdict, "arg3");
 963
 964     if (arg2) {
 965         s = slirp_lookup(mon, arg1, arg2);
 966         src_str = arg3;
 967     } else {
 968         s = slirp_lookup(mon, NULL, NULL);
 969         src_str = arg1;
 970     }
 971     if (!s) {
 972         return;
 973     }
 974
 975     if (!src_str || !src_str[0])
 976         goto fail_syntax;
 977
 978     p = src_str;
 979     get_str_sep(buf, sizeof(buf), &p, ':');
 980
 981     if (!strcmp(buf, "tcp") || buf[0] == '\0') {
 982         is_udp = 0;
 983     } else if (!strcmp(buf, "udp")) {
 984         is_udp = 1;
 985     } else {
 986         goto fail_syntax;
 987     }
 988
 989     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
 990         goto fail_syntax;
 991     }
 992     if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
 993         goto fail_syntax;
 994     }
 995
 996     host_port = atoi(p);
 997
 998     err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
 999                                host_addr, host_port);
1000
1001     monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
1002                    err ? "removed" : "not found");
1003     return;
1004
1005  fail_syntax:
1006     monitor_printf(mon, "invalid format\n");
1007 }
1008
1009 static int slirp_hostfwd(SlirpState *s, const char *redir_str,
1010                          int legacy_format)
1011 {
1012     struct in_addr host_addr = { .s_addr = INADDR_ANY };
1013     struct in_addr guest_addr = { .s_addr = 0 };
1014     int host_port, guest_port;
1015     const char *p;
1016     char buf[256];
1017     int is_udp;
1018     char *end;
1019
1020     p = redir_str;
1021     if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1022         goto fail_syntax;
1023     }
1024     if (!strcmp(buf, "tcp") || buf[0] == '\0') {
1025         is_udp = 0;
1026     } else if (!strcmp(buf, "udp")) {
1027         is_udp = 1;
1028     } else {
1029         goto fail_syntax;
1030     }
1031
1032     if (!legacy_format) {
1033         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1034             goto fail_syntax;
1035         }
1036         if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
1037             goto fail_syntax;
1038         }
1039     }
1040
1041     if (get_str_sep(buf, sizeof(buf), &p, legacy_format ? ':' : '-') < 0) {
1042         goto fail_syntax;
1043     }
1044     host_port = strtol(buf, &end, 0);
1045     if (*end != '\0' || host_port < 1 || host_port > 65535) {
1046         goto fail_syntax;
1047     }
1048
1049     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1050         goto fail_syntax;
1051     }
1052     if (buf[0] != '\0' && !inet_aton(buf, &guest_addr)) {
1053         goto fail_syntax;
1054     }
1055
1056     guest_port = strtol(p, &end, 0);
1057     if (*end != '\0' || guest_port < 1 || guest_port > 65535) {
1058         goto fail_syntax;
1059     }
1060
1061     if (slirp_add_hostfwd(s->slirp, is_udp, host_addr, host_port, guest_addr,
1062                           guest_port) < 0) {
1063         qemu_error("could not set up host forwarding rule '%s'\n",
1064                    redir_str);
1065         return -1;
1066     }
1067     return 0;
1068
1069  fail_syntax:
1070     qemu_error("invalid host forwarding rule '%s'\n", redir_str);
1071     return -1;
1072 }
1073
1074 void net_slirp_hostfwd_add(Monitor *mon, const QDict *qdict)
1075 {
1076     const char *redir_str;
1077     SlirpState *s;
1078     const char *arg1 = qdict_get_str(qdict, "arg1");
1079     const char *arg2 = qdict_get_try_str(qdict, "arg2");
1080     const char *arg3 = qdict_get_try_str(qdict, "arg3");
1081
1082     if (arg2) {
1083         s = slirp_lookup(mon, arg1, arg2);
1084         redir_str = arg3;
1085     } else {
1086         s = slirp_lookup(mon, NULL, NULL);
1087         redir_str = arg1;
1088     }
1089     if (s) {
1090         slirp_hostfwd(s, redir_str, 0);
1091     }
1092
1093 }
1094
1095 int net_slirp_redir(const char *redir_str)
1096 {
1097     struct slirp_config_str *config;
1098
1099     if (QTAILQ_EMPTY(&slirp_stacks)) {
1100         config = qemu_malloc(sizeof(*config));
1101         pstrcpy(config->str, sizeof(config->str), redir_str);
1102         config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
1103         config->next = slirp_configs;
1104         slirp_configs = config;
1105         return 0;
1106     }
1107
1108     return slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), redir_str, 1);
1109 }
1110
1111 #ifndef _WIN32
1112
1113 /* automatic user mode samba server configuration */
1114 static void slirp_smb_cleanup(SlirpState *s)
1115 {
1116     char cmd[128];
1117
1118     if (s->smb_dir[0] != '\0') {
1119         snprintf(cmd, sizeof(cmd), "rm -rf %s", s->smb_dir);
1120         system(cmd);
1121         s->smb_dir[0] = '\0';
1122     }
1123 }
1124
1125 static int slirp_smb(SlirpState* s, const char *exported_dir,
1126                      struct in_addr vserver_addr)
1127 {
1128     static int instance;
1129     char smb_conf[128];
1130     char smb_cmdline[128];
1131     FILE *f;
1132
1133     snprintf(s->smb_dir, sizeof(s->smb_dir), "/tmp/qemu-smb.%ld-%d",
1134              (long)getpid(), instance++);
1135     if (mkdir(s->smb_dir, 0700) < 0) {
1136         qemu_error("could not create samba server dir '%s'\n", s->smb_dir);
1137         return -1;
1138     }
1139     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", s->smb_dir, "smb.conf");
1140
1141     f = fopen(smb_conf, "w");
1142     if (!f) {
1143         slirp_smb_cleanup(s);
1144         qemu_error("could not create samba server configuration file '%s'\n",
1145                    smb_conf);
1146         return -1;
1147     }
1148     fprintf(f,
1149             "[global]\n"
1150             "private dir=%s\n"
1151             "smb ports=0\n"
1152             "socket address=127.0.0.1\n"
1153             "pid directory=%s\n"
1154             "lock directory=%s\n"
1155             "log file=%s/log.smbd\n"
1156             "smb passwd file=%s/smbpasswd\n"
1157             "security = share\n"
1158             "[qemu]\n"
1159             "path=%s\n"
1160             "read only=no\n"
1161             "guest ok=yes\n",
1162             s->smb_dir,
1163             s->smb_dir,
1164             s->smb_dir,
1165             s->smb_dir,
1166             s->smb_dir,
1167             exported_dir
1168             );
1169     fclose(f);
1170
1171     snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
1172              SMBD_COMMAND, smb_conf);
1173
1174     if (slirp_add_exec(s->slirp, 0, smb_cmdline, &vserver_addr, 139) < 0) {
1175         slirp_smb_cleanup(s);
1176         qemu_error("conflicting/invalid smbserver address\n");
1177         return -1;
1178     }
1179     return 0;
1180 }
1181
1182 /* automatic user mode samba server configuration (legacy interface) */
1183 int net_slirp_smb(const char *exported_dir)
1184 {
1185     struct in_addr vserver_addr = { .s_addr = 0 };
1186
1187     if (legacy_smb_export) {
1188         fprintf(stderr, "-smb given twice\n");
1189         return -1;
1190     }
1191     legacy_smb_export = exported_dir;
1192     if (!QTAILQ_EMPTY(&slirp_stacks)) {
1193         return slirp_smb(QTAILQ_FIRST(&slirp_stacks), exported_dir,
1194                          vserver_addr);
1195     }
1196     return 0;
1197 }
1198
1199 #endif /* !defined(_WIN32) */
1200
1201 struct GuestFwd {
1202     CharDriverState *hd;
1203     struct in_addr server;
1204     int port;
1205     Slirp *slirp;
1206 };
1207
1208 static int guestfwd_can_read(void *opaque)
1209 {
1210     struct GuestFwd *fwd = opaque;
1211     return slirp_socket_can_recv(fwd->slirp, fwd->server, fwd->port);
1212 }
1213
1214 static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
1215 {
1216     struct GuestFwd *fwd = opaque;
1217     slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
1218 }
1219
1220 static int slirp_guestfwd(SlirpState *s, const char *config_str,
1221                           int legacy_format)
1222 {
1223     struct in_addr server = { .s_addr = 0 };
1224     struct GuestFwd *fwd;
1225     const char *p;
1226     char buf[128];
1227     char *end;
1228     int port;
1229
1230     p = config_str;
1231     if (legacy_format) {
1232         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1233             goto fail_syntax;
1234         }
1235     } else {
1236         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1237             goto fail_syntax;
1238         }
1239         if (strcmp(buf, "tcp") && buf[0] != '\0') {
1240             goto fail_syntax;
1241         }
1242         if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1243             goto fail_syntax;
1244         }
1245         if (buf[0] != '\0' && !inet_aton(buf, &server)) {
1246             goto fail_syntax;
1247         }
1248         if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
1249             goto fail_syntax;
1250         }
1251     }
1252     port = strtol(buf, &end, 10);
1253     if (*end != '\0' || port < 1 || port > 65535) {
1254         goto fail_syntax;
1255     }
1256
1257     fwd = qemu_malloc(sizeof(struct GuestFwd));
1258     snprintf(buf, sizeof(buf), "guestfwd.tcp:%d", port);
1259     fwd->hd = qemu_chr_open(buf, p, NULL);
1260     if (!fwd->hd) {
1261         qemu_error("could not open guest forwarding device '%s'\n", buf);
1262         qemu_free(fwd);
1263         return -1;
1264     }
1265
1266     if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) {
1267         qemu_error("conflicting/invalid host:port in guest forwarding "
1268                    "rule '%s'\n", config_str);
1269         qemu_free(fwd);
1270         return -1;
1271     }
1272     fwd->server = server;
1273     fwd->port = port;
1274     fwd->slirp = s->slirp;
1275
1276     qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
1277                           NULL, fwd);
1278     return 0;
1279
1280  fail_syntax:
1281     qemu_error("invalid guest forwarding rule '%s'\n", config_str);
1282     return -1;
1283 }
1284
1285 void do_info_usernet(Monitor *mon)
1286 {
1287     SlirpState *s;
1288
1289     QTAILQ_FOREACH(s, &slirp_stacks, entry) {
1290         monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
1291         slirp_connection_info(s->slirp, mon);
1292     }
1293 }
1294
1295 #endif /* CONFIG_SLIRP */
1296
1297 #if defined(_WIN32)
1298 int tap_has_vnet_hdr(VLANClientState *vc)
1299 {
1300     return 0;
1301 }
1302 void tap_using_vnet_hdr(VLANClientState *vc, int using_vnet_hdr)
1303 {
1304 }
1305 #else /* !defined(_WIN32) */
1306
1307 /* Maximum GSO packet size (64k) plus plenty of room for
1308  * the ethernet and virtio_net headers
1309  */
1310 #define TAP_BUFSIZE (4096 + 65536)
1311
1312 typedef struct TAPState {
1313     VLANClientState *vc;
1314     int fd;
1315     char down_script[1024];
1316     char down_script_arg[128];
1317     uint8_t buf[TAP_BUFSIZE];
1318     unsigned int read_poll : 1;
1319     unsigned int write_poll : 1;
1320     unsigned int has_vnet_hdr : 1;
1321     unsigned int using_vnet_hdr : 1;
1322 } TAPState;
1323
1324 static int launch_script(const char *setup_script, const char *ifname, int fd);
1325
1326 static int tap_can_send(void *opaque);
1327 static void tap_send(void *opaque);
1328 static void tap_writable(void *opaque);
1329
1330 static void tap_update_fd_handler(TAPState *s)
1331 {
1332     qemu_set_fd_handler2(s->fd,
1333                          s->read_poll  ? tap_can_send : NULL,
1334                          s->read_poll  ? tap_send     : NULL,
1335                          s->write_poll ? tap_writable : NULL,
1336                          s);
1337 }
1338
1339 static void tap_read_poll(TAPState *s, int enable)
1340 {
1341     s->read_poll = !!enable;
1342     tap_update_fd_handler(s);
1343 }
1344
1345 static void tap_write_poll(TAPState *s, int enable)
1346 {
1347     s->write_poll = !!enable;
1348     tap_update_fd_handler(s);
1349 }
1350
1351 static void tap_writable(void *opaque)
1352 {
1353     TAPState *s = opaque;
1354
1355     tap_write_poll(s, 0);
1356
1357     qemu_flush_queued_packets(s->vc);
1358 }
1359
1360 static ssize_t tap_write_packet(TAPState *s, const struct iovec *iov, int iovcnt)
1361 {
1362     ssize_t len;
1363
1364     do {
1365         len = writev(s->fd, iov, iovcnt);
1366     } while (len == -1 && errno == EINTR);
1367
1368     if (len == -1 && errno == EAGAIN) {
1369         tap_write_poll(s, 1);
1370         return 0;
1371     }
1372
1373     return len;
1374 }
1375
1376 static ssize_t tap_receive_iov(VLANClientState *vc, const struct iovec *iov,
1377                                int iovcnt)
1378 {
1379     TAPState *s = vc->opaque;
1380     const struct iovec *iovp = iov;
1381     struct iovec iov_copy[iovcnt + 1];
1382     struct virtio_net_hdr hdr = { 0, };
1383
1384     if (s->has_vnet_hdr && !s->using_vnet_hdr) {
1385         iov_copy[0].iov_base = &hdr;
1386         iov_copy[0].iov_len =  sizeof(hdr);
1387         memcpy(&iov_copy[1], iov, iovcnt * sizeof(*iov));
1388         iovp = iov_copy;
1389         iovcnt++;
1390     }
1391
1392     return tap_write_packet(s, iovp, iovcnt);
1393 }
1394
1395 static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1396 {
1397     TAPState *s = vc->opaque;
1398     struct iovec iov[2];
1399     int iovcnt = 0;
1400     struct virtio_net_hdr hdr = { 0, };
1401
1402     if (s->has_vnet_hdr && !s->using_vnet_hdr) {
1403         iov[iovcnt].iov_base = &hdr;
1404         iov[iovcnt].iov_len  = sizeof(hdr);
1405         iovcnt++;
1406     }
1407
1408     iov[iovcnt].iov_base = (char *)buf;
1409     iov[iovcnt].iov_len  = size;
1410     iovcnt++;
1411
1412     return tap_write_packet(s, iov, iovcnt);
1413 }
1414
1415 static int tap_can_send(void *opaque)
1416 {
1417     TAPState *s = opaque;
1418
1419     return qemu_can_send_packet(s->vc);
1420 }
1421
1422 #ifdef __sun__
1423 static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1424 {
1425     struct strbuf sbuf;
1426     int f = 0;
1427
1428     sbuf.maxlen = maxlen;
1429     sbuf.buf = (char *)buf;
1430
1431     return getmsg(tapfd, NULL, &sbuf, &f) >= 0 ? sbuf.len : -1;
1432 }
1433 #else
1434 static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1435 {
1436     return read(tapfd, buf, maxlen);
1437 }
1438 #endif
1439
1440 static void tap_send_completed(VLANClientState *vc, ssize_t len)
1441 {
1442     TAPState *s = vc->opaque;
1443     tap_read_poll(s, 1);
1444 }
1445
1446 static void tap_send(void *opaque)
1447 {
1448     TAPState *s = opaque;
1449     int size;
1450
1451     do {
1452         uint8_t *buf = s->buf;
1453
1454         size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
1455         if (size <= 0) {
1456             break;
1457         }
1458
1459         if (s->has_vnet_hdr && !s->using_vnet_hdr) {
1460             buf  += sizeof(struct virtio_net_hdr);
1461             size -= sizeof(struct virtio_net_hdr);
1462         }
1463
1464         size = qemu_send_packet_async(s->vc, buf, size, tap_send_completed);
1465         if (size == 0) {
1466             tap_read_poll(s, 0);
1467         }
1468     } while (size > 0);
1469 }
1470
1471 /* sndbuf should be set to a value lower than the tx queue
1472  * capacity of any destination network interface.
1473  * Ethernet NICs generally have txqueuelen=1000, so 1Mb is
1474  * a good default, given a 1500 byte MTU.
1475  */
1476 #define TAP_DEFAULT_SNDBUF 1024*1024
1477
1478 static int tap_set_sndbuf(TAPState *s, QemuOpts *opts)
1479 {
1480     int sndbuf;
1481
1482     sndbuf = qemu_opt_get_size(opts, "sndbuf", TAP_DEFAULT_SNDBUF);
1483     if (!sndbuf) {
1484         sndbuf = INT_MAX;
1485     }
1486
1487     if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1 && qemu_opt_get(opts, "sndbuf")) {
1488         qemu_error("TUNSETSNDBUF ioctl failed: %s\n", strerror(errno));
1489         return -1;
1490     }
1491     return 0;
1492 }
1493
1494 int tap_has_vnet_hdr(VLANClientState *vc)
1495 {
1496     TAPState *s = vc->opaque;
1497
1498     assert(vc->type == NET_CLIENT_TYPE_TAP);
1499
1500     return s->has_vnet_hdr;
1501 }
1502
1503 void tap_using_vnet_hdr(VLANClientState *vc, int using_vnet_hdr)
1504 {
1505     TAPState *s = vc->opaque;
1506
1507     using_vnet_hdr = using_vnet_hdr != 0;
1508
1509     assert(vc->type == NET_CLIENT_TYPE_TAP);
1510     assert(s->has_vnet_hdr == using_vnet_hdr);
1511
1512     s->using_vnet_hdr = using_vnet_hdr;
1513 }
1514
1515 static int tap_probe_vnet_hdr(int fd)
1516 {
1517     struct ifreq ifr;
1518
1519     if (ioctl(fd, TUNGETIFF, &ifr) != 0) {
1520         qemu_error("TUNGETIFF ioctl() failed: %s\n", strerror(errno));
1521         return 0;
1522     }
1523
1524     return ifr.ifr_flags & IFF_VNET_HDR;
1525 }
1526
1527 static void tap_cleanup(VLANClientState *vc)
1528 {
1529     TAPState *s = vc->opaque;
1530
1531     qemu_purge_queued_packets(vc);
1532
1533     if (s->down_script[0])
1534         launch_script(s->down_script, s->down_script_arg, s->fd);
1535
1536     tap_read_poll(s, 0);
1537     tap_write_poll(s, 0);
1538     close(s->fd);
1539     qemu_free(s);
1540 }
1541
1542 /* fd support */
1543
1544 static TAPState *net_tap_fd_init(VLANState *vlan,
1545                                  const char *model,
1546                                  const char *name,
1547                                  int fd,
1548                                  int vnet_hdr)
1549 {
1550     TAPState *s;
1551
1552     s = qemu_mallocz(sizeof(TAPState));
1553     s->fd = fd;
1554     s->has_vnet_hdr = vnet_hdr != 0;
1555     s->using_vnet_hdr = 0;
1556     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_TAP,
1557                                  vlan, NULL, model, name, NULL,
1558                                  tap_receive, NULL, tap_receive_iov,
1559                                  tap_cleanup, s);
1560     tap_read_poll(s, 1);
1561     return s;
1562 }
1563
1564 #if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__)
1565 static int tap_open(char *ifname, int ifname_size,
1566                     int *vnet_hdr, int vnet_hdr_required)
1567 {
1568     int fd;
1569     char *dev;
1570     struct stat s;
1571
1572     TFR(fd = open("/dev/tap", O_RDWR));
1573     if (fd < 0) {
1574         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1575         return -1;
1576     }
1577
1578     fstat(fd, &s);
1579     dev = devname(s.st_rdev, S_IFCHR);
1580     pstrcpy(ifname, ifname_size, dev);
1581
1582     fcntl(fd, F_SETFL, O_NONBLOCK);
1583     return fd;
1584 }
1585 #elif defined(__sun__)
1586 #define TUNNEWPPA       (('T'<<16) | 0x0001)
1587 /*
1588  * Allocate TAP device, returns opened fd.
1589  * Stores dev name in the first arg(must be large enough).
1590  */
1591 static int tap_alloc(char *dev, size_t dev_size)
1592 {
1593     int tap_fd, if_fd, ppa = -1;
1594     static int ip_fd = 0;
1595     char *ptr;
1596
1597     static int arp_fd = 0;
1598     int ip_muxid, arp_muxid;
1599     struct strioctl  strioc_if, strioc_ppa;
1600     int link_type = I_PLINK;;
1601     struct lifreq ifr;
1602     char actual_name[32] = "";
1603
1604     memset(&ifr, 0x0, sizeof(ifr));
1605
1606     if( *dev ){
1607        ptr = dev;
1608        while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
1609        ppa = atoi(ptr);
1610     }
1611
1612     /* Check if IP device was opened */
1613     if( ip_fd )
1614        close(ip_fd);
1615
1616     TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
1617     if (ip_fd < 0) {
1618        syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
1619        return -1;
1620     }
1621
1622     TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
1623     if (tap_fd < 0) {
1624        syslog(LOG_ERR, "Can't open /dev/tap");
1625        return -1;
1626     }
1627
1628     /* Assign a new PPA and get its unit number. */
1629     strioc_ppa.ic_cmd = TUNNEWPPA;
1630     strioc_ppa.ic_timout = 0;
1631     strioc_ppa.ic_len = sizeof(ppa);
1632     strioc_ppa.ic_dp = (char *)&ppa;
1633     if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
1634        syslog (LOG_ERR, "Can't assign new interface");
1635
1636     TFR(if_fd = open("/dev/tap", O_RDWR, 0));
1637     if (if_fd < 0) {
1638        syslog(LOG_ERR, "Can't open /dev/tap (2)");
1639        return -1;
1640     }
1641     if(ioctl(if_fd, I_PUSH, "ip") < 0){
1642        syslog(LOG_ERR, "Can't push IP module");
1643        return -1;
1644     }
1645
1646     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
1647         syslog(LOG_ERR, "Can't get flags\n");
1648
1649     snprintf (actual_name, 32, "tap%d", ppa);
1650     pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1651
1652     ifr.lifr_ppa = ppa;
1653     /* Assign ppa according to the unit number returned by tun device */
1654
1655     if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
1656         syslog (LOG_ERR, "Can't set PPA %d", ppa);
1657     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
1658         syslog (LOG_ERR, "Can't get flags\n");
1659     /* Push arp module to if_fd */
1660     if (ioctl (if_fd, I_PUSH, "arp") < 0)
1661         syslog (LOG_ERR, "Can't push ARP module (2)");
1662
1663     /* Push arp module to ip_fd */
1664     if (ioctl (ip_fd, I_POP, NULL) < 0)
1665         syslog (LOG_ERR, "I_POP failed\n");
1666     if (ioctl (ip_fd, I_PUSH, "arp") < 0)
1667         syslog (LOG_ERR, "Can't push ARP module (3)\n");
1668     /* Open arp_fd */
1669     TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
1670     if (arp_fd < 0)
1671        syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
1672
1673     /* Set ifname to arp */
1674     strioc_if.ic_cmd = SIOCSLIFNAME;
1675     strioc_if.ic_timout = 0;
1676     strioc_if.ic_len = sizeof(ifr);
1677     strioc_if.ic_dp = (char *)&ifr;
1678     if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
1679         syslog (LOG_ERR, "Can't set ifname to arp\n");
1680     }
1681
1682     if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
1683        syslog(LOG_ERR, "Can't link TAP device to IP");
1684        return -1;
1685     }
1686
1687     if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
1688         syslog (LOG_ERR, "Can't link TAP device to ARP");
1689
1690     close (if_fd);
1691
1692     memset(&ifr, 0x0, sizeof(ifr));
1693     pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1694     ifr.lifr_ip_muxid  = ip_muxid;
1695     ifr.lifr_arp_muxid = arp_muxid;
1696
1697     if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
1698     {
1699       ioctl (ip_fd, I_PUNLINK , arp_muxid);
1700       ioctl (ip_fd, I_PUNLINK, ip_muxid);
1701       syslog (LOG_ERR, "Can't set multiplexor id");
1702     }
1703
1704     snprintf(dev, dev_size, "tap%d", ppa);
1705     return tap_fd;
1706 }
1707
1708 static int tap_open(char *ifname, int ifname_size,
1709                     int *vnet_hdr, int vnet_hdr_required)
1710 {
1711     char  dev[10]="";
1712     int fd;
1713     if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
1714        fprintf(stderr, "Cannot allocate TAP device\n");
1715        return -1;
1716     }
1717     pstrcpy(ifname, ifname_size, dev);
1718     fcntl(fd, F_SETFL, O_NONBLOCK);
1719     return fd;
1720 }
1721 #elif defined (_AIX)
1722 static int tap_open(char *ifname, int ifname_size,
1723                     int *vnet_hdr, int vnet_hdr_required)
1724 {
1725     fprintf (stderr, "no tap on AIX\n");
1726     return -1;
1727 }
1728 #else
1729 static int tap_open(char *ifname, int ifname_size,
1730                     int *vnet_hdr, int vnet_hdr_required)
1731 {
1732     struct ifreq ifr;
1733     int fd, ret;
1734
1735     TFR(fd = open("/dev/net/tun", O_RDWR));
1736     if (fd < 0) {
1737         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1738         return -1;
1739     }
1740     memset(&ifr, 0, sizeof(ifr));
1741     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1742
1743     if (*vnet_hdr) {
1744         unsigned int features;
1745
1746         if (ioctl(fd, TUNGETFEATURES, &features) == 0 &&
1747             features & IFF_VNET_HDR) {
1748             *vnet_hdr = 1;
1749             ifr.ifr_flags |= IFF_VNET_HDR;
1750         }
1751
1752         if (vnet_hdr_required && !*vnet_hdr) {
1753             qemu_error("vnet_hdr=1 requested, but no kernel "
1754                        "support for IFF_VNET_HDR available");
1755             close(fd);
1756             return -1;
1757         }
1758     }
1759
1760     if (ifname[0] != '\0')
1761         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
1762     else
1763         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
1764     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1765     if (ret != 0) {
1766         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1767         close(fd);
1768         return -1;
1769     }
1770     pstrcpy(ifname, ifname_size, ifr.ifr_name);
1771     fcntl(fd, F_SETFL, O_NONBLOCK);
1772     return fd;
1773 }
1774 #endif
1775
1776 static int launch_script(const char *setup_script, const char *ifname, int fd)
1777 {
1778     sigset_t oldmask, mask;
1779     int pid, status;
1780     char *args[3];
1781     char **parg;
1782
1783     sigemptyset(&mask);
1784     sigaddset(&mask, SIGCHLD);
1785     sigprocmask(SIG_BLOCK, &mask, &oldmask);
1786
1787     /* try to launch network script */
1788     pid = fork();
1789     if (pid == 0) {
1790         int open_max = sysconf(_SC_OPEN_MAX), i;
1791
1792         for (i = 0; i < open_max; i++) {
1793             if (i != STDIN_FILENO &&
1794                 i != STDOUT_FILENO &&
1795                 i != STDERR_FILENO &&
1796                 i != fd) {
1797                 close(i);
1798             }
1799         }
1800         parg = args;
1801         *parg++ = (char *)setup_script;
1802         *parg++ = (char *)ifname;
1803         *parg++ = NULL;
1804         execv(setup_script, args);
1805         _exit(1);
1806     } else if (pid > 0) {
1807         while (waitpid(pid, &status, 0) != pid) {
1808             /* loop */
1809         }
1810         sigprocmask(SIG_SETMASK, &oldmask, NULL);
1811
1812         if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
1813             return 0;
1814         }
1815     }
1816     fprintf(stderr, "%s: could not launch network script\n", setup_script);
1817     return -1;
1818 }
1819
1820 static int net_tap_init(QemuOpts *opts, int *vnet_hdr)
1821 {
1822     int fd, vnet_hdr_required;
1823     char ifname[128] = {0,};
1824     const char *setup_script;
1825
1826     if (qemu_opt_get(opts, "ifname")) {
1827         pstrcpy(ifname, sizeof(ifname), qemu_opt_get(opts, "ifname"));
1828     }
1829
1830     *vnet_hdr = qemu_opt_get_bool(opts, "vnet_hdr", 1);
1831     if (qemu_opt_get(opts, "vnet_hdr")) {
1832         vnet_hdr_required = *vnet_hdr;
1833     } else {
1834         vnet_hdr_required = 0;
1835     }
1836
1837     TFR(fd = tap_open(ifname, sizeof(ifname), vnet_hdr, vnet_hdr_required));
1838     if (fd < 0) {
1839         return -1;
1840     }
1841
1842     setup_script = qemu_opt_get(opts, "script");
1843     if (setup_script &&
1844         setup_script[0] != '\0' &&
1845         strcmp(setup_script, "no") != 0 &&
1846         launch_script(setup_script, ifname, fd)) {
1847         close(fd);
1848         return -1;
1849     }
1850
1851     qemu_opt_set(opts, "ifname", ifname);
1852
1853     return fd;
1854 }
1855
1856 #endif /* !_WIN32 */
1857
1858 #if defined(CONFIG_VDE)
1859 typedef struct VDEState {
1860     VLANClientState *vc;
1861     VDECONN *vde;
1862 } VDEState;
1863
1864 static void vde_to_qemu(void *opaque)
1865 {
1866     VDEState *s = opaque;
1867     uint8_t buf[4096];
1868     int size;
1869
1870     size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
1871     if (size > 0) {
1872         qemu_send_packet(s->vc, buf, size);
1873     }
1874 }
1875
1876 static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1877 {
1878     VDEState *s = vc->opaque;
1879     ssize_t ret;
1880
1881     do {
1882       ret = vde_send(s->vde, (const char *)buf, size, 0);
1883     } while (ret < 0 && errno == EINTR);
1884
1885     return ret;
1886 }
1887
1888 static void vde_cleanup(VLANClientState *vc)
1889 {
1890     VDEState *s = vc->opaque;
1891     qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
1892     vde_close(s->vde);
1893     qemu_free(s);
1894 }
1895
1896 static int net_vde_init(VLANState *vlan, const char *model,
1897                         const char *name, const char *sock,
1898                         int port, const char *group, int mode)
1899 {
1900     VDEState *s;
1901     char *init_group = (char *)group;
1902     char *init_sock = (char *)sock;
1903
1904     struct vde_open_args args = {
1905         .port = port,
1906         .group = init_group,
1907         .mode = mode,
1908     };
1909
1910     s = qemu_mallocz(sizeof(VDEState));
1911     s->vde = vde_open(init_sock, (char *)"QEMU", &args);
1912     if (!s->vde){
1913         free(s);
1914         return -1;
1915     }
1916     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_VDE,
1917                                  vlan, NULL, model, name, NULL,
1918                                  vde_receive, NULL, NULL,
1919                                  vde_cleanup, s);
1920     qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
1921     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
1922              sock, vde_datafd(s->vde));
1923     return 0;
1924 }
1925 #endif
1926
1927 /* network connection */
1928 typedef struct NetSocketState {
1929     VLANClientState *vc;
1930     int fd;
1931     int state; /* 0 = getting length, 1 = getting data */
1932     unsigned int index;
1933     unsigned int packet_len;
1934     uint8_t buf[4096];
1935     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1936 } NetSocketState;
1937
1938 typedef struct NetSocketListenState {
1939     VLANState *vlan;
1940     char *model;
1941     char *name;
1942     int fd;
1943 } NetSocketListenState;
1944
1945 /* XXX: we consider we can send the whole packet without blocking */
1946 static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1947 {
1948     NetSocketState *s = vc->opaque;
1949     uint32_t len;
1950     len = htonl(size);
1951
1952     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
1953     return send_all(s->fd, buf, size);
1954 }
1955
1956 static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
1957 {
1958     NetSocketState *s = vc->opaque;
1959
1960     return sendto(s->fd, (const void *)buf, size, 0,
1961                   (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
1962 }
1963
1964 static void net_socket_send(void *opaque)
1965 {
1966     NetSocketState *s = opaque;
1967     int size, err;
1968     unsigned l;
1969     uint8_t buf1[4096];
1970     const uint8_t *buf;
1971
1972     size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
1973     if (size < 0) {
1974         err = socket_error();
1975         if (err != EWOULDBLOCK)
1976             goto eoc;
1977     } else if (size == 0) {
1978         /* end of connection */
1979     eoc:
1980         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1981         closesocket(s->fd);
1982         return;
1983     }
1984     buf = buf1;
1985     while (size > 0) {
1986         /* reassemble a packet from the network */
1987         switch(s->state) {
1988         case 0:
1989             l = 4 - s->index;
1990             if (l > size)
1991                 l = size;
1992             memcpy(s->buf + s->index, buf, l);
1993             buf += l;
1994             size -= l;
1995             s->index += l;
1996             if (s->index == 4) {
1997                 /* got length */
1998                 s->packet_len = ntohl(*(uint32_t *)s->buf);
1999                 s->index = 0;
2000                 s->state = 1;
2001             }
2002             break;
2003         case 1:
2004             l = s->packet_len - s->index;
2005             if (l > size)
2006                 l = size;
2007             if (s->index + l <= sizeof(s->buf)) {
2008                 memcpy(s->buf + s->index, buf, l);
2009             } else {
2010                 fprintf(stderr, "serious error: oversized packet received,"
2011                     "connection terminated.\n");
2012                 s->state = 0;
2013                 goto eoc;
2014             }
2015
2016             s->index += l;
2017             buf += l;
2018             size -= l;
2019             if (s->index >= s->packet_len) {
2020                 qemu_send_packet(s->vc, s->buf, s->packet_len);
2021                 s->index = 0;
2022                 s->state = 0;
2023             }
2024             break;
2025         }
2026     }
2027 }
2028
2029 static void net_socket_send_dgram(void *opaque)
2030 {
2031     NetSocketState *s = opaque;
2032     int size;
2033
2034     size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
2035     if (size < 0)
2036         return;
2037     if (size == 0) {
2038         /* end of connection */
2039         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2040         return;
2041     }
2042     qemu_send_packet(s->vc, s->buf, size);
2043 }
2044
2045 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
2046 {
2047     struct ip_mreq imr;
2048     int fd;
2049     int val, ret;
2050     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
2051         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
2052                 inet_ntoa(mcastaddr->sin_addr),
2053                 (int)ntohl(mcastaddr->sin_addr.s_addr));
2054         return -1;
2055
2056     }
2057     fd = socket(PF_INET, SOCK_DGRAM, 0);
2058     if (fd < 0) {
2059         perror("socket(PF_INET, SOCK_DGRAM)");
2060         return -1;
2061     }
2062
2063     val = 1;
2064     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2065                    (const char *)&val, sizeof(val));
2066     if (ret < 0) {
2067         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
2068         goto fail;
2069     }
2070
2071     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
2072     if (ret < 0) {
2073         perror("bind");
2074         goto fail;
2075     }
2076
2077     /* Add host to multicast group */
2078     imr.imr_multiaddr = mcastaddr->sin_addr;
2079     imr.imr_interface.s_addr = htonl(INADDR_ANY);
2080
2081     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
2082                      (const char *)&imr, sizeof(struct ip_mreq));
2083     if (ret < 0) {
2084         perror("setsockopt(IP_ADD_MEMBERSHIP)");
2085         goto fail;
2086     }
2087
2088     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
2089     val = 1;
2090     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
2091                    (const char *)&val, sizeof(val));
2092     if (ret < 0) {
2093         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
2094         goto fail;
2095     }
2096
2097     socket_set_nonblock(fd);
2098     return fd;
2099 fail:
2100     if (fd >= 0)
2101         closesocket(fd);
2102     return -1;
2103 }
2104
2105 static void net_socket_cleanup(VLANClientState *vc)
2106 {
2107     NetSocketState *s = vc->opaque;
2108     qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2109     close(s->fd);
2110     qemu_free(s);
2111 }
2112
2113 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
2114                                                 const char *model,
2115                                                 const char *name,
2116                                                 int fd, int is_connected)
2117 {
2118     struct sockaddr_in saddr;
2119     int newfd;
2120     socklen_t saddr_len;
2121     NetSocketState *s;
2122
2123     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
2124      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
2125      * by ONLY ONE process: we must "clone" this dgram socket --jjo
2126      */
2127
2128     if (is_connected) {
2129         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
2130             /* must be bound */
2131             if (saddr.sin_addr.s_addr==0) {
2132                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
2133                         fd);
2134                 return NULL;
2135             }
2136             /* clone dgram socket */
2137             newfd = net_socket_mcast_create(&saddr);
2138             if (newfd < 0) {
2139                 /* error already reported by net_socket_mcast_create() */
2140                 close(fd);
2141                 return NULL;
2142             }
2143             /* clone newfd to fd, close newfd */
2144             dup2(newfd, fd);
2145             close(newfd);
2146
2147         } else {
2148             fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
2149                     fd, strerror(errno));
2150             return NULL;
2151         }
2152     }
2153
2154     s = qemu_mallocz(sizeof(NetSocketState));
2155     s->fd = fd;
2156
2157     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_SOCKET,
2158                                  vlan, NULL, model, name, NULL,
2159                                  net_socket_receive_dgram, NULL, NULL,
2160                                  net_socket_cleanup, s);
2161     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2162
2163     /* mcast: save bound address as dst */
2164     if (is_connected) s->dgram_dst=saddr;
2165
2166     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2167             "socket: fd=%d (%s mcast=%s:%d)",
2168             fd, is_connected? "cloned" : "",
2169             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2170     return s;
2171 }
2172
2173 static void net_socket_connect(void *opaque)
2174 {
2175     NetSocketState *s = opaque;
2176     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2177 }
2178
2179 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
2180                                                  const char *model,
2181                                                  const char *name,
2182                                                  int fd, int is_connected)
2183 {
2184     NetSocketState *s;
2185     s = qemu_mallocz(sizeof(NetSocketState));
2186     s->fd = fd;
2187     s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_SOCKET,
2188                                  vlan, NULL, model, name, NULL,
2189                                  net_socket_receive, NULL, NULL,
2190                                  net_socket_cleanup, s);
2191     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2192              "socket: fd=%d", fd);
2193     if (is_connected) {
2194         net_socket_connect(s);
2195     } else {
2196         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2197     }
2198     return s;
2199 }
2200
2201 static NetSocketState *net_socket_fd_init(VLANState *vlan,
2202                                           const char *model, const char *name,
2203                                           int fd, int is_connected)
2204 {
2205     int so_type = -1, optlen=sizeof(so_type);
2206
2207     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
2208         (socklen_t *)&optlen)< 0) {
2209         fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
2210         return NULL;
2211     }
2212     switch(so_type) {
2213     case SOCK_DGRAM:
2214         return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
2215     case SOCK_STREAM:
2216         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
2217     default:
2218         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2219         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
2220         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
2221     }
2222     return NULL;
2223 }
2224
2225 static void net_socket_accept(void *opaque)
2226 {
2227     NetSocketListenState *s = opaque;
2228     NetSocketState *s1;
2229     struct sockaddr_in saddr;
2230     socklen_t len;
2231     int fd;
2232
2233     for(;;) {
2234         len = sizeof(saddr);
2235         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2236         if (fd < 0 && errno != EINTR) {
2237             return;
2238         } else if (fd >= 0) {
2239             break;
2240         }
2241     }
2242     s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
2243     if (!s1) {
2244         closesocket(fd);
2245     } else {
2246         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2247                  "socket: connection from %s:%d",
2248                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2249     }
2250 }
2251
2252 static int net_socket_listen_init(VLANState *vlan,
2253                                   const char *model,
2254                                   const char *name,
2255                                   const char *host_str)
2256 {
2257     NetSocketListenState *s;
2258     int fd, val, ret;
2259     struct sockaddr_in saddr;
2260
2261     if (parse_host_port(&saddr, host_str) < 0)
2262         return -1;
2263
2264     s = qemu_mallocz(sizeof(NetSocketListenState));
2265
2266     fd = socket(PF_INET, SOCK_STREAM, 0);
2267     if (fd < 0) {
2268         perror("socket");
2269         return -1;
2270     }
2271     socket_set_nonblock(fd);
2272
2273     /* allow fast reuse */
2274     val = 1;
2275     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2276
2277     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2278     if (ret < 0) {
2279         perror("bind");
2280         return -1;
2281     }
2282     ret = listen(fd, 0);
2283     if (ret < 0) {
2284         perror("listen");
2285         return -1;
2286     }
2287     s->vlan = vlan;
2288     s->model = qemu_strdup(model);
2289     s->name = name ? qemu_strdup(name) : NULL;
2290     s->fd = fd;
2291     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2292     return 0;
2293 }
2294
2295 static int net_socket_connect_init(VLANState *vlan,
2296                                    const char *model,
2297                                    const char *name,
2298                                    const char *host_str)
2299 {
2300     NetSocketState *s;
2301     int fd, connected, ret, err;
2302     struct sockaddr_in saddr;
2303
2304     if (parse_host_port(&saddr, host_str) < 0)
2305         return -1;
2306
2307     fd = socket(PF_INET, SOCK_STREAM, 0);
2308     if (fd < 0) {
2309         perror("socket");
2310         return -1;
2311     }
2312     socket_set_nonblock(fd);
2313
2314     connected = 0;
2315     for(;;) {
2316         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2317         if (ret < 0) {
2318             err = socket_error();
2319             if (err == EINTR || err == EWOULDBLOCK) {
2320             } else if (err == EINPROGRESS) {
2321                 break;
2322 #ifdef _WIN32
2323             } else if (err == WSAEALREADY) {
2324                 break;
2325 #endif
2326             } else {
2327                 perror("connect");
2328                 closesocket(fd);
2329                 return -1;
2330             }
2331         } else {
2332             connected = 1;
2333             break;
2334         }
2335     }
2336     s = net_socket_fd_init(vlan, model, name, fd, connected);
2337     if (!s)
2338         return -1;
2339     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2340              "socket: connect to %s:%d",
2341              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2342     return 0;
2343 }
2344
2345 static int net_socket_mcast_init(VLANState *vlan,
2346                                  const char *model,
2347                                  const char *name,
2348                                  const char *host_str)
2349 {
2350     NetSocketState *s;
2351     int fd;
2352     struct sockaddr_in saddr;
2353
2354     if (parse_host_port(&saddr, host_str) < 0)
2355         return -1;
2356
2357
2358     fd = net_socket_mcast_create(&saddr);
2359     if (fd < 0)
2360         return -1;
2361
2362     s = net_socket_fd_init(vlan, model, name, fd, 0);
2363     if (!s)
2364         return -1;
2365
2366     s->dgram_dst = saddr;
2367
2368     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2369              "socket: mcast=%s:%d",
2370              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2371     return 0;
2372
2373 }
2374
2375 typedef struct DumpState {
2376     VLANClientState *pcap_vc;
2377     int fd;
2378     int pcap_caplen;
2379 } DumpState;
2380
2381 #define PCAP_MAGIC 0xa1b2c3d4
2382
2383 struct pcap_file_hdr {
2384     uint32_t magic;
2385     uint16_t version_major;
2386     uint16_t version_minor;
2387     int32_t thiszone;
2388     uint32_t sigfigs;
2389     uint32_t snaplen;
2390     uint32_t linktype;
2391 };
2392
2393 struct pcap_sf_pkthdr {
2394     struct {
2395         int32_t tv_sec;
2396         int32_t tv_usec;
2397     } ts;
2398     uint32_t caplen;
2399     uint32_t len;
2400 };
2401
2402 static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
2403 {
2404     DumpState *s = vc->opaque;
2405     struct pcap_sf_pkthdr hdr;
2406     int64_t ts;
2407     int caplen;
2408
2409     /* Early return in case of previous error. */
2410     if (s->fd < 0) {
2411         return size;
2412     }
2413
2414     ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
2415     caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
2416
2417     hdr.ts.tv_sec = ts / 1000000;
2418     hdr.ts.tv_usec = ts % 1000000;
2419     hdr.caplen = caplen;
2420     hdr.len = size;
2421     if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
2422         write(s->fd, buf, caplen) != caplen) {
2423         qemu_log("-net dump write error - stop dump\n");
2424         close(s->fd);
2425         s->fd = -1;
2426     }
2427
2428     return size;
2429 }
2430
2431 static void net_dump_cleanup(VLANClientState *vc)
2432 {
2433     DumpState *s = vc->opaque;
2434
2435     close(s->fd);
2436     qemu_free(s);
2437 }
2438
2439 static int net_dump_init(VLANState *vlan, const char *device,
2440                          const char *name, const char *filename, int len)
2441 {
2442     struct pcap_file_hdr hdr;
2443     DumpState *s;
2444
2445     s = qemu_malloc(sizeof(DumpState));
2446
2447     s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
2448     if (s->fd < 0) {
2449         qemu_error("-net dump: can't open %s\n", filename);
2450         return -1;
2451     }
2452
2453     s->pcap_caplen = len;
2454
2455     hdr.magic = PCAP_MAGIC;
2456     hdr.version_major = 2;
2457     hdr.version_minor = 4;
2458     hdr.thiszone = 0;
2459     hdr.sigfigs = 0;
2460     hdr.snaplen = s->pcap_caplen;
2461     hdr.linktype = 1;
2462
2463     if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
2464         qemu_error("-net dump write error: %s\n", strerror(errno));
2465         close(s->fd);
2466         qemu_free(s);
2467         return -1;
2468     }
2469
2470     s->pcap_vc = qemu_new_vlan_client(NET_CLIENT_TYPE_DUMP,
2471                                       vlan, NULL, device, name, NULL,
2472                                       dump_receive, NULL, NULL,
2473                                       net_dump_cleanup, s);
2474     snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str),
2475              "dump to %s (len=%d)", filename, len);
2476     return 0;
2477 }
2478
2479 /* find or alloc a new VLAN */
2480 VLANState *qemu_find_vlan(int id, int allocate)
2481 {
2482     VLANState *vlan;
2483
2484     QTAILQ_FOREACH(vlan, &vlans, next) {
2485         if (vlan->id == id) {
2486             return vlan;
2487         }
2488     }
2489
2490     if (!allocate) {
2491         return NULL;
2492     }
2493
2494     vlan = qemu_mallocz(sizeof(VLANState));
2495     vlan->id = id;
2496     QTAILQ_INIT(&vlan->clients);
2497
2498     vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
2499                                           qemu_vlan_deliver_packet_iov,
2500                                           vlan);
2501
2502     QTAILQ_INSERT_TAIL(&vlans, vlan, next);
2503
2504     return vlan;
2505 }
2506
2507 VLANClientState *qemu_find_netdev(const char *id)
2508 {
2509     VLANClientState *vc;
2510
2511     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
2512         if (!strcmp(vc->name, id)) {
2513             return vc;
2514         }
2515     }
2516
2517     return NULL;
2518 }
2519
2520 static int nic_get_free_idx(void)
2521 {
2522     int index;
2523
2524     for (index = 0; index < MAX_NICS; index++)
2525         if (!nd_table[index].used)
2526             return index;
2527     return -1;
2528 }
2529
2530 int qemu_show_nic_models(const char *arg, const char *const *models)
2531 {
2532     int i;
2533
2534     if (!arg || strcmp(arg, "?"))
2535         return 0;
2536
2537     fprintf(stderr, "qemu: Supported NIC models: ");
2538     for (i = 0 ; models[i]; i++)
2539         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
2540     return 1;
2541 }
2542
2543 void qemu_check_nic_model(NICInfo *nd, const char *model)
2544 {
2545     const char *models[2];
2546
2547     models[0] = model;
2548     models[1] = NULL;
2549
2550     if (qemu_show_nic_models(nd->model, models))
2551         exit(0);
2552     if (qemu_find_nic_model(nd, models, model) < 0)
2553         exit(1);
2554 }
2555
2556 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
2557                         const char *default_model)
2558 {
2559     int i;
2560
2561     if (!nd->model)
2562         nd->model = qemu_strdup(default_model);
2563
2564     for (i = 0 ; models[i]; i++) {
2565         if (strcmp(nd->model, models[i]) == 0)
2566             return i;
2567     }
2568
2569     qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
2570     return -1;
2571 }
2572
2573 static int net_handle_fd_param(Monitor *mon, const char *param)
2574 {
2575     if (!qemu_isdigit(param[0])) {
2576         int fd;
2577
2578         fd = monitor_get_fd(mon, param);
2579         if (fd == -1) {
2580             qemu_error("No file descriptor named %s found", param);
2581             return -1;
2582         }
2583
2584         return fd;
2585     } else {
2586         return strtol(param, NULL, 0);
2587     }
2588 }
2589
2590 static int net_init_nic(QemuOpts *opts,
2591                         Monitor *mon,
2592                         const char *name,
2593                         VLANState *vlan)
2594 {
2595     int idx;
2596     NICInfo *nd;
2597     const char *netdev;
2598
2599     idx = nic_get_free_idx();
2600     if (idx == -1 || nb_nics >= MAX_NICS) {
2601         qemu_error("Too Many NICs\n");
2602         return -1;
2603     }
2604
2605     nd = &nd_table[idx];
2606
2607     memset(nd, 0, sizeof(*nd));
2608
2609     if ((netdev = qemu_opt_get(opts, "netdev"))) {
2610         nd->netdev = qemu_find_netdev(netdev);
2611         if (!nd->netdev) {
2612             qemu_error("netdev '%s' not found\n", netdev);
2613             return -1;
2614         }
2615     } else {
2616         assert(vlan);
2617         nd->vlan = vlan;
2618     }
2619     if (name) {
2620         nd->name = qemu_strdup(name);
2621     }
2622     if (qemu_opt_get(opts, "model")) {
2623         nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
2624     }
2625     if (qemu_opt_get(opts, "addr")) {
2626         nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
2627     }
2628
2629     nd->macaddr[0] = 0x52;
2630     nd->macaddr[1] = 0x54;
2631     nd->macaddr[2] = 0x00;
2632     nd->macaddr[3] = 0x12;
2633     nd->macaddr[4] = 0x34;
2634     nd->macaddr[5] = 0x56 + idx;
2635
2636     if (qemu_opt_get(opts, "macaddr") &&
2637         parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
2638         qemu_error("invalid syntax for ethernet address\n");
2639         return -1;
2640     }
2641
2642     nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
2643     if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
2644         (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
2645         qemu_error("invalid # of vectors: %d\n", nd->nvectors);
2646         return -1;
2647     }
2648
2649     nd->used = 1;
2650     if (vlan) {
2651         nd->vlan->nb_guest_devs++;
2652     }
2653     nb_nics++;
2654
2655     return idx;
2656 }
2657
2658 #if defined(CONFIG_SLIRP)
2659 static int net_init_slirp_configs(const char *name, const char *value, void *opaque)
2660 {
2661     struct slirp_config_str *config;
2662
2663     if (strcmp(name, "hostfwd") != 0 && strcmp(name, "guestfwd") != 0) {
2664         return 0;
2665     }
2666
2667     config = qemu_mallocz(sizeof(*config));
2668
2669     pstrcpy(config->str, sizeof(config->str), value);
2670
2671     if (!strcmp(name, "hostfwd")) {
2672         config->flags = SLIRP_CFG_HOSTFWD;
2673     }
2674
2675     config->next = slirp_configs;
2676     slirp_configs = config;
2677
2678     return 0;
2679 }
2680
2681 static int net_init_slirp(QemuOpts *opts,
2682                           Monitor *mon,
2683                           const char *name,
2684                           VLANState *vlan)
2685 {
2686     struct slirp_config_str *config;
2687     const char *vhost;
2688     const char *vhostname;
2689     const char *vdhcp_start;
2690     const char *vnamesrv;
2691     const char *tftp_export;
2692     const char *bootfile;
2693     const char *smb_export;
2694     const char *vsmbsrv;
2695     char *vnet = NULL;
2696     int restricted = 0;
2697     int ret;
2698
2699     vhost       = qemu_opt_get(opts, "host");
2700     vhostname   = qemu_opt_get(opts, "hostname");
2701     vdhcp_start = qemu_opt_get(opts, "dhcpstart");
2702     vnamesrv    = qemu_opt_get(opts, "dns");
2703     tftp_export = qemu_opt_get(opts, "tftp");
2704     bootfile    = qemu_opt_get(opts, "bootfile");
2705     smb_export  = qemu_opt_get(opts, "smb");
2706     vsmbsrv     = qemu_opt_get(opts, "smbserver");
2707
2708     if (qemu_opt_get(opts, "ip")) {
2709         const char *ip = qemu_opt_get(opts, "ip");
2710         int l = strlen(ip) + strlen("/24") + 1;
2711
2712         vnet = qemu_malloc(l);
2713
2714         /* emulate legacy ip= parameter */
2715         pstrcpy(vnet, l, ip);
2716         pstrcat(vnet, l, "/24");
2717     }
2718
2719     if (qemu_opt_get(opts, "net")) {
2720         if (vnet) {
2721             qemu_free(vnet);
2722         }
2723         vnet = qemu_strdup(qemu_opt_get(opts, "net"));
2724     }
2725
2726     if (qemu_opt_get(opts, "restrict") &&
2727         qemu_opt_get(opts, "restrict")[0] == 'y') {
2728         restricted = 1;
2729     }
2730
2731     qemu_opt_foreach(opts, net_init_slirp_configs, NULL, 0);
2732
2733     ret = net_slirp_init(vlan, "user", name, restricted, vnet, vhost,
2734                          vhostname, tftp_export, bootfile, vdhcp_start,
2735                          vnamesrv, smb_export, vsmbsrv);
2736
2737     while (slirp_configs) {
2738         config = slirp_configs;
2739         slirp_configs = config->next;
2740         qemu_free(config);
2741     }
2742
2743     if (ret != -1 && vlan) {
2744         vlan->nb_host_devs++;
2745     }
2746
2747     qemu_free(vnet);
2748
2749     return ret;
2750 }
2751 #endif /* CONFIG_SLIRP */
2752
2753 #ifdef _WIN32
2754 static int net_init_tap_win32(QemuOpts *opts,
2755                               Monitor *mon,
2756                               const char *name,
2757                               VLANState *vlan)
2758 {
2759     const char *ifname;
2760
2761     ifname = qemu_opt_get(opts, "ifname");
2762
2763     if (!ifname) {
2764         qemu_error("tap: no interface name\n");
2765         return -1;
2766     }
2767
2768     if (tap_win32_init(vlan, "tap", name, ifname) == -1) {
2769         return -1;
2770     }
2771
2772     if (vlan) {
2773         vlan->nb_host_devs++;
2774     }
2775
2776     return 0;
2777 }
2778 #elif !defined(_AIX)
2779 static int net_init_tap(QemuOpts *opts,
2780                         Monitor *mon,
2781                         const char *name,
2782                         VLANState *vlan)
2783 {
2784     TAPState *s;
2785     int fd, vnet_hdr;
2786
2787     if (qemu_opt_get(opts, "fd")) {
2788         if (qemu_opt_get(opts, "ifname") ||
2789             qemu_opt_get(opts, "script") ||
2790             qemu_opt_get(opts, "downscript") ||
2791             qemu_opt_get(opts, "vnet_hdr")) {
2792             qemu_error("ifname=, script=, downscript= and vnet_hdr= is invalid with fd=\n");
2793             return -1;
2794         }
2795
2796         fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2797         if (fd == -1) {
2798             return -1;
2799         }
2800
2801         fcntl(fd, F_SETFL, O_NONBLOCK);
2802
2803         vnet_hdr = tap_probe_vnet_hdr(fd);
2804     } else {
2805         if (!qemu_opt_get(opts, "script")) {
2806             qemu_opt_set(opts, "script", DEFAULT_NETWORK_SCRIPT);
2807         }
2808
2809         if (!qemu_opt_get(opts, "downscript")) {
2810             qemu_opt_set(opts, "downscript", DEFAULT_NETWORK_DOWN_SCRIPT);
2811         }
2812
2813         fd = net_tap_init(opts, &vnet_hdr);
2814     }
2815
2816     s = net_tap_fd_init(vlan, "tap", name, fd, vnet_hdr);
2817     if (!s) {
2818         close(fd);
2819         return -1;
2820     }
2821
2822     if (tap_set_sndbuf(s, opts) < 0) {
2823         return -1;
2824     }
2825
2826     if (qemu_opt_get(opts, "fd")) {
2827         snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
2828     } else {
2829         const char *ifname, *script, *downscript;
2830
2831         ifname     = qemu_opt_get(opts, "ifname");
2832         script     = qemu_opt_get(opts, "script");
2833         downscript = qemu_opt_get(opts, "downscript");
2834
2835         snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2836                  "ifname=%s,script=%s,downscript=%s",
2837                  ifname, script, downscript);
2838
2839         if (strcmp(downscript, "no") != 0) {
2840             snprintf(s->down_script, sizeof(s->down_script), "%s", downscript);
2841             snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
2842         }
2843     }
2844
2845     if (vlan) {
2846         vlan->nb_host_devs++;
2847     }
2848
2849     return 0;
2850 }
2851 #endif
2852
2853 static int net_init_socket(QemuOpts *opts,
2854                            Monitor *mon,
2855                            const char *name,
2856                            VLANState *vlan)
2857 {
2858     if (qemu_opt_get(opts, "fd")) {
2859         int fd;
2860
2861         if (qemu_opt_get(opts, "listen") ||
2862             qemu_opt_get(opts, "connect") ||
2863             qemu_opt_get(opts, "mcast")) {
2864             qemu_error("listen=, connect= and mcast= is invalid with fd=\n");
2865             return -1;
2866         }
2867
2868         fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2869         if (fd == -1) {
2870             return -1;
2871         }
2872
2873         if (!net_socket_fd_init(vlan, "socket", name, fd, 1)) {
2874             close(fd);
2875             return -1;
2876         }
2877     } else if (qemu_opt_get(opts, "listen")) {
2878         const char *listen;
2879
2880         if (qemu_opt_get(opts, "fd") ||
2881             qemu_opt_get(opts, "connect") ||
2882             qemu_opt_get(opts, "mcast")) {
2883             qemu_error("fd=, connect= and mcast= is invalid with listen=\n");
2884             return -1;
2885         }
2886
2887         listen = qemu_opt_get(opts, "listen");
2888
2889         if (net_socket_listen_init(vlan, "socket", name, listen) == -1) {
2890             return -1;
2891         }
2892     } else if (qemu_opt_get(opts, "connect")) {
2893         const char *connect;
2894
2895         if (qemu_opt_get(opts, "fd") ||
2896             qemu_opt_get(opts, "listen") ||
2897             qemu_opt_get(opts, "mcast")) {
2898             qemu_error("fd=, listen= and mcast= is invalid with connect=\n");
2899             return -1;
2900         }
2901
2902         connect = qemu_opt_get(opts, "connect");
2903
2904         if (net_socket_connect_init(vlan, "socket", name, connect) == -1) {
2905             return -1;
2906         }
2907     } else if (qemu_opt_get(opts, "mcast")) {
2908         const char *mcast;
2909
2910         if (qemu_opt_get(opts, "fd") ||
2911             qemu_opt_get(opts, "connect") ||
2912             qemu_opt_get(opts, "listen")) {
2913             qemu_error("fd=, connect= and listen= is invalid with mcast=\n");
2914             return -1;
2915         }
2916
2917         mcast = qemu_opt_get(opts, "mcast");
2918
2919         if (net_socket_mcast_init(vlan, "socket", name, mcast) == -1) {
2920             return -1;
2921         }
2922     } else {
2923         qemu_error("-socket requires fd=, listen=, connect= or mcast=\n");
2924         return -1;
2925     }
2926
2927     if (vlan) {
2928         vlan->nb_host_devs++;
2929     }
2930
2931     return 0;
2932 }
2933
2934 #ifdef CONFIG_VDE
2935 static int net_init_vde(QemuOpts *opts,
2936                         Monitor *mon,
2937                         const char *name,
2938                         VLANState *vlan)
2939 {
2940     const char *sock;
2941     const char *group;
2942     int port, mode;
2943
2944     sock  = qemu_opt_get(opts, "sock");
2945     group = qemu_opt_get(opts, "group");
2946
2947     port = qemu_opt_get_number(opts, "port", 0);
2948     mode = qemu_opt_get_number(opts, "mode", 0700);
2949
2950     if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
2951         return -1;
2952     }
2953
2954     if (vlan) {
2955         vlan->nb_host_devs++;
2956     }
2957
2958     return 0;
2959 }
2960 #endif
2961
2962 static int net_init_dump(QemuOpts *opts,
2963                          Monitor *mon,
2964                          const char *name,
2965                          VLANState *vlan)
2966 {
2967     int len;
2968     const char *file;
2969     char def_file[128];
2970
2971     assert(vlan);
2972
2973     file = qemu_opt_get(opts, "file");
2974     if (!file) {
2975         snprintf(def_file, sizeof(def_file), "qemu-vlan%d.pcap", vlan->id);
2976         file = def_file;
2977     }
2978
2979     len = qemu_opt_get_size(opts, "len", 65536);
2980
2981     return net_dump_init(vlan, "dump", name, file, len);
2982 }
2983
2984 #define NET_COMMON_PARAMS_DESC                     \
2985     {                                              \
2986         .name = "type",                            \
2987         .type = QEMU_OPT_STRING,                   \
2988         .help = "net client type (nic, tap etc.)", \
2989      }, {                                          \
2990         .name = "vlan",                            \
2991         .type = QEMU_OPT_NUMBER,                   \
2992         .help = "vlan number",                     \
2993      }, {                                          \
2994         .name = "name",                            \
2995         .type = QEMU_OPT_STRING,                   \
2996         .help = "identifier for monitor commands", \
2997      }
2998
2999 typedef int (*net_client_init_func)(QemuOpts *opts,
3000                                     Monitor *mon,
3001                                     const char *name,
3002                                     VLANState *vlan);
3003
3004 /* magic number, but compiler will warn if too small */
3005 #define NET_MAX_DESC 20
3006
3007 static struct {
3008     const char *type;
3009     net_client_init_func init;
3010     QemuOptDesc desc[NET_MAX_DESC];
3011 } net_client_types[] = {
3012     {
3013         .type = "none",
3014         .desc = {
3015             NET_COMMON_PARAMS_DESC,
3016             { /* end of list */ }
3017         },
3018     }, {
3019         .type = "nic",
3020         .init = net_init_nic,
3021         .desc = {
3022             NET_COMMON_PARAMS_DESC,
3023             {
3024                 .name = "netdev",
3025                 .type = QEMU_OPT_STRING,
3026                 .help = "id of -netdev to connect to",
3027             },
3028             {
3029                 .name = "macaddr",
3030                 .type = QEMU_OPT_STRING,
3031                 .help = "MAC address",
3032             }, {
3033                 .name = "model",
3034                 .type = QEMU_OPT_STRING,
3035                 .help = "device model (e1000, rtl8139, virtio etc.)",
3036             }, {
3037                 .name = "addr",
3038                 .type = QEMU_OPT_STRING,
3039                 .help = "PCI device address",
3040             }, {
3041                 .name = "vectors",
3042                 .type = QEMU_OPT_NUMBER,
3043                 .help = "number of MSI-x vectors, 0 to disable MSI-X",
3044             },
3045             { /* end of list */ }
3046         },
3047 #ifdef CONFIG_SLIRP
3048     }, {
3049         .type = "user",
3050         .init = net_init_slirp,
3051         .desc = {
3052             NET_COMMON_PARAMS_DESC,
3053             {
3054                 .name = "hostname",
3055                 .type = QEMU_OPT_STRING,
3056                 .help = "client hostname reported by the builtin DHCP server",
3057             }, {
3058                 .name = "restrict",
3059                 .type = QEMU_OPT_STRING,
3060                 .help = "isolate the guest from the host (y|yes|n|no)",
3061             }, {
3062                 .name = "ip",
3063                 .type = QEMU_OPT_STRING,
3064                 .help = "legacy parameter, use net= instead",
3065             }, {
3066                 .name = "net",
3067                 .type = QEMU_OPT_STRING,
3068                 .help = "IP address and optional netmask",
3069             }, {
3070                 .name = "host",
3071                 .type = QEMU_OPT_STRING,
3072                 .help = "guest-visible address of the host",
3073             }, {
3074                 .name = "tftp",
3075                 .type = QEMU_OPT_STRING,
3076                 .help = "root directory of the built-in TFTP server",
3077             }, {
3078                 .name = "bootfile",
3079                 .type = QEMU_OPT_STRING,
3080                 .help = "BOOTP filename, for use with tftp=",
3081             }, {
3082                 .name = "dhcpstart",
3083                 .type = QEMU_OPT_STRING,
3084                 .help = "the first of the 16 IPs the built-in DHCP server can assign",
3085             }, {
3086                 .name = "dns",
3087                 .type = QEMU_OPT_STRING,
3088                 .help = "guest-visible address of the virtual nameserver",
3089             }, {
3090                 .name = "smb",
3091                 .type = QEMU_OPT_STRING,
3092                 .help = "root directory of the built-in SMB server",
3093             }, {
3094                 .name = "smbserver",
3095                 .type = QEMU_OPT_STRING,
3096                 .help = "IP address of the built-in SMB server",
3097             }, {
3098                 .name = "hostfwd",
3099                 .type = QEMU_OPT_STRING,
3100                 .help = "guest port number to forward incoming TCP or UDP connections",
3101             }, {
3102                 .name = "guestfwd",
3103                 .type = QEMU_OPT_STRING,
3104                 .help = "IP address and port to forward guest TCP connections",
3105             },
3106             { /* end of list */ }
3107         },
3108 #endif
3109 #ifdef _WIN32
3110     }, {
3111         .type = "tap",
3112         .init = net_init_tap_win32,
3113         .desc = {
3114             NET_COMMON_PARAMS_DESC,
3115             {
3116                 .name = "ifname",
3117                 .type = QEMU_OPT_STRING,
3118                 .help = "interface name",
3119             },
3120             { /* end of list */ }
3121         },
3122 #elif !defined(_AIX)
3123     }, {
3124         .type = "tap",
3125         .init = net_init_tap,
3126         .desc = {
3127             NET_COMMON_PARAMS_DESC,
3128             {
3129                 .name = "fd",
3130                 .type = QEMU_OPT_STRING,
3131                 .help = "file descriptor of an already opened tap",
3132             }, {
3133                 .name = "ifname",
3134                 .type = QEMU_OPT_STRING,
3135                 .help = "interface name",
3136             }, {
3137                 .name = "script",
3138                 .type = QEMU_OPT_STRING,
3139                 .help = "script to initialize the interface",
3140             }, {
3141                 .name = "downscript",
3142                 .type = QEMU_OPT_STRING,
3143                 .help = "script to shut down the interface",
3144             }, {
3145                 .name = "sndbuf",
3146                 .type = QEMU_OPT_SIZE,
3147                 .help = "send buffer limit"
3148             }, {
3149                 .name = "vnet_hdr",
3150                 .type = QEMU_OPT_BOOL,
3151                 .help = "enable the IFF_VNET_HDR flag on the tap interface"
3152             },
3153             { /* end of list */ }
3154         },
3155 #endif
3156     }, {
3157         .type = "socket",
3158         .init = net_init_socket,
3159         .desc = {
3160             NET_COMMON_PARAMS_DESC,
3161             {
3162                 .name = "fd",
3163                 .type = QEMU_OPT_STRING,
3164                 .help = "file descriptor of an already opened socket",
3165             }, {
3166                 .name = "listen",
3167                 .type = QEMU_OPT_STRING,
3168                 .help = "port number, and optional hostname, to listen on",
3169             }, {
3170                 .name = "connect",
3171                 .type = QEMU_OPT_STRING,
3172                 .help = "port number, and optional hostname, to connect to",
3173             }, {
3174                 .name = "mcast",
3175                 .type = QEMU_OPT_STRING,
3176                 .help = "UDP multicast address and port number",
3177             },
3178             { /* end of list */ }
3179         },
3180 #ifdef CONFIG_VDE
3181     }, {
3182         .type = "vde",
3183         .init = net_init_vde,
3184         .desc = {
3185             NET_COMMON_PARAMS_DESC,
3186             {
3187                 .name = "sock",
3188                 .type = QEMU_OPT_STRING,
3189                 .help = "socket path",
3190             }, {
3191                 .name = "port",
3192                 .type = QEMU_OPT_NUMBER,
3193                 .help = "port number",
3194             }, {
3195                 .name = "group",
3196                 .type = QEMU_OPT_STRING,
3197                 .help = "group owner of socket",
3198             }, {
3199                 .name = "mode",
3200                 .type = QEMU_OPT_NUMBER,
3201                 .help = "permissions for socket",
3202             },
3203             { /* end of list */ }
3204         },
3205 #endif
3206     }, {
3207         .type = "dump",
3208         .init = net_init_dump,
3209         .desc = {
3210             NET_COMMON_PARAMS_DESC,
3211             {
3212                 .name = "len",
3213                 .type = QEMU_OPT_SIZE,
3214                 .help = "per-packet size limit (64k default)",
3215             }, {
3216                 .name = "file",
3217                 .type = QEMU_OPT_STRING,
3218                 .help = "dump file path (default is qemu-vlan0.pcap)",
3219             },
3220             { /* end of list */ }
3221         },
3222     },
3223     { /* end of list */ }
3224 };
3225
3226 int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
3227 {
3228     const char *name;
3229     const char *type;
3230     int i;
3231
3232     type = qemu_opt_get(opts, "type");
3233     if (!type) {
3234         qemu_error("No type specified for -net\n");
3235         return -1;
3236     }
3237
3238     if (is_netdev) {
3239         if (strcmp(type, "tap") != 0 &&
3240 #ifdef CONFIG_SLIRP
3241             strcmp(type, "user") != 0 &&
3242 #endif
3243 #ifdef CONFIG_VDE
3244             strcmp(type, "vde") != 0 &&
3245 #endif
3246             strcmp(type, "socket") != 0) {
3247             qemu_error("The '%s' network backend type is not valid with -netdev\n",
3248                        type);
3249             return -1;
3250         }
3251
3252         if (qemu_opt_get(opts, "vlan")) {
3253             qemu_error("The 'vlan' parameter is not valid with -netdev\n");
3254             return -1;
3255         }
3256         if (qemu_opt_get(opts, "name")) {
3257             qemu_error("The 'name' parameter is not valid with -netdev\n");
3258             return -1;
3259         }
3260         if (!qemu_opts_id(opts)) {
3261             qemu_error("The id= parameter is required with -netdev\n");
3262             return -1;
3263         }
3264     }
3265
3266     name = qemu_opts_id(opts);
3267     if (!name) {
3268         name = qemu_opt_get(opts, "name");
3269     }
3270
3271     for (i = 0; net_client_types[i].type != NULL; i++) {
3272         if (!strcmp(net_client_types[i].type, type)) {
3273             VLANState *vlan = NULL;
3274
3275             if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
3276                 return -1;
3277             }
3278
3279             /* Do not add to a vlan if it's a -netdev or a nic with a
3280              * netdev= parameter. */
3281             if (!(is_netdev ||
3282                   (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
3283                 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
3284             }
3285
3286             if (net_client_types[i].init) {
3287                 return net_client_types[i].init(opts, mon, name, vlan);
3288             } else {
3289                 return 0;
3290             }
3291         }
3292     }
3293
3294     qemu_error("Invalid -net type '%s'\n", type);
3295     return -1;
3296 }
3297
3298 void net_client_uninit(NICInfo *nd)
3299 {
3300     if (nd->vlan) {
3301         nd->vlan->nb_guest_devs--;
3302     }
3303     nb_nics--;
3304
3305     qemu_free(nd->model);
3306     qemu_free(nd->name);
3307     qemu_free(nd->devaddr);
3308
3309     nd->used = 0;
3310 }
3311
3312 static int net_host_check_device(const char *device)
3313 {
3314     int i;
3315     const char *valid_param_list[] = { "tap", "socket", "dump"
3316 #ifdef CONFIG_SLIRP
3317                                        ,"user"
3318 #endif
3319 #ifdef CONFIG_VDE
3320                                        ,"vde"
3321 #endif
3322     };
3323     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
3324         if (!strncmp(valid_param_list[i], device,
3325                      strlen(valid_param_list[i])))
3326             return 1;
3327     }
3328
3329     return 0;
3330 }
3331
3332 void net_host_device_add(Monitor *mon, const QDict *qdict)
3333 {
3334     const char *device = qdict_get_str(qdict, "device");
3335     const char *opts_str = qdict_get_try_str(qdict, "opts");
3336     QemuOpts *opts;
3337
3338     if (!net_host_check_device(device)) {
3339         monitor_printf(mon, "invalid host network device %s\n", device);
3340         return;
3341     }
3342
3343     opts = qemu_opts_parse(&qemu_net_opts, opts_str ? opts_str : "", NULL);
3344     if (!opts) {
3345         monitor_printf(mon, "parsing network options '%s' failed\n",
3346                        opts_str ? opts_str : "");
3347         return;
3348     }
3349
3350     qemu_opt_set(opts, "type", device);
3351
3352     if (net_client_init(mon, opts, 0) < 0) {
3353         monitor_printf(mon, "adding host network device %s failed\n", device);
3354     }
3355 }
3356
3357 void net_host_device_remove(Monitor *mon, const QDict *qdict)
3358 {
3359     VLANClientState *vc;
3360     int vlan_id = qdict_get_int(qdict, "vlan_id");
3361     const char *device = qdict_get_str(qdict, "device");
3362
3363     vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
3364     if (!vc) {
3365         return;
3366     }
3367     if (!net_host_check_device(vc->model)) {
3368         monitor_printf(mon, "invalid host network device %s\n", device);
3369         return;
3370     }
3371     qemu_del_vlan_client(vc);
3372 }
3373
3374 void net_set_boot_mask(int net_boot_mask)
3375 {
3376     int i;
3377
3378     /* Only the first four NICs may be bootable */
3379     net_boot_mask = net_boot_mask & 0xF;
3380
3381     for (i = 0; i < nb_nics; i++) {
3382         if (net_boot_mask & (1 << i)) {
3383             nd_table[i].bootable = 1;
3384             net_boot_mask &= ~(1 << i);
3385         }
3386     }
3387
3388     if (net_boot_mask) {
3389         fprintf(stderr, "Cannot boot from non-existent NIC\n");
3390         exit(1);
3391     }
3392 }
3393
3394 void do_info_network(Monitor *mon)
3395 {
3396     VLANState *vlan;
3397
3398     QTAILQ_FOREACH(vlan, &vlans, next) {
3399         VLANClientState *vc;
3400
3401         monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
3402
3403         QTAILQ_FOREACH(vc, &vlan->clients, next) {
3404             monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
3405         }
3406     }
3407 }
3408
3409 void do_set_link(Monitor *mon, const QDict *qdict)
3410 {
3411     VLANState *vlan;
3412     VLANClientState *vc = NULL;
3413     const char *name = qdict_get_str(qdict, "name");
3414     const char *up_or_down = qdict_get_str(qdict, "up_or_down");
3415
3416     QTAILQ_FOREACH(vlan, &vlans, next) {
3417         QTAILQ_FOREACH(vc, &vlan->clients, next) {
3418             if (strcmp(vc->name, name) == 0) {
3419                 goto done;
3420             }
3421         }
3422     }
3423 done:
3424
3425     if (!vc) {
3426         monitor_printf(mon, "could not find network device '%s'\n", name);
3427         return;
3428     }
3429
3430     if (strcmp(up_or_down, "up") == 0)
3431         vc->link_down = 0;
3432     else if (strcmp(up_or_down, "down") == 0)
3433         vc->link_down = 1;
3434     else
3435         monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
3436                        "valid\n", up_or_down);
3437
3438     if (vc->link_status_changed)
3439         vc->link_status_changed(vc);
3440 }
3441
3442 void net_cleanup(void)
3443 {
3444     VLANState *vlan;
3445     VLANClientState *vc, *next_vc;
3446
3447     QTAILQ_FOREACH(vlan, &vlans, next) {
3448         QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
3449             qemu_del_vlan_client(vc);
3450         }
3451     }
3452
3453     QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
3454         qemu_del_vlan_client(vc);
3455     }
3456 }
3457
3458 static void net_check_clients(void)
3459 {
3460     VLANState *vlan;
3461
3462     QTAILQ_FOREACH(vlan, &vlans, next) {
3463         if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
3464             continue;
3465         if (vlan->nb_guest_devs == 0)
3466             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
3467         if (vlan->nb_host_devs == 0)
3468             fprintf(stderr,
3469                     "Warning: vlan %d is not connected to host network\n",
3470                     vlan->id);
3471     }
3472 }
3473
3474 static int net_init_client(QemuOpts *opts, void *dummy)
3475 {
3476     if (net_client_init(NULL, opts, 0) < 0)
3477         return -1;
3478     return 0;
3479 }
3480
3481 static int net_init_netdev(QemuOpts *opts, void *dummy)
3482 {
3483     return net_client_init(NULL, opts, 1);
3484 }
3485
3486 int net_init_clients(void)
3487 {
3488     if (QTAILQ_EMPTY(&qemu_net_opts.head)) {
3489         /* if no clients, we use a default config */
3490         qemu_opts_set(&qemu_net_opts, NULL, "type", "nic");
3491 #ifdef CONFIG_SLIRP
3492         qemu_opts_set(&qemu_net_opts, NULL, "type", "user");
3493 #endif
3494     }
3495
3496     QTAILQ_INIT(&vlans);
3497     QTAILQ_INIT(&non_vlan_clients);
3498
3499     if (qemu_opts_foreach(&qemu_netdev_opts, net_init_netdev, NULL, 1) == -1)
3500         return -1;
3501
3502     if (qemu_opts_foreach(&qemu_net_opts, net_init_client, NULL, 1) == -1) {
3503         return -1;
3504     }
3505
3506     net_check_clients();
3507
3508     return 0;
3509 }
3510
3511 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
3512 {
3513 #if defined(CONFIG_SLIRP)
3514     /* handle legacy -net channel,port:chr */
3515     if (!strcmp(opts_list->name, "net") &&
3516         !strncmp(optarg, "channel,", strlen("channel,"))) {
3517         int ret;
3518
3519         optarg += strlen("channel,");
3520
3521         if (QTAILQ_EMPTY(&slirp_stacks)) {
3522             struct slirp_config_str *config;
3523
3524             config = qemu_malloc(sizeof(*config));
3525             pstrcpy(config->str, sizeof(config->str), optarg);
3526             config->flags = SLIRP_CFG_LEGACY;
3527             config->next = slirp_configs;
3528             slirp_configs = config;
3529             ret = 0;
3530         } else {
3531             ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), optarg, 1);
3532         }
3533
3534         return ret;
3535     }
3536 #endif
3537     if (!qemu_opts_parse(opts_list, optarg, "type")) {
3538         return -1;
3539     }
3540
3541     return 0;
3542 }