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