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/hub.h"
  34 #include "net/util.h"
  35 #include "monitor.h"
  36 #include "qemu-common.h"
  37 #include "qemu_socket.h"
  38 #include "qmp-commands.h"
  39 #include "hw/qdev.h"
  40 #include "iov.h"
  41 #include "qapi-visit.h"
  42 #include "qapi/opts-visitor.h"
  43 #include "qapi/qapi-dealloc-visitor.h"
  44
  45 /* Net bridge is currently not supported for W32. */
  46 #if !defined(_WIN32)
  47 # define CONFIG_NET_BRIDGE
  48 #endif
  49
  50 static QTAILQ_HEAD(, VLANState) vlans;
  51 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
  52
  53 int default_net = 1;
  54
  55 /***********************************************************/
  56 /* network device redirectors */
  57
  58 #if defined(DEBUG_NET)
  59 static void hex_dump(FILE *f, const uint8_t *buf, int size)
  60 {
  61     int len, i, j, c;
  62
  63     for(i=0;i<size;i+=16) {
  64         len = size - i;
  65         if (len > 16)
  66             len = 16;
  67         fprintf(f, "%08x ", i);
  68         for(j=0;j<16;j++) {
  69             if (j < len)
  70                 fprintf(f, " %02x", buf[i+j]);
  71             else
  72                 fprintf(f, "   ");
  73         }
  74         fprintf(f, " ");
  75         for(j=0;j<len;j++) {
  76             c = buf[i+j];
  77             if (c < ' ' || c > '~')
  78                 c = '.';
  79             fprintf(f, "%c", c);
  80         }
  81         fprintf(f, "\n");
  82     }
  83 }
  84 #endif
  85
  86 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
  87 {
  88     const char *p, *p1;
  89     int len;
  90     p = *pp;
  91     p1 = strchr(p, sep);
  92     if (!p1)
  93         return -1;
  94     len = p1 - p;
  95     p1++;
  96     if (buf_size > 0) {
  97         if (len > buf_size - 1)
  98             len = buf_size - 1;
  99         memcpy(buf, p, len);
 100         buf[len] = '\0';
 101     }
 102     *pp = p1;
 103     return 0;
 104 }
 105
 106 int parse_host_port(struct sockaddr_in *saddr, const char *str)
 107 {
 108     char buf[512];
 109     struct hostent *he;
 110     const char *p, *r;
 111     int port;
 112
 113     p = str;
 114     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
 115         return -1;
 116     saddr->sin_family = AF_INET;
 117     if (buf[0] == '\0') {
 118         saddr->sin_addr.s_addr = 0;
 119     } else {
 120         if (qemu_isdigit(buf[0])) {
 121             if (!inet_aton(buf, &saddr->sin_addr))
 122                 return -1;
 123         } else {
 124             if ((he = gethostbyname(buf)) == NULL)
 125                 return - 1;
 126             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 127         }
 128     }
 129     port = strtol(p, (char **)&r, 0);
 130     if (r == p)
 131         return -1;
 132     saddr->sin_port = htons(port);
 133     return 0;
 134 }
 135
 136 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
 137 {
 138     snprintf(vc->info_str, sizeof(vc->info_str),
 139              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 140              vc->model,
 141              macaddr[0], macaddr[1], macaddr[2],
 142              macaddr[3], macaddr[4], macaddr[5]);
 143 }
 144
 145 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 146 {
 147     static int index = 0;
 148     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 149
 150     if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
 151         return;
 152     macaddr->a[0] = 0x52;
 153     macaddr->a[1] = 0x54;
 154     macaddr->a[2] = 0x00;
 155     macaddr->a[3] = 0x12;
 156     macaddr->a[4] = 0x34;
 157     macaddr->a[5] = 0x56 + index++;
 158 }
 159
 160 /**
 161  * Generate a name for net client
 162  *
 163  * Only net clients created with the legacy -net option need this.  Naming is
 164  * mandatory for net clients created with -netdev.
 165  */
 166 static char *assign_name(VLANClientState *vc1, const char *model)
 167 {
 168     VLANClientState *vc;
 169     char buf[256];
 170     int id = 0;
 171
 172     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 173         if (vc == vc1) {
 174             continue;
 175         }
 176         /* For compatibility only bump id for net clients on a vlan */
 177         if (strcmp(vc->model, model) == 0 &&
 178             net_hub_id_for_client(vc, NULL) == 0) {
 179             id++;
 180         }
 181     }
 182
 183     snprintf(buf, sizeof(buf), "%s.%d", model, id);
 184
 185     return g_strdup(buf);
 186 }
 187
 188 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 189                                    unsigned flags,
 190                                    const uint8_t *data,
 191                                    size_t size,
 192                                    void *opaque);
 193 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 194                                        unsigned flags,
 195                                        const struct iovec *iov,
 196                                        int iovcnt,
 197                                        void *opaque);
 198
 199 VLANClientState *qemu_new_net_client(NetClientInfo *info,
 200                                      VLANClientState *peer,
 201                                      const char *model,
 202                                      const char *name)
 203 {
 204     VLANClientState *vc;
 205
 206     assert(info->size >= sizeof(VLANClientState));
 207
 208     vc = g_malloc0(info->size);
 209
 210     vc->info = info;
 211     vc->model = g_strdup(model);
 212     if (name) {
 213         vc->name = g_strdup(name);
 214     } else {
 215         vc->name = assign_name(vc, model);
 216     }
 217
 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     return vc;
 230 }
 231
 232 NICState *qemu_new_nic(NetClientInfo *info,
 233                        NICConf *conf,
 234                        const char *model,
 235                        const char *name,
 236                        void *opaque)
 237 {
 238     VLANClientState *nc;
 239     NICState *nic;
 240
 241     assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
 242     assert(info->size >= sizeof(NICState));
 243
 244     nc = qemu_new_net_client(info, conf->peer, model, name);
 245
 246     nic = DO_UPCAST(NICState, nc, nc);
 247     nic->conf = conf;
 248     nic->opaque = opaque;
 249
 250     return nic;
 251 }
 252
 253 static void qemu_cleanup_vlan_client(VLANClientState *vc)
 254 {
 255     if (vc->vlan) {
 256         QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
 257     } else {
 258         QTAILQ_REMOVE(&non_vlan_clients, vc, next);
 259     }
 260
 261     if (vc->info->cleanup) {
 262         vc->info->cleanup(vc);
 263     }
 264 }
 265
 266 static void qemu_free_vlan_client(VLANClientState *vc)
 267 {
 268     if (!vc->vlan) {
 269         if (vc->send_queue) {
 270             qemu_del_net_queue(vc->send_queue);
 271         }
 272         if (vc->peer) {
 273             vc->peer->peer = NULL;
 274         }
 275     }
 276     g_free(vc->name);
 277     g_free(vc->model);
 278     g_free(vc);
 279 }
 280
 281 void qemu_del_vlan_client(VLANClientState *vc)
 282 {
 283     /* If there is a peer NIC, delete and cleanup client, but do not free. */
 284     if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 285         NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
 286         if (nic->peer_deleted) {
 287             return;
 288         }
 289         nic->peer_deleted = true;
 290         /* Let NIC know peer is gone. */
 291         vc->peer->link_down = true;
 292         if (vc->peer->info->link_status_changed) {
 293             vc->peer->info->link_status_changed(vc->peer);
 294         }
 295         qemu_cleanup_vlan_client(vc);
 296         return;
 297     }
 298
 299     /* If this is a peer NIC and peer has already been deleted, free it now. */
 300     if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 301         NICState *nic = DO_UPCAST(NICState, nc, vc);
 302         if (nic->peer_deleted) {
 303             qemu_free_vlan_client(vc->peer);
 304         }
 305     }
 306
 307     qemu_cleanup_vlan_client(vc);
 308     qemu_free_vlan_client(vc);
 309 }
 310
 311 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
 312 {
 313     VLANClientState *nc;
 314     VLANState *vlan;
 315
 316     QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
 317         if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 318             func(DO_UPCAST(NICState, nc, nc), opaque);
 319         }
 320     }
 321
 322     QTAILQ_FOREACH(vlan, &vlans, next) {
 323         QTAILQ_FOREACH(nc, &vlan->clients, next) {
 324             if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 325                 func(DO_UPCAST(NICState, nc, nc), opaque);
 326             }
 327         }
 328     }
 329 }
 330
 331 int qemu_can_send_packet(VLANClientState *sender)
 332 {
 333     VLANState *vlan = sender->vlan;
 334     VLANClientState *vc;
 335
 336     if (sender->peer) {
 337         if (sender->peer->receive_disabled) {
 338             return 0;
 339         } else if (sender->peer->info->can_receive &&
 340                    !sender->peer->info->can_receive(sender->peer)) {
 341             return 0;
 342         } else {
 343             return 1;
 344         }
 345     }
 346
 347     if (!sender->vlan) {
 348         return 1;
 349     }
 350
 351     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 352         if (vc == sender) {
 353             continue;
 354         }
 355
 356         /* no can_receive() handler, they can always receive */
 357         if (vc->info->can_receive && !vc->info->can_receive(vc)) {
 358             return 0;
 359         }
 360     }
 361     return 1;
 362 }
 363
 364 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 365                                    unsigned flags,
 366                                    const uint8_t *data,
 367                                    size_t size,
 368                                    void *opaque)
 369 {
 370     VLANClientState *vc = opaque;
 371     ssize_t ret;
 372
 373     if (vc->link_down) {
 374         return size;
 375     }
 376
 377     if (vc->receive_disabled) {
 378         return 0;
 379     }
 380
 381     if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 382         ret = vc->info->receive_raw(vc, data, size);
 383     } else {
 384         ret = vc->info->receive(vc, data, size);
 385     }
 386
 387     if (ret == 0) {
 388         vc->receive_disabled = 1;
 389     };
 390
 391     return ret;
 392 }
 393
 394 void qemu_purge_queued_packets(VLANClientState *vc)
 395 {
 396     NetQueue *queue;
 397
 398     if (!vc->peer && !vc->vlan) {
 399         return;
 400     }
 401
 402     if (vc->peer) {
 403         queue = vc->peer->send_queue;
 404     } else {
 405         queue = vc->vlan->send_queue;
 406     }
 407
 408     qemu_net_queue_purge(queue, vc);
 409 }
 410
 411 void qemu_flush_queued_packets(VLANClientState *vc)
 412 {
 413     NetQueue *queue;
 414
 415     vc->receive_disabled = 0;
 416
 417     if (vc->vlan) {
 418         queue = vc->vlan->send_queue;
 419     } else {
 420         queue = vc->send_queue;
 421     }
 422
 423     qemu_net_queue_flush(queue);
 424 }
 425
 426 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
 427                                                  unsigned flags,
 428                                                  const uint8_t *buf, int size,
 429                                                  NetPacketSent *sent_cb)
 430 {
 431     NetQueue *queue;
 432
 433 #ifdef DEBUG_NET
 434     printf("qemu_send_packet_async:\n");
 435     hex_dump(stdout, buf, size);
 436 #endif
 437
 438     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 439         return size;
 440     }
 441
 442     if (sender->peer) {
 443         queue = sender->peer->send_queue;
 444     } else {
 445         queue = sender->vlan->send_queue;
 446     }
 447
 448     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 449 }
 450
 451 ssize_t qemu_send_packet_async(VLANClientState *sender,
 452                                const uint8_t *buf, int size,
 453                                NetPacketSent *sent_cb)
 454 {
 455     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 456                                              buf, size, sent_cb);
 457 }
 458
 459 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
 460 {
 461     qemu_send_packet_async(vc, buf, size, NULL);
 462 }
 463
 464 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
 465 {
 466     return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
 467                                              buf, size, NULL);
 468 }
 469
 470 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
 471                                int iovcnt)
 472 {
 473     uint8_t buffer[4096];
 474     size_t offset;
 475
 476     offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
 477
 478     return vc->info->receive(vc, buffer, offset);
 479 }
 480
 481 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 482                                        unsigned flags,
 483                                        const struct iovec *iov,
 484                                        int iovcnt,
 485                                        void *opaque)
 486 {
 487     VLANClientState *vc = opaque;
 488
 489     if (vc->link_down) {
 490         return iov_size(iov, iovcnt);
 491     }
 492
 493     if (vc->info->receive_iov) {
 494         return vc->info->receive_iov(vc, iov, iovcnt);
 495     } else {
 496         return vc_sendv_compat(vc, iov, iovcnt);
 497     }
 498 }
 499
 500 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
 501                                 const struct iovec *iov, int iovcnt,
 502                                 NetPacketSent *sent_cb)
 503 {
 504     NetQueue *queue;
 505
 506     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 507         return iov_size(iov, iovcnt);
 508     }
 509
 510     if (sender->peer) {
 511         queue = sender->peer->send_queue;
 512     } else {
 513         queue = sender->vlan->send_queue;
 514     }
 515
 516     return qemu_net_queue_send_iov(queue, sender,
 517                                    QEMU_NET_PACKET_FLAG_NONE,
 518                                    iov, iovcnt, sent_cb);
 519 }
 520
 521 ssize_t
 522 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
 523 {
 524     return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
 525 }
 526
 527 VLANClientState *qemu_find_netdev(const char *id)
 528 {
 529     VLANClientState *vc;
 530
 531     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 532         if (vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
 533             continue;
 534         if (!strcmp(vc->name, id)) {
 535             return vc;
 536         }
 537     }
 538
 539     return NULL;
 540 }
 541
 542 static int nic_get_free_idx(void)
 543 {
 544     int index;
 545
 546     for (index = 0; index < MAX_NICS; index++)
 547         if (!nd_table[index].used)
 548             return index;
 549     return -1;
 550 }
 551
 552 int qemu_show_nic_models(const char *arg, const char *const *models)
 553 {
 554     int i;
 555
 556     if (!arg || strcmp(arg, "?"))
 557         return 0;
 558
 559     fprintf(stderr, "qemu: Supported NIC models: ");
 560     for (i = 0 ; models[i]; i++)
 561         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 562     return 1;
 563 }
 564
 565 void qemu_check_nic_model(NICInfo *nd, const char *model)
 566 {
 567     const char *models[2];
 568
 569     models[0] = model;
 570     models[1] = NULL;
 571
 572     if (qemu_show_nic_models(nd->model, models))
 573         exit(0);
 574     if (qemu_find_nic_model(nd, models, model) < 0)
 575         exit(1);
 576 }
 577
 578 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
 579                         const char *default_model)
 580 {
 581     int i;
 582
 583     if (!nd->model)
 584         nd->model = g_strdup(default_model);
 585
 586     for (i = 0 ; models[i]; i++) {
 587         if (strcmp(nd->model, models[i]) == 0)
 588             return i;
 589     }
 590
 591     error_report("Unsupported NIC model: %s", nd->model);
 592     return -1;
 593 }
 594
 595 int net_handle_fd_param(Monitor *mon, const char *param)
 596 {
 597     int fd;
 598
 599     if (!qemu_isdigit(param[0]) && mon) {
 600
 601         fd = monitor_get_fd(mon, param);
 602         if (fd == -1) {
 603             error_report("No file descriptor named %s found", param);
 604             return -1;
 605         }
 606     } else {
 607         fd = qemu_parse_fd(param);
 608     }
 609
 610     return fd;
 611 }
 612
 613 static int net_init_nic(const NetClientOptions *opts, const char *name,
 614                         VLANClientState *peer)
 615 {
 616     int idx;
 617     NICInfo *nd;
 618     const NetLegacyNicOptions *nic;
 619
 620     assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
 621     nic = opts->nic;
 622
 623     idx = nic_get_free_idx();
 624     if (idx == -1 || nb_nics >= MAX_NICS) {
 625         error_report("Too Many NICs");
 626         return -1;
 627     }
 628
 629     nd = &nd_table[idx];
 630
 631     memset(nd, 0, sizeof(*nd));
 632
 633     if (nic->has_netdev) {
 634         nd->netdev = qemu_find_netdev(nic->netdev);
 635         if (!nd->netdev) {
 636             error_report("netdev '%s' not found", nic->netdev);
 637             return -1;
 638         }
 639     } else {
 640         assert(peer);
 641         nd->netdev = peer;
 642     }
 643     if (name) {
 644         nd->name = g_strdup(name);
 645     }
 646     if (nic->has_model) {
 647         nd->model = g_strdup(nic->model);
 648     }
 649     if (nic->has_addr) {
 650         nd->devaddr = g_strdup(nic->addr);
 651     }
 652
 653     if (nic->has_macaddr &&
 654         net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
 655         error_report("invalid syntax for ethernet address");
 656         return -1;
 657     }
 658     qemu_macaddr_default_if_unset(&nd->macaddr);
 659
 660     if (nic->has_vectors) {
 661         if (nic->vectors > 0x7ffffff) {
 662             error_report("invalid # of vectors: %"PRIu32, nic->vectors);
 663             return -1;
 664         }
 665         nd->nvectors = nic->vectors;
 666     } else {
 667         nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
 668     }
 669
 670     nd->used = 1;
 671     nb_nics++;
 672
 673     return idx;
 674 }
 675
 676
 677 static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
 678     const NetClientOptions *opts,
 679     const char *name,
 680     VLANClientState *peer) = {
 681         [NET_CLIENT_OPTIONS_KIND_NIC]       = net_init_nic,
 682 #ifdef CONFIG_SLIRP
 683         [NET_CLIENT_OPTIONS_KIND_USER]      = net_init_slirp,
 684 #endif
 685         [NET_CLIENT_OPTIONS_KIND_TAP]       = net_init_tap,
 686         [NET_CLIENT_OPTIONS_KIND_SOCKET]    = net_init_socket,
 687 #ifdef CONFIG_VDE
 688         [NET_CLIENT_OPTIONS_KIND_VDE]       = net_init_vde,
 689 #endif
 690         [NET_CLIENT_OPTIONS_KIND_DUMP]      = net_init_dump,
 691 #ifdef CONFIG_NET_BRIDGE
 692         [NET_CLIENT_OPTIONS_KIND_BRIDGE]    = net_init_bridge,
 693 #endif
 694         [NET_CLIENT_OPTIONS_KIND_HUBPORT]   = net_init_hubport,
 695 };
 696
 697
 698 static int net_client_init1(const void *object, int is_netdev, Error **errp)
 699 {
 700     union {
 701         const Netdev    *netdev;
 702         const NetLegacy *net;
 703     } u;
 704     const NetClientOptions *opts;
 705     const char *name;
 706
 707     if (is_netdev) {
 708         u.netdev = object;
 709         opts = u.netdev->opts;
 710         name = u.netdev->id;
 711
 712         switch (opts->kind) {
 713 #ifdef CONFIG_SLIRP
 714         case NET_CLIENT_OPTIONS_KIND_USER:
 715 #endif
 716         case NET_CLIENT_OPTIONS_KIND_TAP:
 717         case NET_CLIENT_OPTIONS_KIND_SOCKET:
 718 #ifdef CONFIG_VDE
 719         case NET_CLIENT_OPTIONS_KIND_VDE:
 720 #endif
 721 #ifdef CONFIG_NET_BRIDGE
 722         case NET_CLIENT_OPTIONS_KIND_BRIDGE:
 723 #endif
 724         case NET_CLIENT_OPTIONS_KIND_HUBPORT:
 725             break;
 726
 727         default:
 728             error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
 729                       "a netdev backend type");
 730             return -1;
 731         }
 732     } else {
 733         u.net = object;
 734         opts = u.net->opts;
 735         /* missing optional values have been initialized to "all bits zero" */
 736         name = u.net->has_id ? u.net->id : u.net->name;
 737     }
 738
 739     if (net_client_init_fun[opts->kind]) {
 740         VLANClientState *peer = NULL;
 741
 742         /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
 743          * parameter. */
 744         if (!is_netdev &&
 745             (opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
 746              !opts->nic->has_netdev)) {
 747             peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
 748         }
 749
 750         if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
 751             /* TODO push error reporting into init() methods */
 752             error_set(errp, QERR_DEVICE_INIT_FAILED,
 753                       NetClientOptionsKind_lookup[opts->kind]);
 754             return -1;
 755         }
 756     }
 757     return 0;
 758 }
 759
 760
 761 static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
 762 {
 763     if (is_netdev) {
 764         visit_type_Netdev(v, (Netdev **)object, NULL, errp);
 765     } else {
 766         visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
 767     }
 768 }
 769
 770
 771 int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
 772 {
 773     void *object = NULL;
 774     Error *err = NULL;
 775     int ret = -1;
 776
 777     {
 778         OptsVisitor *ov = opts_visitor_new(opts);
 779
 780         net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
 781         opts_visitor_cleanup(ov);
 782     }
 783
 784     if (!err) {
 785         ret = net_client_init1(object, is_netdev, &err);
 786     }
 787
 788     if (object) {
 789         QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
 790
 791         net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
 792         qapi_dealloc_visitor_cleanup(dv);
 793     }
 794
 795     error_propagate(errp, err);
 796     return ret;
 797 }
 798
 799
 800 static int net_host_check_device(const char *device)
 801 {
 802     int i;
 803     const char *valid_param_list[] = { "tap", "socket", "dump"
 804 #ifdef CONFIG_NET_BRIDGE
 805                                        , "bridge"
 806 #endif
 807 #ifdef CONFIG_SLIRP
 808                                        ,"user"
 809 #endif
 810 #ifdef CONFIG_VDE
 811                                        ,"vde"
 812 #endif
 813     };
 814     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
 815         if (!strncmp(valid_param_list[i], device,
 816                      strlen(valid_param_list[i])))
 817             return 1;
 818     }
 819
 820     return 0;
 821 }
 822
 823 void net_host_device_add(Monitor *mon, const QDict *qdict)
 824 {
 825     const char *device = qdict_get_str(qdict, "device");
 826     const char *opts_str = qdict_get_try_str(qdict, "opts");
 827     Error *local_err = NULL;
 828     QemuOpts *opts;
 829
 830     if (!net_host_check_device(device)) {
 831         monitor_printf(mon, "invalid host network device %s\n", device);
 832         return;
 833     }
 834
 835     opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
 836     if (!opts) {
 837         return;
 838     }
 839
 840     qemu_opt_set(opts, "type", device);
 841
 842     net_client_init(opts, 0, &local_err);
 843     if (error_is_set(&local_err)) {
 844         qerror_report_err(local_err);
 845         error_free(local_err);
 846         monitor_printf(mon, "adding host network device %s failed\n", device);
 847     }
 848 }
 849
 850 void net_host_device_remove(Monitor *mon, const QDict *qdict)
 851 {
 852     VLANClientState *vc;
 853     int vlan_id = qdict_get_int(qdict, "vlan_id");
 854     const char *device = qdict_get_str(qdict, "device");
 855
 856     vc = net_hub_find_client_by_name(vlan_id, device);
 857     if (!vc) {
 858         return;
 859     }
 860     if (!net_host_check_device(vc->model)) {
 861         monitor_printf(mon, "invalid host network device %s\n", device);
 862         return;
 863     }
 864     qemu_del_vlan_client(vc);
 865 }
 866
 867 void netdev_add(QemuOpts *opts, Error **errp)
 868 {
 869     net_client_init(opts, 1, errp);
 870 }
 871
 872 int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
 873 {
 874     Error *local_err = NULL;
 875     QemuOptsList *opts_list;
 876     QemuOpts *opts;
 877
 878     opts_list = qemu_find_opts_err("netdev", &local_err);
 879     if (error_is_set(&local_err)) {
 880         goto exit_err;
 881     }
 882
 883     opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
 884     if (error_is_set(&local_err)) {
 885         goto exit_err;
 886     }
 887
 888     netdev_add(opts, &local_err);
 889     if (error_is_set(&local_err)) {
 890         qemu_opts_del(opts);
 891         goto exit_err;
 892     }
 893
 894     return 0;
 895
 896 exit_err:
 897     qerror_report_err(local_err);
 898     error_free(local_err);
 899     return -1;
 900 }
 901
 902 void qmp_netdev_del(const char *id, Error **errp)
 903 {
 904     VLANClientState *vc;
 905
 906     vc = qemu_find_netdev(id);
 907     if (!vc) {
 908         error_set(errp, QERR_DEVICE_NOT_FOUND, id);
 909         return;
 910     }
 911
 912     qemu_del_vlan_client(vc);
 913     qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id));
 914 }
 915
 916 static void print_net_client(Monitor *mon, VLANClientState *vc)
 917 {
 918     monitor_printf(mon, "%s: type=%s,%s\n", vc->name,
 919                    NetClientOptionsKind_lookup[vc->info->type], vc->info_str);
 920 }
 921
 922 void do_info_network(Monitor *mon)
 923 {
 924     VLANState *vlan;
 925     VLANClientState *vc, *peer;
 926     NetClientOptionsKind type;
 927
 928     QTAILQ_FOREACH(vlan, &vlans, next) {
 929         monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
 930
 931         QTAILQ_FOREACH(vc, &vlan->clients, next) {
 932             monitor_printf(mon, "  ");
 933             print_net_client(mon, vc);
 934         }
 935     }
 936     monitor_printf(mon, "Devices not on any VLAN:\n");
 937     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 938         peer = vc->peer;
 939         type = vc->info->type;
 940         if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
 941             monitor_printf(mon, "  ");
 942             print_net_client(mon, vc);
 943         } /* else it's a netdev connected to a NIC, printed with the NIC */
 944         if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
 945             monitor_printf(mon, "   \\ ");
 946             print_net_client(mon, peer);
 947         }
 948     }
 949     net_hub_info(mon);
 950 }
 951
 952 void qmp_set_link(const char *name, bool up, Error **errp)
 953 {
 954     VLANState *vlan;
 955     VLANClientState *vc = NULL;
 956
 957     QTAILQ_FOREACH(vlan, &vlans, next) {
 958         QTAILQ_FOREACH(vc, &vlan->clients, next) {
 959             if (strcmp(vc->name, name) == 0) {
 960                 goto done;
 961             }
 962         }
 963     }
 964     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 965         if (!strcmp(vc->name, name)) {
 966             goto done;
 967         }
 968     }
 969 done:
 970
 971     if (!vc) {
 972         error_set(errp, QERR_DEVICE_NOT_FOUND, name);
 973         return;
 974     }
 975
 976     vc->link_down = !up;
 977
 978     if (vc->info->link_status_changed) {
 979         vc->info->link_status_changed(vc);
 980     }
 981
 982     /* Notify peer. Don't update peer link status: this makes it possible to
 983      * disconnect from host network without notifying the guest.
 984      * FIXME: is disconnected link status change operation useful?
 985      *
 986      * Current behaviour is compatible with qemu vlans where there could be
 987      * multiple clients that can still communicate with each other in
 988      * disconnected mode. For now maintain this compatibility. */
 989     if (vc->peer && vc->peer->info->link_status_changed) {
 990         vc->peer->info->link_status_changed(vc->peer);
 991     }
 992 }
 993
 994 void net_cleanup(void)
 995 {
 996     VLANState *vlan;
 997     VLANClientState *vc, *next_vc;
 998
 999     QTAILQ_FOREACH(vlan, &vlans, next) {
1000         QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1001             qemu_del_vlan_client(vc);
1002         }
1003     }
1004
1005     QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1006         qemu_del_vlan_client(vc);
1007     }
1008 }
1009
1010 void net_check_clients(void)
1011 {
1012     VLANClientState *vc;
1013     int i;
1014
1015     /* Don't warn about the default network setup that you get if
1016      * no command line -net or -netdev options are specified. There
1017      * are two cases that we would otherwise complain about:
1018      * (1) board doesn't support a NIC but the implicit "-net nic"
1019      * requested one
1020      * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1021      * sets up a nic that isn't connected to anything.
1022      */
1023     if (default_net) {
1024         return;
1025     }
1026
1027     net_hub_check_clients();
1028
1029     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1030         if (!vc->peer) {
1031             fprintf(stderr, "Warning: %s %s has no peer\n",
1032                     vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ? "nic" : "netdev",
1033                     vc->name);
1034         }
1035     }
1036
1037     /* Check that all NICs requested via -net nic actually got created.
1038      * NICs created via -device don't need to be checked here because
1039      * they are always instantiated.
1040      */
1041     for (i = 0; i < MAX_NICS; i++) {
1042         NICInfo *nd = &nd_table[i];
1043         if (nd->used && !nd->instantiated) {
1044             fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1045                     "was not created (not supported by this machine?)\n",
1046                     nd->name ? nd->name : "anonymous",
1047                     nd->model ? nd->model : "unspecified");
1048         }
1049     }
1050 }
1051
1052 static int net_init_client(QemuOpts *opts, void *dummy)
1053 {
1054     Error *local_err = NULL;
1055
1056     net_client_init(opts, 0, &local_err);
1057     if (error_is_set(&local_err)) {
1058         qerror_report_err(local_err);
1059         error_free(local_err);
1060         return -1;
1061     }
1062
1063     return 0;
1064 }
1065
1066 static int net_init_netdev(QemuOpts *opts, void *dummy)
1067 {
1068     Error *local_err = NULL;
1069     int ret;
1070
1071     ret = net_client_init(opts, 1, &local_err);
1072     if (error_is_set(&local_err)) {
1073         qerror_report_err(local_err);
1074         error_free(local_err);
1075         return -1;
1076     }
1077
1078     return ret;
1079 }
1080
1081 int net_init_clients(void)
1082 {
1083     QemuOptsList *net = qemu_find_opts("net");
1084
1085     if (default_net) {
1086         /* if no clients, we use a default config */
1087         qemu_opts_set(net, NULL, "type", "nic");
1088 #ifdef CONFIG_SLIRP
1089         qemu_opts_set(net, NULL, "type", "user");
1090 #endif
1091     }
1092
1093     QTAILQ_INIT(&vlans);
1094     QTAILQ_INIT(&non_vlan_clients);
1095
1096     if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1097         return -1;
1098
1099     if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1100         return -1;
1101     }
1102
1103     return 0;
1104 }
1105
1106 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1107 {
1108 #if defined(CONFIG_SLIRP)
1109     int ret;
1110     if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1111         return ret;
1112     }
1113 #endif
1114
1115     if (!qemu_opts_parse(opts_list, optarg, 1)) {
1116         return -1;
1117     }
1118
1119     default_net = 0;
1120     return 0;
1121 }
1122
1123 /* From FreeBSD */
1124 /* XXX: optimize */
1125 unsigned compute_mcast_idx(const uint8_t *ep)
1126 {
1127     uint32_t crc;
1128     int carry, i, j;
1129     uint8_t b;
1130
1131     crc = 0xffffffff;
1132     for (i = 0; i < 6; i++) {
1133         b = *ep++;
1134         for (j = 0; j < 8; j++) {
1135             carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1136             crc <<= 1;
1137             b >>= 1;
1138             if (carry) {
1139                 crc = ((crc ^ POLYNOMIAL) | carry);
1140             }
1141         }
1142     }
1143     return crc >> 26;
1144 }