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 "net.h"
  25
  26 #include "config-host.h"
  27
  28 #include "net/tap.h"
  29 #include "net/socket.h"
  30 #include "net/dump.h"
  31 #include "net/slirp.h"
  32 #include "net/vde.h"
  33 #include "net/util.h"
  34 #include "monitor.h"
  35 #include "sysemu.h"
  36 #include "qemu-common.h"
  37 #include "qemu_socket.h"
  38
  39 static QTAILQ_HEAD(, VLANState) vlans;
  40 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
  41
  42 int default_net = 1;
  43
  44 /***********************************************************/
  45 /* network device redirectors */
  46
  47 #if defined(DEBUG_NET)
  48 static void hex_dump(FILE *f, const uint8_t *buf, int size)
  49 {
  50     int len, i, j, c;
  51
  52     for(i=0;i<size;i+=16) {
  53         len = size - i;
  54         if (len > 16)
  55             len = 16;
  56         fprintf(f, "%08x ", i);
  57         for(j=0;j<16;j++) {
  58             if (j < len)
  59                 fprintf(f, " %02x", buf[i+j]);
  60             else
  61                 fprintf(f, "   ");
  62         }
  63         fprintf(f, " ");
  64         for(j=0;j<len;j++) {
  65             c = buf[i+j];
  66             if (c < ' ' || c > '~')
  67                 c = '.';
  68             fprintf(f, "%c", c);
  69         }
  70         fprintf(f, "\n");
  71     }
  72 }
  73 #endif
  74
  75 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
  76 {
  77     const char *p, *p1;
  78     int len;
  79     p = *pp;
  80     p1 = strchr(p, sep);
  81     if (!p1)
  82         return -1;
  83     len = p1 - p;
  84     p1++;
  85     if (buf_size > 0) {
  86         if (len > buf_size - 1)
  87             len = buf_size - 1;
  88         memcpy(buf, p, len);
  89         buf[len] = '\0';
  90     }
  91     *pp = p1;
  92     return 0;
  93 }
  94
  95 int parse_host_src_port(struct sockaddr_in *haddr,
  96                         struct sockaddr_in *saddr,
  97                         const char *input_str)
  98 {
  99     char *str = qemu_strdup(input_str);
 100     char *host_str = str;
 101     char *src_str;
 102     const char *src_str2;
 103     char *ptr;
 104
 105     /*
 106      * Chop off any extra arguments at the end of the string which
 107      * would start with a comma, then fill in the src port information
 108      * if it was provided else use the "any address" and "any port".
 109      */
 110     if ((ptr = strchr(str,',')))
 111         *ptr = '\0';
 112
 113     if ((src_str = strchr(input_str,'@'))) {
 114         *src_str = '\0';
 115         src_str++;
 116     }
 117
 118     if (parse_host_port(haddr, host_str) < 0)
 119         goto fail;
 120
 121     src_str2 = src_str;
 122     if (!src_str || *src_str == '\0')
 123         src_str2 = ":0";
 124
 125     if (parse_host_port(saddr, src_str2) < 0)
 126         goto fail;
 127
 128     free(str);
 129     return(0);
 130
 131 fail:
 132     free(str);
 133     return -1;
 134 }
 135
 136 int parse_host_port(struct sockaddr_in *saddr, const char *str)
 137 {
 138     char buf[512];
 139     struct hostent *he;
 140     const char *p, *r;
 141     int port;
 142
 143     p = str;
 144     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
 145         return -1;
 146     saddr->sin_family = AF_INET;
 147     if (buf[0] == '\0') {
 148         saddr->sin_addr.s_addr = 0;
 149     } else {
 150         if (qemu_isdigit(buf[0])) {
 151             if (!inet_aton(buf, &saddr->sin_addr))
 152                 return -1;
 153         } else {
 154             if ((he = gethostbyname(buf)) == NULL)
 155                 return - 1;
 156             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 157         }
 158     }
 159     port = strtol(p, (char **)&r, 0);
 160     if (r == p)
 161         return -1;
 162     saddr->sin_port = htons(port);
 163     return 0;
 164 }
 165
 166 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
 167 {
 168     snprintf(vc->info_str, sizeof(vc->info_str),
 169              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 170              vc->model,
 171              macaddr[0], macaddr[1], macaddr[2],
 172              macaddr[3], macaddr[4], macaddr[5]);
 173 }
 174
 175 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 176 {
 177     static int index = 0;
 178     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 179
 180     if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
 181         return;
 182     macaddr->a[0] = 0x52;
 183     macaddr->a[1] = 0x54;
 184     macaddr->a[2] = 0x00;
 185     macaddr->a[3] = 0x12;
 186     macaddr->a[4] = 0x34;
 187     macaddr->a[5] = 0x56 + index++;
 188 }
 189
 190 static char *assign_name(VLANClientState *vc1, const char *model)
 191 {
 192     VLANState *vlan;
 193     char buf[256];
 194     int id = 0;
 195
 196     QTAILQ_FOREACH(vlan, &vlans, next) {
 197         VLANClientState *vc;
 198
 199         QTAILQ_FOREACH(vc, &vlan->clients, next) {
 200             if (vc != vc1 && strcmp(vc->model, model) == 0) {
 201                 id++;
 202             }
 203         }
 204     }
 205
 206     snprintf(buf, sizeof(buf), "%s.%d", model, id);
 207
 208     return qemu_strdup(buf);
 209 }
 210
 211 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 212                                    unsigned flags,
 213                                    const uint8_t *data,
 214                                    size_t size,
 215                                    void *opaque);
 216 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 217                                        unsigned flags,
 218                                        const struct iovec *iov,
 219                                        int iovcnt,
 220                                        void *opaque);
 221
 222 VLANClientState *qemu_new_net_client(NetClientInfo *info,
 223                                      VLANState *vlan,
 224                                      VLANClientState *peer,
 225                                      const char *model,
 226                                      const char *name)
 227 {
 228     VLANClientState *vc;
 229
 230     assert(info->size >= sizeof(VLANClientState));
 231
 232     vc = qemu_mallocz(info->size);
 233
 234     vc->info = info;
 235     vc->model = qemu_strdup(model);
 236     if (name) {
 237         vc->name = qemu_strdup(name);
 238     } else {
 239         vc->name = assign_name(vc, model);
 240     }
 241
 242     if (vlan) {
 243         assert(!peer);
 244         vc->vlan = vlan;
 245         QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
 246     } else {
 247         if (peer) {
 248             vc->peer = peer;
 249             peer->peer = vc;
 250         }
 251         QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
 252
 253         vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
 254                                             qemu_deliver_packet_iov,
 255                                             vc);
 256     }
 257
 258     return vc;
 259 }
 260
 261 NICState *qemu_new_nic(NetClientInfo *info,
 262                        NICConf *conf,
 263                        const char *model,
 264                        const char *name,
 265                        void *opaque)
 266 {
 267     VLANClientState *nc;
 268     NICState *nic;
 269
 270     assert(info->type == NET_CLIENT_TYPE_NIC);
 271     assert(info->size >= sizeof(NICState));
 272
 273     nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
 274
 275     nic = DO_UPCAST(NICState, nc, nc);
 276     nic->conf = conf;
 277     nic->opaque = opaque;
 278
 279     return nic;
 280 }
 281
 282 void qemu_del_vlan_client(VLANClientState *vc)
 283 {
 284     if (vc->vlan) {
 285         QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
 286     } else {
 287         if (vc->send_queue) {
 288             qemu_del_net_queue(vc->send_queue);
 289         }
 290         QTAILQ_REMOVE(&non_vlan_clients, vc, next);
 291         if (vc->peer) {
 292             vc->peer->peer = NULL;
 293         }
 294     }
 295
 296     if (vc->info->cleanup) {
 297         vc->info->cleanup(vc);
 298     }
 299
 300     qemu_free(vc->name);
 301     qemu_free(vc->model);
 302     qemu_free(vc);
 303 }
 304
 305 VLANClientState *
 306 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
 307                               const char *client_str)
 308 {
 309     VLANState *vlan;
 310     VLANClientState *vc;
 311
 312     vlan = qemu_find_vlan(vlan_id, 0);
 313     if (!vlan) {
 314         monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
 315         return NULL;
 316     }
 317
 318     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 319         if (!strcmp(vc->name, client_str)) {
 320             break;
 321         }
 322     }
 323     if (!vc) {
 324         monitor_printf(mon, "can't find device %s on VLAN %d\n",
 325                        client_str, vlan_id);
 326     }
 327
 328     return vc;
 329 }
 330
 331 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
 332 {
 333     VLANClientState *nc;
 334     VLANState *vlan;
 335
 336     QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
 337         if (nc->info->type == NET_CLIENT_TYPE_NIC) {
 338             func(DO_UPCAST(NICState, nc, nc), opaque);
 339         }
 340     }
 341
 342     QTAILQ_FOREACH(vlan, &vlans, next) {
 343         QTAILQ_FOREACH(nc, &vlan->clients, next) {
 344             if (nc->info->type == NET_CLIENT_TYPE_NIC) {
 345                 func(DO_UPCAST(NICState, nc, nc), opaque);
 346             }
 347         }
 348     }
 349 }
 350
 351 int qemu_can_send_packet(VLANClientState *sender)
 352 {
 353     VLANState *vlan = sender->vlan;
 354     VLANClientState *vc;
 355
 356     if (sender->peer) {
 357         if (sender->peer->receive_disabled) {
 358             return 0;
 359         } else if (sender->peer->info->can_receive &&
 360                    !sender->peer->info->can_receive(sender->peer)) {
 361             return 0;
 362         } else {
 363             return 1;
 364         }
 365     }
 366
 367     if (!sender->vlan) {
 368         return 1;
 369     }
 370
 371     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 372         if (vc == sender) {
 373             continue;
 374         }
 375
 376         /* no can_receive() handler, they can always receive */
 377         if (!vc->info->can_receive || vc->info->can_receive(vc)) {
 378             return 1;
 379         }
 380     }
 381     return 0;
 382 }
 383
 384 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 385                                    unsigned flags,
 386                                    const uint8_t *data,
 387                                    size_t size,
 388                                    void *opaque)
 389 {
 390     VLANClientState *vc = opaque;
 391     ssize_t ret;
 392
 393     if (vc->link_down) {
 394         return size;
 395     }
 396
 397     if (vc->receive_disabled) {
 398         return 0;
 399     }
 400
 401     if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 402         ret = vc->info->receive_raw(vc, data, size);
 403     } else {
 404         ret = vc->info->receive(vc, data, size);
 405     }
 406
 407     if (ret == 0) {
 408         vc->receive_disabled = 1;
 409     };
 410
 411     return ret;
 412 }
 413
 414 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
 415                                         unsigned flags,
 416                                         const uint8_t *buf,
 417                                         size_t size,
 418                                         void *opaque)
 419 {
 420     VLANState *vlan = opaque;
 421     VLANClientState *vc;
 422     ssize_t ret = -1;
 423
 424     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 425         ssize_t len;
 426
 427         if (vc == sender) {
 428             continue;
 429         }
 430
 431         if (vc->link_down) {
 432             ret = size;
 433             continue;
 434         }
 435
 436         if (vc->receive_disabled) {
 437             ret = 0;
 438             continue;
 439         }
 440
 441         if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 442             len = vc->info->receive_raw(vc, buf, size);
 443         } else {
 444             len = vc->info->receive(vc, buf, size);
 445         }
 446
 447         if (len == 0) {
 448             vc->receive_disabled = 1;
 449         }
 450
 451         ret = (ret >= 0) ? ret : len;
 452
 453     }
 454
 455     return ret;
 456 }
 457
 458 void qemu_purge_queued_packets(VLANClientState *vc)
 459 {
 460     NetQueue *queue;
 461
 462     if (!vc->peer && !vc->vlan) {
 463         return;
 464     }
 465
 466     if (vc->peer) {
 467         queue = vc->peer->send_queue;
 468     } else {
 469         queue = vc->vlan->send_queue;
 470     }
 471
 472     qemu_net_queue_purge(queue, vc);
 473 }
 474
 475 void qemu_flush_queued_packets(VLANClientState *vc)
 476 {
 477     NetQueue *queue;
 478
 479     vc->receive_disabled = 0;
 480
 481     if (vc->vlan) {
 482         queue = vc->vlan->send_queue;
 483     } else {
 484         queue = vc->send_queue;
 485     }
 486
 487     qemu_net_queue_flush(queue);
 488 }
 489
 490 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
 491                                                  unsigned flags,
 492                                                  const uint8_t *buf, int size,
 493                                                  NetPacketSent *sent_cb)
 494 {
 495     NetQueue *queue;
 496
 497 #ifdef DEBUG_NET
 498     printf("qemu_send_packet_async:\n");
 499     hex_dump(stdout, buf, size);
 500 #endif
 501
 502     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 503         return size;
 504     }
 505
 506     if (sender->peer) {
 507         queue = sender->peer->send_queue;
 508     } else {
 509         queue = sender->vlan->send_queue;
 510     }
 511
 512     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 513 }
 514
 515 ssize_t qemu_send_packet_async(VLANClientState *sender,
 516                                const uint8_t *buf, int size,
 517                                NetPacketSent *sent_cb)
 518 {
 519     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 520                                              buf, size, sent_cb);
 521 }
 522
 523 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
 524 {
 525     qemu_send_packet_async(vc, buf, size, NULL);
 526 }
 527
 528 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
 529 {
 530     return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
 531                                              buf, size, NULL);
 532 }
 533
 534 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
 535                                int iovcnt)
 536 {
 537     uint8_t buffer[4096];
 538     size_t offset = 0;
 539     int i;
 540
 541     for (i = 0; i < iovcnt; i++) {
 542         size_t len;
 543
 544         len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
 545         memcpy(buffer + offset, iov[i].iov_base, len);
 546         offset += len;
 547     }
 548
 549     return vc->info->receive(vc, buffer, offset);
 550 }
 551
 552 static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
 553 {
 554     size_t offset = 0;
 555     int i;
 556
 557     for (i = 0; i < iovcnt; i++)
 558         offset += iov[i].iov_len;
 559     return offset;
 560 }
 561
 562 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 563                                        unsigned flags,
 564                                        const struct iovec *iov,
 565                                        int iovcnt,
 566                                        void *opaque)
 567 {
 568     VLANClientState *vc = opaque;
 569
 570     if (vc->link_down) {
 571         return calc_iov_length(iov, iovcnt);
 572     }
 573
 574     if (vc->info->receive_iov) {
 575         return vc->info->receive_iov(vc, iov, iovcnt);
 576     } else {
 577         return vc_sendv_compat(vc, iov, iovcnt);
 578     }
 579 }
 580
 581 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
 582                                             unsigned flags,
 583                                             const struct iovec *iov,
 584                                             int iovcnt,
 585                                             void *opaque)
 586 {
 587     VLANState *vlan = opaque;
 588     VLANClientState *vc;
 589     ssize_t ret = -1;
 590
 591     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 592         ssize_t len;
 593
 594         if (vc == sender) {
 595             continue;
 596         }
 597
 598         if (vc->link_down) {
 599             ret = calc_iov_length(iov, iovcnt);
 600             continue;
 601         }
 602
 603         assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
 604
 605         if (vc->info->receive_iov) {
 606             len = vc->info->receive_iov(vc, iov, iovcnt);
 607         } else {
 608             len = vc_sendv_compat(vc, iov, iovcnt);
 609         }
 610
 611         ret = (ret >= 0) ? ret : len;
 612     }
 613
 614     return ret;
 615 }
 616
 617 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
 618                                 const struct iovec *iov, int iovcnt,
 619                                 NetPacketSent *sent_cb)
 620 {
 621     NetQueue *queue;
 622
 623     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 624         return calc_iov_length(iov, iovcnt);
 625     }
 626
 627     if (sender->peer) {
 628         queue = sender->peer->send_queue;
 629     } else {
 630         queue = sender->vlan->send_queue;
 631     }
 632
 633     return qemu_net_queue_send_iov(queue, sender,
 634                                    QEMU_NET_PACKET_FLAG_NONE,
 635                                    iov, iovcnt, sent_cb);
 636 }
 637
 638 ssize_t
 639 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
 640 {
 641     return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
 642 }
 643
 644 /* find or alloc a new VLAN */
 645 VLANState *qemu_find_vlan(int id, int allocate)
 646 {
 647     VLANState *vlan;
 648
 649     QTAILQ_FOREACH(vlan, &vlans, next) {
 650         if (vlan->id == id) {
 651             return vlan;
 652         }
 653     }
 654
 655     if (!allocate) {
 656         return NULL;
 657     }
 658
 659     vlan = qemu_mallocz(sizeof(VLANState));
 660     vlan->id = id;
 661     QTAILQ_INIT(&vlan->clients);
 662
 663     vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
 664                                           qemu_vlan_deliver_packet_iov,
 665                                           vlan);
 666
 667     QTAILQ_INSERT_TAIL(&vlans, vlan, next);
 668
 669     return vlan;
 670 }
 671
 672 VLANClientState *qemu_find_netdev(const char *id)
 673 {
 674     VLANClientState *vc;
 675
 676     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 677         if (!strcmp(vc->name, id)) {
 678             return vc;
 679         }
 680     }
 681
 682     return NULL;
 683 }
 684
 685 static int nic_get_free_idx(void)
 686 {
 687     int index;
 688
 689     for (index = 0; index < MAX_NICS; index++)
 690         if (!nd_table[index].used)
 691             return index;
 692     return -1;
 693 }
 694
 695 int qemu_show_nic_models(const char *arg, const char *const *models)
 696 {
 697     int i;
 698
 699     if (!arg || strcmp(arg, "?"))
 700         return 0;
 701
 702     fprintf(stderr, "qemu: Supported NIC models: ");
 703     for (i = 0 ; models[i]; i++)
 704         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 705     return 1;
 706 }
 707
 708 void qemu_check_nic_model(NICInfo *nd, const char *model)
 709 {
 710     const char *models[2];
 711
 712     models[0] = model;
 713     models[1] = NULL;
 714
 715     if (qemu_show_nic_models(nd->model, models))
 716         exit(0);
 717     if (qemu_find_nic_model(nd, models, model) < 0)
 718         exit(1);
 719 }
 720
 721 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
 722                         const char *default_model)
 723 {
 724     int i;
 725
 726     if (!nd->model)
 727         nd->model = qemu_strdup(default_model);
 728
 729     for (i = 0 ; models[i]; i++) {
 730         if (strcmp(nd->model, models[i]) == 0)
 731             return i;
 732     }
 733
 734     qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
 735     return -1;
 736 }
 737
 738 int net_handle_fd_param(Monitor *mon, const char *param)
 739 {
 740     if (!qemu_isdigit(param[0])) {
 741         int fd;
 742
 743         fd = monitor_get_fd(mon, param);
 744         if (fd == -1) {
 745             qemu_error("No file descriptor named %s found", param);
 746             return -1;
 747         }
 748
 749         return fd;
 750     } else {
 751         return strtol(param, NULL, 0);
 752     }
 753 }
 754
 755 static int net_init_nic(QemuOpts *opts,
 756                         Monitor *mon,
 757                         const char *name,
 758                         VLANState *vlan)
 759 {
 760     int idx;
 761     NICInfo *nd;
 762     const char *netdev;
 763
 764     idx = nic_get_free_idx();
 765     if (idx == -1 || nb_nics >= MAX_NICS) {
 766         qemu_error("Too Many NICs\n");
 767         return -1;
 768     }
 769
 770     nd = &nd_table[idx];
 771
 772     memset(nd, 0, sizeof(*nd));
 773
 774     if ((netdev = qemu_opt_get(opts, "netdev"))) {
 775         nd->netdev = qemu_find_netdev(netdev);
 776         if (!nd->netdev) {
 777             qemu_error("netdev '%s' not found\n", netdev);
 778             return -1;
 779         }
 780     } else {
 781         assert(vlan);
 782         nd->vlan = vlan;
 783     }
 784     if (name) {
 785         nd->name = qemu_strdup(name);
 786     }
 787     if (qemu_opt_get(opts, "model")) {
 788         nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
 789     }
 790     if (qemu_opt_get(opts, "addr")) {
 791         nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
 792     }
 793
 794     nd->macaddr[0] = 0x52;
 795     nd->macaddr[1] = 0x54;
 796     nd->macaddr[2] = 0x00;
 797     nd->macaddr[3] = 0x12;
 798     nd->macaddr[4] = 0x34;
 799     nd->macaddr[5] = 0x56 + idx;
 800
 801     if (qemu_opt_get(opts, "macaddr") &&
 802         net_parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
 803         qemu_error("invalid syntax for ethernet address\n");
 804         return -1;
 805     }
 806
 807     nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
 808     if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
 809         (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
 810         qemu_error("invalid # of vectors: %d\n", nd->nvectors);
 811         return -1;
 812     }
 813
 814     nd->used = 1;
 815     nb_nics++;
 816
 817     return idx;
 818 }
 819
 820 #define NET_COMMON_PARAMS_DESC                     \
 821     {                                              \
 822         .name = "type",                            \
 823         .type = QEMU_OPT_STRING,                   \
 824         .help = "net client type (nic, tap etc.)", \
 825      }, {                                          \
 826         .name = "vlan",                            \
 827         .type = QEMU_OPT_NUMBER,                   \
 828         .help = "vlan number",                     \
 829      }, {                                          \
 830         .name = "name",                            \
 831         .type = QEMU_OPT_STRING,                   \
 832         .help = "identifier for monitor commands", \
 833      }
 834
 835 typedef int (*net_client_init_func)(QemuOpts *opts,
 836                                     Monitor *mon,
 837                                     const char *name,
 838                                     VLANState *vlan);
 839
 840 /* magic number, but compiler will warn if too small */
 841 #define NET_MAX_DESC 20
 842
 843 static struct {
 844     const char *type;
 845     net_client_init_func init;
 846     QemuOptDesc desc[NET_MAX_DESC];
 847 } net_client_types[] = {
 848     {
 849         .type = "none",
 850         .desc = {
 851             NET_COMMON_PARAMS_DESC,
 852             { /* end of list */ }
 853         },
 854     }, {
 855         .type = "nic",
 856         .init = net_init_nic,
 857         .desc = {
 858             NET_COMMON_PARAMS_DESC,
 859             {
 860                 .name = "netdev",
 861                 .type = QEMU_OPT_STRING,
 862                 .help = "id of -netdev to connect to",
 863             },
 864             {
 865                 .name = "macaddr",
 866                 .type = QEMU_OPT_STRING,
 867                 .help = "MAC address",
 868             }, {
 869                 .name = "model",
 870                 .type = QEMU_OPT_STRING,
 871                 .help = "device model (e1000, rtl8139, virtio etc.)",
 872             }, {
 873                 .name = "addr",
 874                 .type = QEMU_OPT_STRING,
 875                 .help = "PCI device address",
 876             }, {
 877                 .name = "vectors",
 878                 .type = QEMU_OPT_NUMBER,
 879                 .help = "number of MSI-x vectors, 0 to disable MSI-X",
 880             },
 881             { /* end of list */ }
 882         },
 883 #ifdef CONFIG_SLIRP
 884     }, {
 885         .type = "user",
 886         .init = net_init_slirp,
 887         .desc = {
 888             NET_COMMON_PARAMS_DESC,
 889             {
 890                 .name = "hostname",
 891                 .type = QEMU_OPT_STRING,
 892                 .help = "client hostname reported by the builtin DHCP server",
 893             }, {
 894                 .name = "restrict",
 895                 .type = QEMU_OPT_STRING,
 896                 .help = "isolate the guest from the host (y|yes|n|no)",
 897             }, {
 898                 .name = "ip",
 899                 .type = QEMU_OPT_STRING,
 900                 .help = "legacy parameter, use net= instead",
 901             }, {
 902                 .name = "net",
 903                 .type = QEMU_OPT_STRING,
 904                 .help = "IP address and optional netmask",
 905             }, {
 906                 .name = "host",
 907                 .type = QEMU_OPT_STRING,
 908                 .help = "guest-visible address of the host",
 909             }, {
 910                 .name = "tftp",
 911                 .type = QEMU_OPT_STRING,
 912                 .help = "root directory of the built-in TFTP server",
 913             }, {
 914                 .name = "bootfile",
 915                 .type = QEMU_OPT_STRING,
 916                 .help = "BOOTP filename, for use with tftp=",
 917             }, {
 918                 .name = "dhcpstart",
 919                 .type = QEMU_OPT_STRING,
 920                 .help = "the first of the 16 IPs the built-in DHCP server can assign",
 921             }, {
 922                 .name = "dns",
 923                 .type = QEMU_OPT_STRING,
 924                 .help = "guest-visible address of the virtual nameserver",
 925             }, {
 926                 .name = "smb",
 927                 .type = QEMU_OPT_STRING,
 928                 .help = "root directory of the built-in SMB server",
 929             }, {
 930                 .name = "smbserver",
 931                 .type = QEMU_OPT_STRING,
 932                 .help = "IP address of the built-in SMB server",
 933             }, {
 934                 .name = "hostfwd",
 935                 .type = QEMU_OPT_STRING,
 936                 .help = "guest port number to forward incoming TCP or UDP connections",
 937             }, {
 938                 .name = "guestfwd",
 939                 .type = QEMU_OPT_STRING,
 940                 .help = "IP address and port to forward guest TCP connections",
 941             },
 942             { /* end of list */ }
 943         },
 944 #endif
 945     }, {
 946         .type = "tap",
 947         .init = net_init_tap,
 948         .desc = {
 949             NET_COMMON_PARAMS_DESC,
 950             {
 951                 .name = "ifname",
 952                 .type = QEMU_OPT_STRING,
 953                 .help = "interface name",
 954             },
 955 #ifndef _WIN32
 956             {
 957                 .name = "fd",
 958                 .type = QEMU_OPT_STRING,
 959                 .help = "file descriptor of an already opened tap",
 960             }, {
 961                 .name = "script",
 962                 .type = QEMU_OPT_STRING,
 963                 .help = "script to initialize the interface",
 964             }, {
 965                 .name = "downscript",
 966                 .type = QEMU_OPT_STRING,
 967                 .help = "script to shut down the interface",
 968             }, {
 969                 .name = "sndbuf",
 970                 .type = QEMU_OPT_SIZE,
 971                 .help = "send buffer limit"
 972             }, {
 973                 .name = "vnet_hdr",
 974                 .type = QEMU_OPT_BOOL,
 975                 .help = "enable the IFF_VNET_HDR flag on the tap interface"
 976             },
 977 #endif /* _WIN32 */
 978             { /* end of list */ }
 979         },
 980     }, {
 981         .type = "socket",
 982         .init = net_init_socket,
 983         .desc = {
 984             NET_COMMON_PARAMS_DESC,
 985             {
 986                 .name = "fd",
 987                 .type = QEMU_OPT_STRING,
 988                 .help = "file descriptor of an already opened socket",
 989             }, {
 990                 .name = "listen",
 991                 .type = QEMU_OPT_STRING,
 992                 .help = "port number, and optional hostname, to listen on",
 993             }, {
 994                 .name = "connect",
 995                 .type = QEMU_OPT_STRING,
 996                 .help = "port number, and optional hostname, to connect to",
 997             }, {
 998                 .name = "mcast",
 999                 .type = QEMU_OPT_STRING,
1000                 .help = "UDP multicast address and port number",
1001             },
1002             { /* end of list */ }
1003         },
1004 #ifdef CONFIG_VDE
1005     }, {
1006         .type = "vde",
1007         .init = net_init_vde,
1008         .desc = {
1009             NET_COMMON_PARAMS_DESC,
1010             {
1011                 .name = "sock",
1012                 .type = QEMU_OPT_STRING,
1013                 .help = "socket path",
1014             }, {
1015                 .name = "port",
1016                 .type = QEMU_OPT_NUMBER,
1017                 .help = "port number",
1018             }, {
1019                 .name = "group",
1020                 .type = QEMU_OPT_STRING,
1021                 .help = "group owner of socket",
1022             }, {
1023                 .name = "mode",
1024                 .type = QEMU_OPT_NUMBER,
1025                 .help = "permissions for socket",
1026             },
1027             { /* end of list */ }
1028         },
1029 #endif
1030     }, {
1031         .type = "dump",
1032         .init = net_init_dump,
1033         .desc = {
1034             NET_COMMON_PARAMS_DESC,
1035             {
1036                 .name = "len",
1037                 .type = QEMU_OPT_SIZE,
1038                 .help = "per-packet size limit (64k default)",
1039             }, {
1040                 .name = "file",
1041                 .type = QEMU_OPT_STRING,
1042                 .help = "dump file path (default is qemu-vlan0.pcap)",
1043             },
1044             { /* end of list */ }
1045         },
1046     },
1047     { /* end of list */ }
1048 };
1049
1050 int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
1051 {
1052     const char *name;
1053     const char *type;
1054     int i;
1055
1056     type = qemu_opt_get(opts, "type");
1057
1058     if (!is_netdev) {
1059         if (!type) {
1060             qemu_error("No type specified for -net\n");
1061             return -1;
1062         }
1063     } else {
1064         if (!type) {
1065             qemu_error("No type specified for -netdev\n");
1066             return -1;
1067         }
1068
1069         if (strcmp(type, "tap") != 0 &&
1070 #ifdef CONFIG_SLIRP
1071             strcmp(type, "user") != 0 &&
1072 #endif
1073 #ifdef CONFIG_VDE
1074             strcmp(type, "vde") != 0 &&
1075 #endif
1076             strcmp(type, "socket") != 0) {
1077             qemu_error("The '%s' network backend type is not valid with -netdev\n",
1078                        type);
1079             return -1;
1080         }
1081
1082         if (qemu_opt_get(opts, "vlan")) {
1083             qemu_error("The 'vlan' parameter is not valid with -netdev\n");
1084             return -1;
1085         }
1086         if (qemu_opt_get(opts, "name")) {
1087             qemu_error("The 'name' parameter is not valid with -netdev\n");
1088             return -1;
1089         }
1090         if (!qemu_opts_id(opts)) {
1091             qemu_error("The id= parameter is required with -netdev\n");
1092             return -1;
1093         }
1094     }
1095
1096     name = qemu_opts_id(opts);
1097     if (!name) {
1098         name = qemu_opt_get(opts, "name");
1099     }
1100
1101     for (i = 0; net_client_types[i].type != NULL; i++) {
1102         if (!strcmp(net_client_types[i].type, type)) {
1103             VLANState *vlan = NULL;
1104
1105             if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
1106                 return -1;
1107             }
1108
1109             /* Do not add to a vlan if it's a -netdev or a nic with a
1110              * netdev= parameter. */
1111             if (!(is_netdev ||
1112                   (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1113                 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1114             }
1115
1116             if (net_client_types[i].init) {
1117                 return net_client_types[i].init(opts, mon, name, vlan);
1118             } else {
1119                 return 0;
1120             }
1121         }
1122     }
1123
1124     qemu_error("Invalid -net type '%s'\n", type);
1125     return -1;
1126 }
1127
1128 static int net_host_check_device(const char *device)
1129 {
1130     int i;
1131     const char *valid_param_list[] = { "tap", "socket", "dump"
1132 #ifdef CONFIG_SLIRP
1133                                        ,"user"
1134 #endif
1135 #ifdef CONFIG_VDE
1136                                        ,"vde"
1137 #endif
1138     };
1139     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1140         if (!strncmp(valid_param_list[i], device,
1141                      strlen(valid_param_list[i])))
1142             return 1;
1143     }
1144
1145     return 0;
1146 }
1147
1148 void net_host_device_add(Monitor *mon, const QDict *qdict)
1149 {
1150     const char *device = qdict_get_str(qdict, "device");
1151     const char *opts_str = qdict_get_try_str(qdict, "opts");
1152     QemuOpts *opts;
1153
1154     if (!net_host_check_device(device)) {
1155         monitor_printf(mon, "invalid host network device %s\n", device);
1156         return;
1157     }
1158
1159     opts = qemu_opts_parse(&qemu_net_opts, opts_str ? opts_str : "", NULL);
1160     if (!opts) {
1161         monitor_printf(mon, "parsing network options '%s' failed\n",
1162                        opts_str ? opts_str : "");
1163         return;
1164     }
1165
1166     qemu_opt_set(opts, "type", device);
1167
1168     if (net_client_init(mon, opts, 0) < 0) {
1169         monitor_printf(mon, "adding host network device %s failed\n", device);
1170     }
1171 }
1172
1173 void net_host_device_remove(Monitor *mon, const QDict *qdict)
1174 {
1175     VLANClientState *vc;
1176     int vlan_id = qdict_get_int(qdict, "vlan_id");
1177     const char *device = qdict_get_str(qdict, "device");
1178
1179     vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1180     if (!vc) {
1181         return;
1182     }
1183     if (!net_host_check_device(vc->model)) {
1184         monitor_printf(mon, "invalid host network device %s\n", device);
1185         return;
1186     }
1187     qemu_del_vlan_client(vc);
1188 }
1189
1190 void net_set_boot_mask(int net_boot_mask)
1191 {
1192     int i;
1193
1194     /* Only the first four NICs may be bootable */
1195     net_boot_mask = net_boot_mask & 0xF;
1196
1197     for (i = 0; i < nb_nics; i++) {
1198         if (net_boot_mask & (1 << i)) {
1199             nd_table[i].bootable = 1;
1200             net_boot_mask &= ~(1 << i);
1201         }
1202     }
1203
1204     if (net_boot_mask) {
1205         fprintf(stderr, "Cannot boot from non-existent NIC\n");
1206         exit(1);
1207     }
1208 }
1209
1210 void do_info_network(Monitor *mon)
1211 {
1212     VLANState *vlan;
1213     VLANClientState *vc;
1214
1215     QTAILQ_FOREACH(vlan, &vlans, next) {
1216         monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1217
1218         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1219             monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
1220         }
1221     }
1222     monitor_printf(mon, "Devices not on any VLAN:\n");
1223     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1224         monitor_printf(mon, "  %s: %s", vc->name, vc->info_str);
1225         if (vc->peer) {
1226             monitor_printf(mon, " peer=%s", vc->peer->name);
1227         }
1228         monitor_printf(mon, "\n");
1229     }
1230 }
1231
1232 void do_set_link(Monitor *mon, const QDict *qdict)
1233 {
1234     VLANState *vlan;
1235     VLANClientState *vc = NULL;
1236     const char *name = qdict_get_str(qdict, "name");
1237     const char *up_or_down = qdict_get_str(qdict, "up_or_down");
1238
1239     QTAILQ_FOREACH(vlan, &vlans, next) {
1240         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1241             if (strcmp(vc->name, name) == 0) {
1242                 goto done;
1243             }
1244         }
1245     }
1246     vc = qemu_find_netdev(name);
1247 done:
1248
1249     if (!vc) {
1250         monitor_printf(mon, "could not find network device '%s'\n", name);
1251         return;
1252     }
1253
1254     if (strcmp(up_or_down, "up") == 0)
1255         vc->link_down = 0;
1256     else if (strcmp(up_or_down, "down") == 0)
1257         vc->link_down = 1;
1258     else
1259         monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
1260                        "valid\n", up_or_down);
1261
1262     if (vc->info->link_status_changed) {
1263         vc->info->link_status_changed(vc);
1264     }
1265 }
1266
1267 void net_cleanup(void)
1268 {
1269     VLANState *vlan;
1270     VLANClientState *vc, *next_vc;
1271
1272     QTAILQ_FOREACH(vlan, &vlans, next) {
1273         QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1274             qemu_del_vlan_client(vc);
1275         }
1276     }
1277
1278     QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1279         qemu_del_vlan_client(vc);
1280     }
1281 }
1282
1283 void net_check_clients(void)
1284 {
1285     VLANState *vlan;
1286     VLANClientState *vc;
1287     int has_nic = 0, has_host_dev = 0;
1288
1289     QTAILQ_FOREACH(vlan, &vlans, next) {
1290         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1291             switch (vc->info->type) {
1292             case NET_CLIENT_TYPE_NIC:
1293                 has_nic = 1;
1294                 break;
1295             case NET_CLIENT_TYPE_SLIRP:
1296             case NET_CLIENT_TYPE_TAP:
1297             case NET_CLIENT_TYPE_SOCKET:
1298             case NET_CLIENT_TYPE_VDE:
1299                 has_host_dev = 1;
1300                 break;
1301             default: ;
1302             }
1303         }
1304         if (has_host_dev && !has_nic)
1305             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1306         if (has_nic && !has_host_dev)
1307             fprintf(stderr,
1308                     "Warning: vlan %d is not connected to host network\n",
1309                     vlan->id);
1310     }
1311     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1312         if (!vc->peer) {
1313             fprintf(stderr, "Warning: %s %s has no peer\n",
1314                     vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1315                     vc->name);
1316         }
1317     }
1318 }
1319
1320 static int net_init_client(QemuOpts *opts, void *dummy)
1321 {
1322     if (net_client_init(NULL, opts, 0) < 0)
1323         return -1;
1324     return 0;
1325 }
1326
1327 static int net_init_netdev(QemuOpts *opts, void *dummy)
1328 {
1329     return net_client_init(NULL, opts, 1);
1330 }
1331
1332 int net_init_clients(void)
1333 {
1334     if (default_net) {
1335         /* if no clients, we use a default config */
1336         qemu_opts_set(&qemu_net_opts, NULL, "type", "nic");
1337 #ifdef CONFIG_SLIRP
1338         qemu_opts_set(&qemu_net_opts, NULL, "type", "user");
1339 #endif
1340     }
1341
1342     QTAILQ_INIT(&vlans);
1343     QTAILQ_INIT(&non_vlan_clients);
1344
1345     if (qemu_opts_foreach(&qemu_netdev_opts, net_init_netdev, NULL, 1) == -1)
1346         return -1;
1347
1348     if (qemu_opts_foreach(&qemu_net_opts, net_init_client, NULL, 1) == -1) {
1349         return -1;
1350     }
1351
1352     return 0;
1353 }
1354
1355 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1356 {
1357 #if defined(CONFIG_SLIRP)
1358     int ret;
1359     if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1360         return ret;
1361     }
1362 #endif
1363
1364     if (!qemu_opts_parse(opts_list, optarg, "type")) {
1365         return -1;
1366     }
1367
1368     default_net = 0;
1369     return 0;
1370 }