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                                      VLANState *vlan,
 201                                      VLANClientState *peer,
 202                                      const char *model,
 203                                      const char *name)
 204 {
 205     VLANClientState *vc;
 206
 207     assert(info->size >= sizeof(VLANClientState));
 208
 209     vc = g_malloc0(info->size);
 210
 211     vc->info = info;
 212     vc->model = g_strdup(model);
 213     if (name) {
 214         vc->name = g_strdup(name);
 215     } else {
 216         vc->name = assign_name(vc, model);
 217     }
 218
 219     if (vlan) {
 220         assert(!peer);
 221         vc->vlan = vlan;
 222         QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
 223     } else {
 224         if (peer) {
 225             assert(!peer->peer);
 226             vc->peer = peer;
 227             peer->peer = vc;
 228         }
 229         QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
 230
 231         vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
 232                                             qemu_deliver_packet_iov,
 233                                             vc);
 234     }
 235
 236     return vc;
 237 }
 238
 239 NICState *qemu_new_nic(NetClientInfo *info,
 240                        NICConf *conf,
 241                        const char *model,
 242                        const char *name,
 243                        void *opaque)
 244 {
 245     VLANClientState *nc;
 246     NICState *nic;
 247
 248     assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
 249     assert(info->size >= sizeof(NICState));
 250
 251     nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
 252
 253     nic = DO_UPCAST(NICState, nc, nc);
 254     nic->conf = conf;
 255     nic->opaque = opaque;
 256
 257     return nic;
 258 }
 259
 260 static void qemu_cleanup_vlan_client(VLANClientState *vc)
 261 {
 262     if (vc->vlan) {
 263         QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
 264     } else {
 265         QTAILQ_REMOVE(&non_vlan_clients, vc, next);
 266     }
 267
 268     if (vc->info->cleanup) {
 269         vc->info->cleanup(vc);
 270     }
 271 }
 272
 273 static void qemu_free_vlan_client(VLANClientState *vc)
 274 {
 275     if (!vc->vlan) {
 276         if (vc->send_queue) {
 277             qemu_del_net_queue(vc->send_queue);
 278         }
 279         if (vc->peer) {
 280             vc->peer->peer = NULL;
 281         }
 282     }
 283     g_free(vc->name);
 284     g_free(vc->model);
 285     g_free(vc);
 286 }
 287
 288 void qemu_del_vlan_client(VLANClientState *vc)
 289 {
 290     /* If there is a peer NIC, delete and cleanup client, but do not free. */
 291     if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 292         NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
 293         if (nic->peer_deleted) {
 294             return;
 295         }
 296         nic->peer_deleted = true;
 297         /* Let NIC know peer is gone. */
 298         vc->peer->link_down = true;
 299         if (vc->peer->info->link_status_changed) {
 300             vc->peer->info->link_status_changed(vc->peer);
 301         }
 302         qemu_cleanup_vlan_client(vc);
 303         return;
 304     }
 305
 306     /* If this is a peer NIC and peer has already been deleted, free it now. */
 307     if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 308         NICState *nic = DO_UPCAST(NICState, nc, vc);
 309         if (nic->peer_deleted) {
 310             qemu_free_vlan_client(vc->peer);
 311         }
 312     }
 313
 314     qemu_cleanup_vlan_client(vc);
 315     qemu_free_vlan_client(vc);
 316 }
 317
 318 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
 319 {
 320     VLANClientState *nc;
 321     VLANState *vlan;
 322
 323     QTAILQ_FOREACH(nc, &non_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     QTAILQ_FOREACH(vlan, &vlans, next) {
 330         QTAILQ_FOREACH(nc, &vlan->clients, next) {
 331             if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 332                 func(DO_UPCAST(NICState, nc, nc), opaque);
 333             }
 334         }
 335     }
 336 }
 337
 338 int qemu_can_send_packet(VLANClientState *sender)
 339 {
 340     VLANState *vlan = sender->vlan;
 341     VLANClientState *vc;
 342
 343     if (sender->peer) {
 344         if (sender->peer->receive_disabled) {
 345             return 0;
 346         } else if (sender->peer->info->can_receive &&
 347                    !sender->peer->info->can_receive(sender->peer)) {
 348             return 0;
 349         } else {
 350             return 1;
 351         }
 352     }
 353
 354     if (!sender->vlan) {
 355         return 1;
 356     }
 357
 358     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 359         if (vc == sender) {
 360             continue;
 361         }
 362
 363         /* no can_receive() handler, they can always receive */
 364         if (vc->info->can_receive && !vc->info->can_receive(vc)) {
 365             return 0;
 366         }
 367     }
 368     return 1;
 369 }
 370
 371 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 372                                    unsigned flags,
 373                                    const uint8_t *data,
 374                                    size_t size,
 375                                    void *opaque)
 376 {
 377     VLANClientState *vc = opaque;
 378     ssize_t ret;
 379
 380     if (vc->link_down) {
 381         return size;
 382     }
 383
 384     if (vc->receive_disabled) {
 385         return 0;
 386     }
 387
 388     if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 389         ret = vc->info->receive_raw(vc, data, size);
 390     } else {
 391         ret = vc->info->receive(vc, data, size);
 392     }
 393
 394     if (ret == 0) {
 395         vc->receive_disabled = 1;
 396     };
 397
 398     return ret;
 399 }
 400
 401 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
 402                                         unsigned flags,
 403                                         const uint8_t *buf,
 404                                         size_t size,
 405                                         void *opaque)
 406 {
 407     VLANState *vlan = opaque;
 408     VLANClientState *vc;
 409     ssize_t ret = -1;
 410
 411     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 412         ssize_t len;
 413
 414         if (vc == sender) {
 415             continue;
 416         }
 417
 418         if (vc->link_down) {
 419             ret = size;
 420             continue;
 421         }
 422
 423         if (vc->receive_disabled) {
 424             ret = 0;
 425             continue;
 426         }
 427
 428         if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 429             len = vc->info->receive_raw(vc, buf, size);
 430         } else {
 431             len = vc->info->receive(vc, buf, size);
 432         }
 433
 434         if (len == 0) {
 435             vc->receive_disabled = 1;
 436         }
 437
 438         ret = (ret >= 0) ? ret : len;
 439
 440     }
 441
 442     return ret;
 443 }
 444
 445 void qemu_purge_queued_packets(VLANClientState *vc)
 446 {
 447     NetQueue *queue;
 448
 449     if (!vc->peer && !vc->vlan) {
 450         return;
 451     }
 452
 453     if (vc->peer) {
 454         queue = vc->peer->send_queue;
 455     } else {
 456         queue = vc->vlan->send_queue;
 457     }
 458
 459     qemu_net_queue_purge(queue, vc);
 460 }
 461
 462 void qemu_flush_queued_packets(VLANClientState *vc)
 463 {
 464     NetQueue *queue;
 465
 466     vc->receive_disabled = 0;
 467
 468     if (vc->vlan) {
 469         queue = vc->vlan->send_queue;
 470     } else {
 471         queue = vc->send_queue;
 472     }
 473
 474     qemu_net_queue_flush(queue);
 475 }
 476
 477 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
 478                                                  unsigned flags,
 479                                                  const uint8_t *buf, int size,
 480                                                  NetPacketSent *sent_cb)
 481 {
 482     NetQueue *queue;
 483
 484 #ifdef DEBUG_NET
 485     printf("qemu_send_packet_async:\n");
 486     hex_dump(stdout, buf, size);
 487 #endif
 488
 489     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 490         return size;
 491     }
 492
 493     if (sender->peer) {
 494         queue = sender->peer->send_queue;
 495     } else {
 496         queue = sender->vlan->send_queue;
 497     }
 498
 499     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 500 }
 501
 502 ssize_t qemu_send_packet_async(VLANClientState *sender,
 503                                const uint8_t *buf, int size,
 504                                NetPacketSent *sent_cb)
 505 {
 506     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 507                                              buf, size, sent_cb);
 508 }
 509
 510 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
 511 {
 512     qemu_send_packet_async(vc, buf, size, NULL);
 513 }
 514
 515 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
 516 {
 517     return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
 518                                              buf, size, NULL);
 519 }
 520
 521 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
 522                                int iovcnt)
 523 {
 524     uint8_t buffer[4096];
 525     size_t offset;
 526
 527     offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
 528
 529     return vc->info->receive(vc, buffer, offset);
 530 }
 531
 532 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 533                                        unsigned flags,
 534                                        const struct iovec *iov,
 535                                        int iovcnt,
 536                                        void *opaque)
 537 {
 538     VLANClientState *vc = opaque;
 539
 540     if (vc->link_down) {
 541         return iov_size(iov, iovcnt);
 542     }
 543
 544     if (vc->info->receive_iov) {
 545         return vc->info->receive_iov(vc, iov, iovcnt);
 546     } else {
 547         return vc_sendv_compat(vc, iov, iovcnt);
 548     }
 549 }
 550
 551 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
 552                                             unsigned flags,
 553                                             const struct iovec *iov,
 554                                             int iovcnt,
 555                                             void *opaque)
 556 {
 557     VLANState *vlan = opaque;
 558     VLANClientState *vc;
 559     ssize_t ret = -1;
 560
 561     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 562         ssize_t len;
 563
 564         if (vc == sender) {
 565             continue;
 566         }
 567
 568         if (vc->link_down) {
 569             ret = iov_size(iov, iovcnt);
 570             continue;
 571         }
 572
 573         assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
 574
 575         if (vc->info->receive_iov) {
 576             len = vc->info->receive_iov(vc, iov, iovcnt);
 577         } else {
 578             len = vc_sendv_compat(vc, iov, iovcnt);
 579         }
 580
 581         ret = (ret >= 0) ? ret : len;
 582     }
 583
 584     return ret;
 585 }
 586
 587 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
 588                                 const struct iovec *iov, int iovcnt,
 589                                 NetPacketSent *sent_cb)
 590 {
 591     NetQueue *queue;
 592
 593     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 594         return iov_size(iov, iovcnt);
 595     }
 596
 597     if (sender->peer) {
 598         queue = sender->peer->send_queue;
 599     } else {
 600         queue = sender->vlan->send_queue;
 601     }
 602
 603     return qemu_net_queue_send_iov(queue, sender,
 604                                    QEMU_NET_PACKET_FLAG_NONE,
 605                                    iov, iovcnt, sent_cb);
 606 }
 607
 608 ssize_t
 609 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
 610 {
 611     return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
 612 }
 613
 614 /* find or alloc a new VLAN */
 615 VLANState *qemu_find_vlan(int id, int allocate)
 616 {
 617     VLANState *vlan;
 618
 619     QTAILQ_FOREACH(vlan, &vlans, next) {
 620         if (vlan->id == id) {
 621             return vlan;
 622         }
 623     }
 624
 625     if (!allocate) {
 626         return NULL;
 627     }
 628
 629     vlan = g_malloc0(sizeof(VLANState));
 630     vlan->id = id;
 631     QTAILQ_INIT(&vlan->clients);
 632
 633     vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
 634                                           qemu_vlan_deliver_packet_iov,
 635                                           vlan);
 636
 637     QTAILQ_INSERT_TAIL(&vlans, vlan, next);
 638
 639     return vlan;
 640 }
 641
 642 VLANClientState *qemu_find_netdev(const char *id)
 643 {
 644     VLANClientState *vc;
 645
 646     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 647         if (vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
 648             continue;
 649         if (!strcmp(vc->name, id)) {
 650             return vc;
 651         }
 652     }
 653
 654     return NULL;
 655 }
 656
 657 static int nic_get_free_idx(void)
 658 {
 659     int index;
 660
 661     for (index = 0; index < MAX_NICS; index++)
 662         if (!nd_table[index].used)
 663             return index;
 664     return -1;
 665 }
 666
 667 int qemu_show_nic_models(const char *arg, const char *const *models)
 668 {
 669     int i;
 670
 671     if (!arg || strcmp(arg, "?"))
 672         return 0;
 673
 674     fprintf(stderr, "qemu: Supported NIC models: ");
 675     for (i = 0 ; models[i]; i++)
 676         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 677     return 1;
 678 }
 679
 680 void qemu_check_nic_model(NICInfo *nd, const char *model)
 681 {
 682     const char *models[2];
 683
 684     models[0] = model;
 685     models[1] = NULL;
 686
 687     if (qemu_show_nic_models(nd->model, models))
 688         exit(0);
 689     if (qemu_find_nic_model(nd, models, model) < 0)
 690         exit(1);
 691 }
 692
 693 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
 694                         const char *default_model)
 695 {
 696     int i;
 697
 698     if (!nd->model)
 699         nd->model = g_strdup(default_model);
 700
 701     for (i = 0 ; models[i]; i++) {
 702         if (strcmp(nd->model, models[i]) == 0)
 703             return i;
 704     }
 705
 706     error_report("Unsupported NIC model: %s", nd->model);
 707     return -1;
 708 }
 709
 710 int net_handle_fd_param(Monitor *mon, const char *param)
 711 {
 712     int fd;
 713
 714     if (!qemu_isdigit(param[0]) && mon) {
 715
 716         fd = monitor_get_fd(mon, param);
 717         if (fd == -1) {
 718             error_report("No file descriptor named %s found", param);
 719             return -1;
 720         }
 721     } else {
 722         fd = qemu_parse_fd(param);
 723     }
 724
 725     return fd;
 726 }
 727
 728 static int net_init_nic(const NetClientOptions *opts, const char *name,
 729                         VLANClientState *peer)
 730 {
 731     int idx;
 732     NICInfo *nd;
 733     const NetLegacyNicOptions *nic;
 734
 735     assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
 736     nic = opts->nic;
 737
 738     idx = nic_get_free_idx();
 739     if (idx == -1 || nb_nics >= MAX_NICS) {
 740         error_report("Too Many NICs");
 741         return -1;
 742     }
 743
 744     nd = &nd_table[idx];
 745
 746     memset(nd, 0, sizeof(*nd));
 747
 748     if (nic->has_netdev) {
 749         nd->netdev = qemu_find_netdev(nic->netdev);
 750         if (!nd->netdev) {
 751             error_report("netdev '%s' not found", nic->netdev);
 752             return -1;
 753         }
 754     } else {
 755         assert(peer);
 756         nd->netdev = peer;
 757     }
 758     if (name) {
 759         nd->name = g_strdup(name);
 760     }
 761     if (nic->has_model) {
 762         nd->model = g_strdup(nic->model);
 763     }
 764     if (nic->has_addr) {
 765         nd->devaddr = g_strdup(nic->addr);
 766     }
 767
 768     if (nic->has_macaddr &&
 769         net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
 770         error_report("invalid syntax for ethernet address");
 771         return -1;
 772     }
 773     qemu_macaddr_default_if_unset(&nd->macaddr);
 774
 775     if (nic->has_vectors) {
 776         if (nic->vectors > 0x7ffffff) {
 777             error_report("invalid # of vectors: %"PRIu32, nic->vectors);
 778             return -1;
 779         }
 780         nd->nvectors = nic->vectors;
 781     } else {
 782         nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
 783     }
 784
 785     nd->used = 1;
 786     nb_nics++;
 787
 788     return idx;
 789 }
 790
 791
 792 static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
 793     const NetClientOptions *opts,
 794     const char *name,
 795     VLANClientState *peer) = {
 796         [NET_CLIENT_OPTIONS_KIND_NIC]       = net_init_nic,
 797 #ifdef CONFIG_SLIRP
 798         [NET_CLIENT_OPTIONS_KIND_USER]      = net_init_slirp,
 799 #endif
 800         [NET_CLIENT_OPTIONS_KIND_TAP]       = net_init_tap,
 801         [NET_CLIENT_OPTIONS_KIND_SOCKET]    = net_init_socket,
 802 #ifdef CONFIG_VDE
 803         [NET_CLIENT_OPTIONS_KIND_VDE]       = net_init_vde,
 804 #endif
 805         [NET_CLIENT_OPTIONS_KIND_DUMP]      = net_init_dump,
 806 #ifdef CONFIG_NET_BRIDGE
 807         [NET_CLIENT_OPTIONS_KIND_BRIDGE]    = net_init_bridge,
 808 #endif
 809         [NET_CLIENT_OPTIONS_KIND_HUBPORT]   = net_init_hubport,
 810 };
 811
 812
 813 static int net_client_init1(const void *object, int is_netdev, Error **errp)
 814 {
 815     union {
 816         const Netdev    *netdev;
 817         const NetLegacy *net;
 818     } u;
 819     const NetClientOptions *opts;
 820     const char *name;
 821
 822     if (is_netdev) {
 823         u.netdev = object;
 824         opts = u.netdev->opts;
 825         name = u.netdev->id;
 826
 827         switch (opts->kind) {
 828 #ifdef CONFIG_SLIRP
 829         case NET_CLIENT_OPTIONS_KIND_USER:
 830 #endif
 831         case NET_CLIENT_OPTIONS_KIND_TAP:
 832         case NET_CLIENT_OPTIONS_KIND_SOCKET:
 833 #ifdef CONFIG_VDE
 834         case NET_CLIENT_OPTIONS_KIND_VDE:
 835 #endif
 836 #ifdef CONFIG_NET_BRIDGE
 837         case NET_CLIENT_OPTIONS_KIND_BRIDGE:
 838 #endif
 839         case NET_CLIENT_OPTIONS_KIND_HUBPORT:
 840             break;
 841
 842         default:
 843             error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
 844                       "a netdev backend type");
 845             return -1;
 846         }
 847     } else {
 848         u.net = object;
 849         opts = u.net->opts;
 850         /* missing optional values have been initialized to "all bits zero" */
 851         name = u.net->has_id ? u.net->id : u.net->name;
 852     }
 853
 854     if (net_client_init_fun[opts->kind]) {
 855         VLANClientState *peer = NULL;
 856
 857         /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
 858          * parameter. */
 859         if (!is_netdev &&
 860             (opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
 861              !opts->nic->has_netdev)) {
 862             peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
 863         }
 864
 865         if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
 866             /* TODO push error reporting into init() methods */
 867             error_set(errp, QERR_DEVICE_INIT_FAILED,
 868                       NetClientOptionsKind_lookup[opts->kind]);
 869             return -1;
 870         }
 871     }
 872     return 0;
 873 }
 874
 875
 876 static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
 877 {
 878     if (is_netdev) {
 879         visit_type_Netdev(v, (Netdev **)object, NULL, errp);
 880     } else {
 881         visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
 882     }
 883 }
 884
 885
 886 int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
 887 {
 888     void *object = NULL;
 889     Error *err = NULL;
 890     int ret = -1;
 891
 892     {
 893         OptsVisitor *ov = opts_visitor_new(opts);
 894
 895         net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
 896         opts_visitor_cleanup(ov);
 897     }
 898
 899     if (!err) {
 900         ret = net_client_init1(object, is_netdev, &err);
 901     }
 902
 903     if (object) {
 904         QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
 905
 906         net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
 907         qapi_dealloc_visitor_cleanup(dv);
 908     }
 909
 910     error_propagate(errp, err);
 911     return ret;
 912 }
 913
 914
 915 static int net_host_check_device(const char *device)
 916 {
 917     int i;
 918     const char *valid_param_list[] = { "tap", "socket", "dump"
 919 #ifdef CONFIG_NET_BRIDGE
 920                                        , "bridge"
 921 #endif
 922 #ifdef CONFIG_SLIRP
 923                                        ,"user"
 924 #endif
 925 #ifdef CONFIG_VDE
 926                                        ,"vde"
 927 #endif
 928     };
 929     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
 930         if (!strncmp(valid_param_list[i], device,
 931                      strlen(valid_param_list[i])))
 932             return 1;
 933     }
 934
 935     return 0;
 936 }
 937
 938 void net_host_device_add(Monitor *mon, const QDict *qdict)
 939 {
 940     const char *device = qdict_get_str(qdict, "device");
 941     const char *opts_str = qdict_get_try_str(qdict, "opts");
 942     Error *local_err = NULL;
 943     QemuOpts *opts;
 944
 945     if (!net_host_check_device(device)) {
 946         monitor_printf(mon, "invalid host network device %s\n", device);
 947         return;
 948     }
 949
 950     opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
 951     if (!opts) {
 952         return;
 953     }
 954
 955     qemu_opt_set(opts, "type", device);
 956
 957     net_client_init(opts, 0, &local_err);
 958     if (error_is_set(&local_err)) {
 959         qerror_report_err(local_err);
 960         error_free(local_err);
 961         monitor_printf(mon, "adding host network device %s failed\n", device);
 962     }
 963 }
 964
 965 void net_host_device_remove(Monitor *mon, const QDict *qdict)
 966 {
 967     VLANClientState *vc;
 968     int vlan_id = qdict_get_int(qdict, "vlan_id");
 969     const char *device = qdict_get_str(qdict, "device");
 970
 971     vc = net_hub_find_client_by_name(vlan_id, device);
 972     if (!vc) {
 973         return;
 974     }
 975     if (!net_host_check_device(vc->model)) {
 976         monitor_printf(mon, "invalid host network device %s\n", device);
 977         return;
 978     }
 979     qemu_del_vlan_client(vc);
 980 }
 981
 982 void netdev_add(QemuOpts *opts, Error **errp)
 983 {
 984     net_client_init(opts, 1, errp);
 985 }
 986
 987 int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
 988 {
 989     Error *local_err = NULL;
 990     QemuOptsList *opts_list;
 991     QemuOpts *opts;
 992
 993     opts_list = qemu_find_opts_err("netdev", &local_err);
 994     if (error_is_set(&local_err)) {
 995         goto exit_err;
 996     }
 997
 998     opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
 999     if (error_is_set(&local_err)) {
1000         goto exit_err;
1001     }
1002
1003     netdev_add(opts, &local_err);
1004     if (error_is_set(&local_err)) {
1005         qemu_opts_del(opts);
1006         goto exit_err;
1007     }
1008
1009     return 0;
1010
1011 exit_err:
1012     qerror_report_err(local_err);
1013     error_free(local_err);
1014     return -1;
1015 }
1016
1017 void qmp_netdev_del(const char *id, Error **errp)
1018 {
1019     VLANClientState *vc;
1020
1021     vc = qemu_find_netdev(id);
1022     if (!vc) {
1023         error_set(errp, QERR_DEVICE_NOT_FOUND, id);
1024         return;
1025     }
1026
1027     qemu_del_vlan_client(vc);
1028     qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id));
1029 }
1030
1031 static void print_net_client(Monitor *mon, VLANClientState *vc)
1032 {
1033     monitor_printf(mon, "%s: type=%s,%s\n", vc->name,
1034                    NetClientOptionsKind_lookup[vc->info->type], vc->info_str);
1035 }
1036
1037 void do_info_network(Monitor *mon)
1038 {
1039     VLANState *vlan;
1040     VLANClientState *vc, *peer;
1041     NetClientOptionsKind type;
1042
1043     QTAILQ_FOREACH(vlan, &vlans, next) {
1044         monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1045
1046         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1047             monitor_printf(mon, "  ");
1048             print_net_client(mon, vc);
1049         }
1050     }
1051     monitor_printf(mon, "Devices not on any VLAN:\n");
1052     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1053         peer = vc->peer;
1054         type = vc->info->type;
1055         if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
1056             monitor_printf(mon, "  ");
1057             print_net_client(mon, vc);
1058         } /* else it's a netdev connected to a NIC, printed with the NIC */
1059         if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
1060             monitor_printf(mon, "   \\ ");
1061             print_net_client(mon, peer);
1062         }
1063     }
1064     net_hub_info(mon);
1065 }
1066
1067 void qmp_set_link(const char *name, bool up, Error **errp)
1068 {
1069     VLANState *vlan;
1070     VLANClientState *vc = NULL;
1071
1072     QTAILQ_FOREACH(vlan, &vlans, next) {
1073         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1074             if (strcmp(vc->name, name) == 0) {
1075                 goto done;
1076             }
1077         }
1078     }
1079     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1080         if (!strcmp(vc->name, name)) {
1081             goto done;
1082         }
1083     }
1084 done:
1085
1086     if (!vc) {
1087         error_set(errp, QERR_DEVICE_NOT_FOUND, name);
1088         return;
1089     }
1090
1091     vc->link_down = !up;
1092
1093     if (vc->info->link_status_changed) {
1094         vc->info->link_status_changed(vc);
1095     }
1096
1097     /* Notify peer. Don't update peer link status: this makes it possible to
1098      * disconnect from host network without notifying the guest.
1099      * FIXME: is disconnected link status change operation useful?
1100      *
1101      * Current behaviour is compatible with qemu vlans where there could be
1102      * multiple clients that can still communicate with each other in
1103      * disconnected mode. For now maintain this compatibility. */
1104     if (vc->peer && vc->peer->info->link_status_changed) {
1105         vc->peer->info->link_status_changed(vc->peer);
1106     }
1107 }
1108
1109 void net_cleanup(void)
1110 {
1111     VLANState *vlan;
1112     VLANClientState *vc, *next_vc;
1113
1114     QTAILQ_FOREACH(vlan, &vlans, next) {
1115         QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1116             qemu_del_vlan_client(vc);
1117         }
1118     }
1119
1120     QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1121         qemu_del_vlan_client(vc);
1122     }
1123 }
1124
1125 void net_check_clients(void)
1126 {
1127     VLANState *vlan;
1128     VLANClientState *vc;
1129     int i;
1130
1131     /* Don't warn about the default network setup that you get if
1132      * no command line -net or -netdev options are specified. There
1133      * are two cases that we would otherwise complain about:
1134      * (1) board doesn't support a NIC but the implicit "-net nic"
1135      * requested one
1136      * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1137      * sets up a nic that isn't connected to anything.
1138      */
1139     if (default_net) {
1140         return;
1141     }
1142
1143     QTAILQ_FOREACH(vlan, &vlans, next) {
1144         int has_nic = 0, has_host_dev = 0;
1145
1146         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1147             switch (vc->info->type) {
1148             case NET_CLIENT_OPTIONS_KIND_NIC:
1149                 has_nic = 1;
1150                 break;
1151             case NET_CLIENT_OPTIONS_KIND_USER:
1152             case NET_CLIENT_OPTIONS_KIND_TAP:
1153             case NET_CLIENT_OPTIONS_KIND_SOCKET:
1154             case NET_CLIENT_OPTIONS_KIND_VDE:
1155                 has_host_dev = 1;
1156                 break;
1157             default: ;
1158             }
1159         }
1160         if (has_host_dev && !has_nic)
1161             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1162         if (has_nic && !has_host_dev)
1163             fprintf(stderr,
1164                     "Warning: vlan %d is not connected to host network\n",
1165                     vlan->id);
1166     }
1167     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1168         if (!vc->peer) {
1169             fprintf(stderr, "Warning: %s %s has no peer\n",
1170                     vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ? "nic" : "netdev",
1171                     vc->name);
1172         }
1173     }
1174
1175     /* Check that all NICs requested via -net nic actually got created.
1176      * NICs created via -device don't need to be checked here because
1177      * they are always instantiated.
1178      */
1179     for (i = 0; i < MAX_NICS; i++) {
1180         NICInfo *nd = &nd_table[i];
1181         if (nd->used && !nd->instantiated) {
1182             fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1183                     "was not created (not supported by this machine?)\n",
1184                     nd->name ? nd->name : "anonymous",
1185                     nd->model ? nd->model : "unspecified");
1186         }
1187     }
1188 }
1189
1190 static int net_init_client(QemuOpts *opts, void *dummy)
1191 {
1192     Error *local_err = NULL;
1193
1194     net_client_init(opts, 0, &local_err);
1195     if (error_is_set(&local_err)) {
1196         qerror_report_err(local_err);
1197         error_free(local_err);
1198         return -1;
1199     }
1200
1201     return 0;
1202 }
1203
1204 static int net_init_netdev(QemuOpts *opts, void *dummy)
1205 {
1206     Error *local_err = NULL;
1207     int ret;
1208
1209     ret = net_client_init(opts, 1, &local_err);
1210     if (error_is_set(&local_err)) {
1211         qerror_report_err(local_err);
1212         error_free(local_err);
1213         return -1;
1214     }
1215
1216     return ret;
1217 }
1218
1219 int net_init_clients(void)
1220 {
1221     QemuOptsList *net = qemu_find_opts("net");
1222
1223     if (default_net) {
1224         /* if no clients, we use a default config */
1225         qemu_opts_set(net, NULL, "type", "nic");
1226 #ifdef CONFIG_SLIRP
1227         qemu_opts_set(net, NULL, "type", "user");
1228 #endif
1229     }
1230
1231     QTAILQ_INIT(&vlans);
1232     QTAILQ_INIT(&non_vlan_clients);
1233
1234     if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1235         return -1;
1236
1237     if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1238         return -1;
1239     }
1240
1241     return 0;
1242 }
1243
1244 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1245 {
1246 #if defined(CONFIG_SLIRP)
1247     int ret;
1248     if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1249         return ret;
1250     }
1251 #endif
1252
1253     if (!qemu_opts_parse(opts_list, optarg, 1)) {
1254         return -1;
1255     }
1256
1257     default_net = 0;
1258     return 0;
1259 }
1260
1261 /* From FreeBSD */
1262 /* XXX: optimize */
1263 unsigned compute_mcast_idx(const uint8_t *ep)
1264 {
1265     uint32_t crc;
1266     int carry, i, j;
1267     uint8_t b;
1268
1269     crc = 0xffffffff;
1270     for (i = 0; i < 6; i++) {
1271         b = *ep++;
1272         for (j = 0; j < 8; j++) {
1273             carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1274             crc <<= 1;
1275             b >>= 1;
1276             if (carry) {
1277                 crc = ((crc ^ POLYNOMIAL) | carry);
1278             }
1279         }
1280     }
1281     return crc >> 26;
1282 }