net/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
  25 #include "qemu/osdep.h"
  26
  27 #include "net/net.h"
  28 #include "clients.h"
  29 #include "hub.h"
  30 #include "net/slirp.h"
  31 #include "net/eth.h"
  32 #include "util.h"
  33
  34 #include "monitor/monitor.h"
  35 #include "qemu/help_option.h"
  36 #include "qapi/qmp/qdict.h"
  37 #include "qapi/qmp/qerror.h"
  38 #include "qemu/error-report.h"
  39 #include "qemu/sockets.h"
  40 #include "qemu/cutils.h"
  41 #include "qemu/config-file.h"
  42 #include "qmp-commands.h"
  43 #include "hw/qdev.h"
  44 #include "qemu/iov.h"
  45 #include "qemu/main-loop.h"
  46 #include "qemu/option.h"
  47 #include "qapi-visit.h"
  48 #include "qapi/error.h"
  49 #include "qapi/opts-visitor.h"
  50 #include "sysemu/sysemu.h"
  51 #include "sysemu/qtest.h"
  52 #include "net/filter.h"
  53 #include "qapi/string-output-visitor.h"
  54
  55 /* Net bridge is currently not supported for W32. */
  56 #if !defined(_WIN32)
  57 # define CONFIG_NET_BRIDGE
  58 #endif
  59
  60 static VMChangeStateEntry *net_change_state_entry;
  61 static QTAILQ_HEAD(, NetClientState) net_clients;
  62
  63 const char *host_net_devices[] = {
  64     "tap",
  65     "socket",
  66     "dump",
  67 #ifdef CONFIG_NET_BRIDGE
  68     "bridge",
  69 #endif
  70 #ifdef CONFIG_NETMAP
  71     "netmap",
  72 #endif
  73 #ifdef CONFIG_SLIRP
  74     "user",
  75 #endif
  76 #ifdef CONFIG_VDE
  77     "vde",
  78 #endif
  79     "vhost-user",
  80     NULL,
  81 };
  82
  83 /***********************************************************/
  84 /* network device redirectors */
  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                     Error **errp)
 108 {
 109     char buf[512];
 110     struct hostent *he;
 111     const char *p, *r;
 112     int port;
 113
 114     p = str;
 115     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
 116         error_setg(errp, "host address '%s' doesn't contain ':' "
 117                    "separating host from port", str);
 118         return -1;
 119     }
 120     saddr->sin_family = AF_INET;
 121     if (buf[0] == '\0') {
 122         saddr->sin_addr.s_addr = 0;
 123     } else {
 124         if (qemu_isdigit(buf[0])) {
 125             if (!inet_aton(buf, &saddr->sin_addr)) {
 126                 error_setg(errp, "host address '%s' is not a valid "
 127                            "IPv4 address", buf);
 128                 return -1;
 129             }
 130         } else {
 131             he = gethostbyname(buf);
 132             if (he == NULL) {
 133                 error_setg(errp, "can't resolve host address '%s'", buf);
 134                 return - 1;
 135             }
 136             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 137         }
 138     }
 139     port = strtol(p, (char **)&r, 0);
 140     if (r == p) {
 141         error_setg(errp, "port number '%s' is invalid", p);
 142         return -1;
 143     }
 144     saddr->sin_port = htons(port);
 145     return 0;
 146 }
 147
 148 char *qemu_mac_strdup_printf(const uint8_t *macaddr)
 149 {
 150     return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
 151                            macaddr[0], macaddr[1], macaddr[2],
 152                            macaddr[3], macaddr[4], macaddr[5]);
 153 }
 154
 155 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
 156 {
 157     snprintf(nc->info_str, sizeof(nc->info_str),
 158              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 159              nc->model,
 160              macaddr[0], macaddr[1], macaddr[2],
 161              macaddr[3], macaddr[4], macaddr[5]);
 162 }
 163
 164 static int mac_table[256] = {0};
 165
 166 static void qemu_macaddr_set_used(MACAddr *macaddr)
 167 {
 168     int index;
 169
 170     for (index = 0x56; index < 0xFF; index++) {
 171         if (macaddr->a[5] == index) {
 172             mac_table[index]++;
 173         }
 174     }
 175 }
 176
 177 static void qemu_macaddr_set_free(MACAddr *macaddr)
 178 {
 179     int index;
 180     static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
 181
 182     if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
 183         return;
 184     }
 185     for (index = 0x56; index < 0xFF; index++) {
 186         if (macaddr->a[5] == index) {
 187             mac_table[index]--;
 188         }
 189     }
 190 }
 191
 192 static int qemu_macaddr_get_free(void)
 193 {
 194     int index;
 195
 196     for (index = 0x56; index < 0xFF; index++) {
 197         if (mac_table[index] == 0) {
 198             return index;
 199         }
 200     }
 201
 202     return -1;
 203 }
 204
 205 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 206 {
 207     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 208     static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
 209
 210     if (memcmp(macaddr, &zero, sizeof(zero)) != 0) {
 211         if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
 212             return;
 213         } else {
 214             qemu_macaddr_set_used(macaddr);
 215             return;
 216         }
 217     }
 218
 219     macaddr->a[0] = 0x52;
 220     macaddr->a[1] = 0x54;
 221     macaddr->a[2] = 0x00;
 222     macaddr->a[3] = 0x12;
 223     macaddr->a[4] = 0x34;
 224     macaddr->a[5] = qemu_macaddr_get_free();
 225     qemu_macaddr_set_used(macaddr);
 226 }
 227
 228 /**
 229  * Generate a name for net client
 230  *
 231  * Only net clients created with the legacy -net option and NICs need this.
 232  */
 233 static char *assign_name(NetClientState *nc1, const char *model)
 234 {
 235     NetClientState *nc;
 236     int id = 0;
 237
 238     QTAILQ_FOREACH(nc, &net_clients, next) {
 239         if (nc == nc1) {
 240             continue;
 241         }
 242         if (strcmp(nc->model, model) == 0) {
 243             id++;
 244         }
 245     }
 246
 247     return g_strdup_printf("%s.%d", model, id);
 248 }
 249
 250 static void qemu_net_client_destructor(NetClientState *nc)
 251 {
 252     g_free(nc);
 253 }
 254
 255 static void qemu_net_client_setup(NetClientState *nc,
 256                                   NetClientInfo *info,
 257                                   NetClientState *peer,
 258                                   const char *model,
 259                                   const char *name,
 260                                   NetClientDestructor *destructor)
 261 {
 262     nc->info = info;
 263     nc->model = g_strdup(model);
 264     if (name) {
 265         nc->name = g_strdup(name);
 266     } else {
 267         nc->name = assign_name(nc, model);
 268     }
 269
 270     if (peer) {
 271         assert(!peer->peer);
 272         nc->peer = peer;
 273         peer->peer = nc;
 274     }
 275     QTAILQ_INSERT_TAIL(&net_clients, nc, next);
 276
 277     nc->incoming_queue = qemu_new_net_queue(qemu_deliver_packet_iov, nc);
 278     nc->destructor = destructor;
 279     QTAILQ_INIT(&nc->filters);
 280 }
 281
 282 NetClientState *qemu_new_net_client(NetClientInfo *info,
 283                                     NetClientState *peer,
 284                                     const char *model,
 285                                     const char *name)
 286 {
 287     NetClientState *nc;
 288
 289     assert(info->size >= sizeof(NetClientState));
 290
 291     nc = g_malloc0(info->size);
 292     qemu_net_client_setup(nc, info, peer, model, name,
 293                           qemu_net_client_destructor);
 294
 295     return nc;
 296 }
 297
 298 NICState *qemu_new_nic(NetClientInfo *info,
 299                        NICConf *conf,
 300                        const char *model,
 301                        const char *name,
 302                        void *opaque)
 303 {
 304     NetClientState **peers = conf->peers.ncs;
 305     NICState *nic;
 306     int i, queues = MAX(1, conf->peers.queues);
 307
 308     assert(info->type == NET_CLIENT_DRIVER_NIC);
 309     assert(info->size >= sizeof(NICState));
 310
 311     nic = g_malloc0(info->size + sizeof(NetClientState) * queues);
 312     nic->ncs = (void *)nic + info->size;
 313     nic->conf = conf;
 314     nic->opaque = opaque;
 315
 316     for (i = 0; i < queues; i++) {
 317         qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, name,
 318                               NULL);
 319         nic->ncs[i].queue_index = i;
 320     }
 321
 322     return nic;
 323 }
 324
 325 NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
 326 {
 327     return nic->ncs + queue_index;
 328 }
 329
 330 NetClientState *qemu_get_queue(NICState *nic)
 331 {
 332     return qemu_get_subqueue(nic, 0);
 333 }
 334
 335 NICState *qemu_get_nic(NetClientState *nc)
 336 {
 337     NetClientState *nc0 = nc - nc->queue_index;
 338
 339     return (NICState *)((void *)nc0 - nc->info->size);
 340 }
 341
 342 void *qemu_get_nic_opaque(NetClientState *nc)
 343 {
 344     NICState *nic = qemu_get_nic(nc);
 345
 346     return nic->opaque;
 347 }
 348
 349 static void qemu_cleanup_net_client(NetClientState *nc)
 350 {
 351     QTAILQ_REMOVE(&net_clients, nc, next);
 352
 353     if (nc->info->cleanup) {
 354         nc->info->cleanup(nc);
 355     }
 356 }
 357
 358 static void qemu_free_net_client(NetClientState *nc)
 359 {
 360     if (nc->incoming_queue) {
 361         qemu_del_net_queue(nc->incoming_queue);
 362     }
 363     if (nc->peer) {
 364         nc->peer->peer = NULL;
 365     }
 366     g_free(nc->name);
 367     g_free(nc->model);
 368     if (nc->destructor) {
 369         nc->destructor(nc);
 370     }
 371 }
 372
 373 void qemu_del_net_client(NetClientState *nc)
 374 {
 375     NetClientState *ncs[MAX_QUEUE_NUM];
 376     int queues, i;
 377     NetFilterState *nf, *next;
 378
 379     assert(nc->info->type != NET_CLIENT_DRIVER_NIC);
 380
 381     /* If the NetClientState belongs to a multiqueue backend, we will change all
 382      * other NetClientStates also.
 383      */
 384     queues = qemu_find_net_clients_except(nc->name, ncs,
 385                                           NET_CLIENT_DRIVER_NIC,
 386                                           MAX_QUEUE_NUM);
 387     assert(queues != 0);
 388
 389     QTAILQ_FOREACH_SAFE(nf, &nc->filters, next, next) {
 390         object_unparent(OBJECT(nf));
 391     }
 392
 393     /* If there is a peer NIC, delete and cleanup client, but do not free. */
 394     if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
 395         NICState *nic = qemu_get_nic(nc->peer);
 396         if (nic->peer_deleted) {
 397             return;
 398         }
 399         nic->peer_deleted = true;
 400
 401         for (i = 0; i < queues; i++) {
 402             ncs[i]->peer->link_down = true;
 403         }
 404
 405         if (nc->peer->info->link_status_changed) {
 406             nc->peer->info->link_status_changed(nc->peer);
 407         }
 408
 409         for (i = 0; i < queues; i++) {
 410             qemu_cleanup_net_client(ncs[i]);
 411         }
 412
 413         return;
 414     }
 415
 416     for (i = 0; i < queues; i++) {
 417         qemu_cleanup_net_client(ncs[i]);
 418         qemu_free_net_client(ncs[i]);
 419     }
 420 }
 421
 422 void qemu_del_nic(NICState *nic)
 423 {
 424     int i, queues = MAX(nic->conf->peers.queues, 1);
 425
 426     qemu_macaddr_set_free(&nic->conf->macaddr);
 427
 428     /* If this is a peer NIC and peer has already been deleted, free it now. */
 429     if (nic->peer_deleted) {
 430         for (i = 0; i < queues; i++) {
 431             qemu_free_net_client(qemu_get_subqueue(nic, i)->peer);
 432         }
 433     }
 434
 435     for (i = queues - 1; i >= 0; i--) {
 436         NetClientState *nc = qemu_get_subqueue(nic, i);
 437
 438         qemu_cleanup_net_client(nc);
 439         qemu_free_net_client(nc);
 440     }
 441
 442     g_free(nic);
 443 }
 444
 445 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
 446 {
 447     NetClientState *nc;
 448
 449     QTAILQ_FOREACH(nc, &net_clients, next) {
 450         if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
 451             if (nc->queue_index == 0) {
 452                 func(qemu_get_nic(nc), opaque);
 453             }
 454         }
 455     }
 456 }
 457
 458 bool qemu_has_ufo(NetClientState *nc)
 459 {
 460     if (!nc || !nc->info->has_ufo) {
 461         return false;
 462     }
 463
 464     return nc->info->has_ufo(nc);
 465 }
 466
 467 bool qemu_has_vnet_hdr(NetClientState *nc)
 468 {
 469     if (!nc || !nc->info->has_vnet_hdr) {
 470         return false;
 471     }
 472
 473     return nc->info->has_vnet_hdr(nc);
 474 }
 475
 476 bool qemu_has_vnet_hdr_len(NetClientState *nc, int len)
 477 {
 478     if (!nc || !nc->info->has_vnet_hdr_len) {
 479         return false;
 480     }
 481
 482     return nc->info->has_vnet_hdr_len(nc, len);
 483 }
 484
 485 void qemu_using_vnet_hdr(NetClientState *nc, bool enable)
 486 {
 487     if (!nc || !nc->info->using_vnet_hdr) {
 488         return;
 489     }
 490
 491     nc->info->using_vnet_hdr(nc, enable);
 492 }
 493
 494 void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
 495                           int ecn, int ufo)
 496 {
 497     if (!nc || !nc->info->set_offload) {
 498         return;
 499     }
 500
 501     nc->info->set_offload(nc, csum, tso4, tso6, ecn, ufo);
 502 }
 503
 504 void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
 505 {
 506     if (!nc || !nc->info->set_vnet_hdr_len) {
 507         return;
 508     }
 509
 510     nc->vnet_hdr_len = len;
 511     nc->info->set_vnet_hdr_len(nc, len);
 512 }
 513
 514 int qemu_set_vnet_le(NetClientState *nc, bool is_le)
 515 {
 516 #ifdef HOST_WORDS_BIGENDIAN
 517     if (!nc || !nc->info->set_vnet_le) {
 518         return -ENOSYS;
 519     }
 520
 521     return nc->info->set_vnet_le(nc, is_le);
 522 #else
 523     return 0;
 524 #endif
 525 }
 526
 527 int qemu_set_vnet_be(NetClientState *nc, bool is_be)
 528 {
 529 #ifdef HOST_WORDS_BIGENDIAN
 530     return 0;
 531 #else
 532     if (!nc || !nc->info->set_vnet_be) {
 533         return -ENOSYS;
 534     }
 535
 536     return nc->info->set_vnet_be(nc, is_be);
 537 #endif
 538 }
 539
 540 int qemu_can_send_packet(NetClientState *sender)
 541 {
 542     int vm_running = runstate_is_running();
 543
 544     if (!vm_running) {
 545         return 0;
 546     }
 547
 548     if (!sender->peer) {
 549         return 1;
 550     }
 551
 552     if (sender->peer->receive_disabled) {
 553         return 0;
 554     } else if (sender->peer->info->can_receive &&
 555                !sender->peer->info->can_receive(sender->peer)) {
 556         return 0;
 557     }
 558     return 1;
 559 }
 560
 561 static ssize_t filter_receive_iov(NetClientState *nc,
 562                                   NetFilterDirection direction,
 563                                   NetClientState *sender,
 564                                   unsigned flags,
 565                                   const struct iovec *iov,
 566                                   int iovcnt,
 567                                   NetPacketSent *sent_cb)
 568 {
 569     ssize_t ret = 0;
 570     NetFilterState *nf = NULL;
 571
 572     if (direction == NET_FILTER_DIRECTION_TX) {
 573         QTAILQ_FOREACH(nf, &nc->filters, next) {
 574             ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
 575                                          iovcnt, sent_cb);
 576             if (ret) {
 577                 return ret;
 578             }
 579         }
 580     } else {
 581         QTAILQ_FOREACH_REVERSE(nf, &nc->filters, NetFilterHead, next) {
 582             ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
 583                                          iovcnt, sent_cb);
 584             if (ret) {
 585                 return ret;
 586             }
 587         }
 588     }
 589
 590     return ret;
 591 }
 592
 593 static ssize_t filter_receive(NetClientState *nc,
 594                               NetFilterDirection direction,
 595                               NetClientState *sender,
 596                               unsigned flags,
 597                               const uint8_t *data,
 598                               size_t size,
 599                               NetPacketSent *sent_cb)
 600 {
 601     struct iovec iov = {
 602         .iov_base = (void *)data,
 603         .iov_len = size
 604     };
 605
 606     return filter_receive_iov(nc, direction, sender, flags, &iov, 1, sent_cb);
 607 }
 608
 609 void qemu_purge_queued_packets(NetClientState *nc)
 610 {
 611     if (!nc->peer) {
 612         return;
 613     }
 614
 615     qemu_net_queue_purge(nc->peer->incoming_queue, nc);
 616 }
 617
 618 static
 619 void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge)
 620 {
 621     nc->receive_disabled = 0;
 622
 623     if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_HUBPORT) {
 624         if (net_hub_flush(nc->peer)) {
 625             qemu_notify_event();
 626         }
 627     }
 628     if (qemu_net_queue_flush(nc->incoming_queue)) {
 629         /* We emptied the queue successfully, signal to the IO thread to repoll
 630          * the file descriptor (for tap, for example).
 631          */
 632         qemu_notify_event();
 633     } else if (purge) {
 634         /* Unable to empty the queue, purge remaining packets */
 635         qemu_net_queue_purge(nc->incoming_queue, nc);
 636     }
 637 }
 638
 639 void qemu_flush_queued_packets(NetClientState *nc)
 640 {
 641     qemu_flush_or_purge_queued_packets(nc, false);
 642 }
 643
 644 static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
 645                                                  unsigned flags,
 646                                                  const uint8_t *buf, int size,
 647                                                  NetPacketSent *sent_cb)
 648 {
 649     NetQueue *queue;
 650     int ret;
 651
 652 #ifdef DEBUG_NET
 653     printf("qemu_send_packet_async:\n");
 654     qemu_hexdump((const char *)buf, stdout, "net", size);
 655 #endif
 656
 657     if (sender->link_down || !sender->peer) {
 658         return size;
 659     }
 660
 661     /* Let filters handle the packet first */
 662     ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
 663                          sender, flags, buf, size, sent_cb);
 664     if (ret) {
 665         return ret;
 666     }
 667
 668     ret = filter_receive(sender->peer, NET_FILTER_DIRECTION_RX,
 669                          sender, flags, buf, size, sent_cb);
 670     if (ret) {
 671         return ret;
 672     }
 673
 674     queue = sender->peer->incoming_queue;
 675
 676     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 677 }
 678
 679 ssize_t qemu_send_packet_async(NetClientState *sender,
 680                                const uint8_t *buf, int size,
 681                                NetPacketSent *sent_cb)
 682 {
 683     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 684                                              buf, size, sent_cb);
 685 }
 686
 687 void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
 688 {
 689     qemu_send_packet_async(nc, buf, size, NULL);
 690 }
 691
 692 ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
 693 {
 694     return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
 695                                              buf, size, NULL);
 696 }
 697
 698 static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
 699                                int iovcnt, unsigned flags)
 700 {
 701     uint8_t *buf = NULL;
 702     uint8_t *buffer;
 703     size_t offset;
 704     ssize_t ret;
 705
 706     if (iovcnt == 1) {
 707         buffer = iov[0].iov_base;
 708         offset = iov[0].iov_len;
 709     } else {
 710         offset = iov_size(iov, iovcnt);
 711         if (offset > NET_BUFSIZE) {
 712             return -1;
 713         }
 714         buf = g_malloc(offset);
 715         buffer = buf;
 716         offset = iov_to_buf(iov, iovcnt, 0, buf, offset);
 717     }
 718
 719     if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
 720         ret = nc->info->receive_raw(nc, buffer, offset);
 721     } else {
 722         ret = nc->info->receive(nc, buffer, offset);
 723     }
 724
 725     g_free(buf);
 726     return ret;
 727 }
 728
 729 ssize_t qemu_deliver_packet_iov(NetClientState *sender,
 730                                 unsigned flags,
 731                                 const struct iovec *iov,
 732                                 int iovcnt,
 733                                 void *opaque)
 734 {
 735     NetClientState *nc = opaque;
 736     int ret;
 737
 738     if (nc->link_down) {
 739         return iov_size(iov, iovcnt);
 740     }
 741
 742     if (nc->receive_disabled) {
 743         return 0;
 744     }
 745
 746     if (nc->info->receive_iov && !(flags & QEMU_NET_PACKET_FLAG_RAW)) {
 747         ret = nc->info->receive_iov(nc, iov, iovcnt);
 748     } else {
 749         ret = nc_sendv_compat(nc, iov, iovcnt, flags);
 750     }
 751
 752     if (ret == 0) {
 753         nc->receive_disabled = 1;
 754     }
 755
 756     return ret;
 757 }
 758
 759 ssize_t qemu_sendv_packet_async(NetClientState *sender,
 760                                 const struct iovec *iov, int iovcnt,
 761                                 NetPacketSent *sent_cb)
 762 {
 763     NetQueue *queue;
 764     int ret;
 765
 766     if (sender->link_down || !sender->peer) {
 767         return iov_size(iov, iovcnt);
 768     }
 769
 770     /* Let filters handle the packet first */
 771     ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
 772                              QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
 773     if (ret) {
 774         return ret;
 775     }
 776
 777     ret = filter_receive_iov(sender->peer, NET_FILTER_DIRECTION_RX, sender,
 778                              QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
 779     if (ret) {
 780         return ret;
 781     }
 782
 783     queue = sender->peer->incoming_queue;
 784
 785     return qemu_net_queue_send_iov(queue, sender,
 786                                    QEMU_NET_PACKET_FLAG_NONE,
 787                                    iov, iovcnt, sent_cb);
 788 }
 789
 790 ssize_t
 791 qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
 792 {
 793     return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
 794 }
 795
 796 NetClientState *qemu_find_netdev(const char *id)
 797 {
 798     NetClientState *nc;
 799
 800     QTAILQ_FOREACH(nc, &net_clients, next) {
 801         if (nc->info->type == NET_CLIENT_DRIVER_NIC)
 802             continue;
 803         if (!strcmp(nc->name, id)) {
 804             return nc;
 805         }
 806     }
 807
 808     return NULL;
 809 }
 810
 811 int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
 812                                  NetClientDriver type, int max)
 813 {
 814     NetClientState *nc;
 815     int ret = 0;
 816
 817     QTAILQ_FOREACH(nc, &net_clients, next) {
 818         if (nc->info->type == type) {
 819             continue;
 820         }
 821         if (!id || !strcmp(nc->name, id)) {
 822             if (ret < max) {
 823                 ncs[ret] = nc;
 824             }
 825             ret++;
 826         }
 827     }
 828
 829     return ret;
 830 }
 831
 832 static int nic_get_free_idx(void)
 833 {
 834     int index;
 835
 836     for (index = 0; index < MAX_NICS; index++)
 837         if (!nd_table[index].used)
 838             return index;
 839     return -1;
 840 }
 841
 842 int qemu_show_nic_models(const char *arg, const char *const *models)
 843 {
 844     int i;
 845
 846     if (!arg || !is_help_option(arg)) {
 847         return 0;
 848     }
 849
 850     fprintf(stderr, "qemu: Supported NIC models: ");
 851     for (i = 0 ; models[i]; i++)
 852         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 853     return 1;
 854 }
 855
 856 void qemu_check_nic_model(NICInfo *nd, const char *model)
 857 {
 858     const char *models[2];
 859
 860     models[0] = model;
 861     models[1] = NULL;
 862
 863     if (qemu_show_nic_models(nd->model, models))
 864         exit(0);
 865     if (qemu_find_nic_model(nd, models, model) < 0)
 866         exit(1);
 867 }
 868
 869 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
 870                         const char *default_model)
 871 {
 872     int i;
 873
 874     if (!nd->model)
 875         nd->model = g_strdup(default_model);
 876
 877     for (i = 0 ; models[i]; i++) {
 878         if (strcmp(nd->model, models[i]) == 0)
 879             return i;
 880     }
 881
 882     error_report("Unsupported NIC model: %s", nd->model);
 883     return -1;
 884 }
 885
 886 static int net_init_nic(const Netdev *netdev, const char *name,
 887                         NetClientState *peer, Error **errp)
 888 {
 889     int idx;
 890     NICInfo *nd;
 891     const NetLegacyNicOptions *nic;
 892
 893     assert(netdev->type == NET_CLIENT_DRIVER_NIC);
 894     nic = &netdev->u.nic;
 895
 896     idx = nic_get_free_idx();
 897     if (idx == -1 || nb_nics >= MAX_NICS) {
 898         error_setg(errp, "too many NICs");
 899         return -1;
 900     }
 901
 902     nd = &nd_table[idx];
 903
 904     memset(nd, 0, sizeof(*nd));
 905
 906     if (nic->has_netdev) {
 907         nd->netdev = qemu_find_netdev(nic->netdev);
 908         if (!nd->netdev) {
 909             error_setg(errp, "netdev '%s' not found", nic->netdev);
 910             return -1;
 911         }
 912     } else {
 913         assert(peer);
 914         nd->netdev = peer;
 915     }
 916     nd->name = g_strdup(name);
 917     if (nic->has_model) {
 918         nd->model = g_strdup(nic->model);
 919     }
 920     if (nic->has_addr) {
 921         nd->devaddr = g_strdup(nic->addr);
 922     }
 923
 924     if (nic->has_macaddr &&
 925         net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
 926         error_setg(errp, "invalid syntax for ethernet address");
 927         return -1;
 928     }
 929     if (nic->has_macaddr &&
 930         is_multicast_ether_addr(nd->macaddr.a)) {
 931         error_setg(errp,
 932                    "NIC cannot have multicast MAC address (odd 1st byte)");
 933         return -1;
 934     }
 935     qemu_macaddr_default_if_unset(&nd->macaddr);
 936
 937     if (nic->has_vectors) {
 938         if (nic->vectors > 0x7ffffff) {
 939             error_setg(errp, "invalid # of vectors: %"PRIu32, nic->vectors);
 940             return -1;
 941         }
 942         nd->nvectors = nic->vectors;
 943     } else {
 944         nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
 945     }
 946
 947     nd->used = 1;
 948     nb_nics++;
 949
 950     return idx;
 951 }
 952
 953
 954 static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
 955     const Netdev *netdev,
 956     const char *name,
 957     NetClientState *peer, Error **errp) = {
 958         [NET_CLIENT_DRIVER_NIC]       = net_init_nic,
 959 #ifdef CONFIG_SLIRP
 960         [NET_CLIENT_DRIVER_USER]      = net_init_slirp,
 961 #endif
 962         [NET_CLIENT_DRIVER_TAP]       = net_init_tap,
 963         [NET_CLIENT_DRIVER_SOCKET]    = net_init_socket,
 964 #ifdef CONFIG_VDE
 965         [NET_CLIENT_DRIVER_VDE]       = net_init_vde,
 966 #endif
 967 #ifdef CONFIG_NETMAP
 968         [NET_CLIENT_DRIVER_NETMAP]    = net_init_netmap,
 969 #endif
 970         [NET_CLIENT_DRIVER_DUMP]      = net_init_dump,
 971 #ifdef CONFIG_NET_BRIDGE
 972         [NET_CLIENT_DRIVER_BRIDGE]    = net_init_bridge,
 973 #endif
 974         [NET_CLIENT_DRIVER_HUBPORT]   = net_init_hubport,
 975 #ifdef CONFIG_VHOST_NET_USED
 976         [NET_CLIENT_DRIVER_VHOST_USER] = net_init_vhost_user,
 977 #endif
 978 #ifdef CONFIG_L2TPV3
 979         [NET_CLIENT_DRIVER_L2TPV3]    = net_init_l2tpv3,
 980 #endif
 981 };
 982
 983
 984 static int net_client_init1(const void *object, bool is_netdev, Error **errp)
 985 {
 986     Netdev legacy = {0};
 987     const Netdev *netdev;
 988     const char *name;
 989     NetClientState *peer = NULL;
 990     static bool vlan_warned;
 991
 992     if (is_netdev) {
 993         netdev = object;
 994         name = netdev->id;
 995
 996         if (netdev->type == NET_CLIENT_DRIVER_DUMP ||
 997             netdev->type == NET_CLIENT_DRIVER_NIC ||
 998             !net_client_init_fun[netdev->type]) {
 999             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1000                        "a netdev backend type");
1001             return -1;
1002         }
1003     } else {
1004         const NetLegacy *net = object;
1005         const NetLegacyOptions *opts = net->opts;
1006         legacy.id = net->id;
1007         netdev = &legacy;
1008         /* missing optional values have been initialized to "all bits zero" */
1009         name = net->has_id ? net->id : net->name;
1010
1011         /* Map the old options to the new flat type */
1012         switch (opts->type) {
1013         case NET_LEGACY_OPTIONS_TYPE_NONE:
1014             return 0; /* nothing to do */
1015         case NET_LEGACY_OPTIONS_TYPE_NIC:
1016             legacy.type = NET_CLIENT_DRIVER_NIC;
1017             legacy.u.nic = opts->u.nic;
1018             break;
1019         case NET_LEGACY_OPTIONS_TYPE_USER:
1020             legacy.type = NET_CLIENT_DRIVER_USER;
1021             legacy.u.user = opts->u.user;
1022             break;
1023         case NET_LEGACY_OPTIONS_TYPE_TAP:
1024             legacy.type = NET_CLIENT_DRIVER_TAP;
1025             legacy.u.tap = opts->u.tap;
1026             break;
1027         case NET_LEGACY_OPTIONS_TYPE_L2TPV3:
1028             legacy.type = NET_CLIENT_DRIVER_L2TPV3;
1029             legacy.u.l2tpv3 = opts->u.l2tpv3;
1030             break;
1031         case NET_LEGACY_OPTIONS_TYPE_SOCKET:
1032             legacy.type = NET_CLIENT_DRIVER_SOCKET;
1033             legacy.u.socket = opts->u.socket;
1034             break;
1035         case NET_LEGACY_OPTIONS_TYPE_VDE:
1036             legacy.type = NET_CLIENT_DRIVER_VDE;
1037             legacy.u.vde = opts->u.vde;
1038             break;
1039         case NET_LEGACY_OPTIONS_TYPE_DUMP:
1040             legacy.type = NET_CLIENT_DRIVER_DUMP;
1041             legacy.u.dump = opts->u.dump;
1042             break;
1043         case NET_LEGACY_OPTIONS_TYPE_BRIDGE:
1044             legacy.type = NET_CLIENT_DRIVER_BRIDGE;
1045             legacy.u.bridge = opts->u.bridge;
1046             break;
1047         case NET_LEGACY_OPTIONS_TYPE_NETMAP:
1048             legacy.type = NET_CLIENT_DRIVER_NETMAP;
1049             legacy.u.netmap = opts->u.netmap;
1050             break;
1051         case NET_LEGACY_OPTIONS_TYPE_VHOST_USER:
1052             legacy.type = NET_CLIENT_DRIVER_VHOST_USER;
1053             legacy.u.vhost_user = opts->u.vhost_user;
1054             break;
1055         default:
1056             abort();
1057         }
1058
1059         if (!net_client_init_fun[netdev->type]) {
1060             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1061                        "a net backend type (maybe it is not compiled "
1062                        "into this binary)");
1063             return -1;
1064         }
1065
1066         /* Do not add to a vlan if it's a nic with a netdev= parameter. */
1067         if (netdev->type != NET_CLIENT_DRIVER_NIC ||
1068             !opts->u.nic.has_netdev) {
1069             peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL, NULL);
1070         }
1071
1072         if (net->has_vlan && !vlan_warned) {
1073             error_report("'vlan' is deprecated. Please use 'netdev' instead.");
1074             vlan_warned = true;
1075         }
1076     }
1077
1078     if (net_client_init_fun[netdev->type](netdev, name, peer, errp) < 0) {
1079         /* FIXME drop when all init functions store an Error */
1080         if (errp && !*errp) {
1081             error_setg(errp, QERR_DEVICE_INIT_FAILED,
1082                        NetClientDriver_str(netdev->type));
1083         }
1084         return -1;
1085     }
1086     return 0;
1087 }
1088
1089
1090 int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)
1091 {
1092     void *object = NULL;
1093     Error *err = NULL;
1094     int ret = -1;
1095     Visitor *v = opts_visitor_new(opts);
1096
1097     {
1098         /* Parse convenience option format ip6-net=fec0::0[/64] */
1099         const char *ip6_net = qemu_opt_get(opts, "ipv6-net");
1100
1101         if (ip6_net) {
1102             char buf[strlen(ip6_net) + 1];
1103
1104             if (get_str_sep(buf, sizeof(buf), &ip6_net, '/') < 0) {
1105                 /* Default 64bit prefix length.  */
1106                 qemu_opt_set(opts, "ipv6-prefix", ip6_net, &error_abort);
1107                 qemu_opt_set_number(opts, "ipv6-prefixlen", 64, &error_abort);
1108             } else {
1109                 /* User-specified prefix length.  */
1110                 unsigned long len;
1111                 int err;
1112
1113                 qemu_opt_set(opts, "ipv6-prefix", buf, &error_abort);
1114                 err = qemu_strtoul(ip6_net, NULL, 10, &len);
1115
1116                 if (err) {
1117                     error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1118                               "ipv6-prefix", "a number");
1119                 } else {
1120                     qemu_opt_set_number(opts, "ipv6-prefixlen", len,
1121                                         &error_abort);
1122                 }
1123             }
1124             qemu_opt_unset(opts, "ipv6-net");
1125         }
1126     }
1127
1128     if (is_netdev) {
1129         visit_type_Netdev(v, NULL, (Netdev **)&object, &err);
1130     } else {
1131         visit_type_NetLegacy(v, NULL, (NetLegacy **)&object, &err);
1132     }
1133
1134     if (!err) {
1135         ret = net_client_init1(object, is_netdev, &err);
1136     }
1137
1138     if (is_netdev) {
1139         qapi_free_Netdev(object);
1140     } else {
1141         qapi_free_NetLegacy(object);
1142     }
1143
1144     error_propagate(errp, err);
1145     visit_free(v);
1146     return ret;
1147 }
1148
1149
1150 static int net_host_check_device(const char *device)
1151 {
1152     int i;
1153     for (i = 0; host_net_devices[i]; i++) {
1154         if (!strncmp(host_net_devices[i], device,
1155                      strlen(host_net_devices[i]))) {
1156             return 1;
1157         }
1158     }
1159
1160     return 0;
1161 }
1162
1163 void hmp_host_net_add(Monitor *mon, const QDict *qdict)
1164 {
1165     const char *device = qdict_get_str(qdict, "device");
1166     const char *opts_str = qdict_get_try_str(qdict, "opts");
1167     Error *local_err = NULL;
1168     QemuOpts *opts;
1169     static bool warned;
1170
1171     if (!warned && !qtest_enabled()) {
1172         error_report("host_net_add is deprecated, use netdev_add instead");
1173         warned = true;
1174     }
1175
1176     if (!net_host_check_device(device)) {
1177         monitor_printf(mon, "invalid host network device %s\n", device);
1178         return;
1179     }
1180
1181     opts = qemu_opts_parse_noisily(qemu_find_opts("net"),
1182                                    opts_str ? opts_str : "", false);
1183     if (!opts) {
1184         return;
1185     }
1186
1187     qemu_opt_set(opts, "type", device, &error_abort);
1188
1189     net_client_init(opts, false, &local_err);
1190     if (local_err) {
1191         error_report_err(local_err);
1192         monitor_printf(mon, "adding host network device %s failed\n", device);
1193     }
1194 }
1195
1196 void hmp_host_net_remove(Monitor *mon, const QDict *qdict)
1197 {
1198     NetClientState *nc;
1199     int vlan_id = qdict_get_int(qdict, "vlan_id");
1200     const char *device = qdict_get_str(qdict, "device");
1201     static bool warned;
1202
1203     if (!warned && !qtest_enabled()) {
1204         error_report("host_net_remove is deprecated, use netdev_del instead");
1205         warned = true;
1206     }
1207
1208     nc = net_hub_find_client_by_name(vlan_id, device);
1209     if (!nc) {
1210         error_report("Host network device '%s' on hub '%d' not found",
1211                      device, vlan_id);
1212         return;
1213     }
1214     if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
1215         error_report("invalid host network device '%s'", device);
1216         return;
1217     }
1218
1219     qemu_del_net_client(nc->peer);
1220     qemu_del_net_client(nc);
1221     qemu_opts_del(qemu_opts_find(qemu_find_opts("net"), device));
1222 }
1223
1224 void netdev_add(QemuOpts *opts, Error **errp)
1225 {
1226     net_client_init(opts, true, errp);
1227 }
1228
1229 void qmp_netdev_add(QDict *qdict, QObject **ret, Error **errp)
1230 {
1231     Error *local_err = NULL;
1232     QemuOptsList *opts_list;
1233     QemuOpts *opts;
1234
1235     opts_list = qemu_find_opts_err("netdev", &local_err);
1236     if (local_err) {
1237         goto out;
1238     }
1239
1240     opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
1241     if (local_err) {
1242         goto out;
1243     }
1244
1245     netdev_add(opts, &local_err);
1246     if (local_err) {
1247         qemu_opts_del(opts);
1248         goto out;
1249     }
1250
1251 out:
1252     error_propagate(errp, local_err);
1253 }
1254
1255 void qmp_netdev_del(const char *id, Error **errp)
1256 {
1257     NetClientState *nc;
1258     QemuOpts *opts;
1259
1260     nc = qemu_find_netdev(id);
1261     if (!nc) {
1262         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1263                   "Device '%s' not found", id);
1264         return;
1265     }
1266
1267     opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), id);
1268     if (!opts) {
1269         error_setg(errp, "Device '%s' is not a netdev", id);
1270         return;
1271     }
1272
1273     qemu_del_net_client(nc);
1274     qemu_opts_del(opts);
1275 }
1276
1277 static void netfilter_print_info(Monitor *mon, NetFilterState *nf)
1278 {
1279     char *str;
1280     ObjectProperty *prop;
1281     ObjectPropertyIterator iter;
1282     Visitor *v;
1283
1284     /* generate info str */
1285     object_property_iter_init(&iter, OBJECT(nf));
1286     while ((prop = object_property_iter_next(&iter))) {
1287         if (!strcmp(prop->name, "type")) {
1288             continue;
1289         }
1290         v = string_output_visitor_new(false, &str);
1291         object_property_get(OBJECT(nf), v, prop->name, NULL);
1292         visit_complete(v, &str);
1293         visit_free(v);
1294         monitor_printf(mon, ",%s=%s", prop->name, str);
1295         g_free(str);
1296     }
1297     monitor_printf(mon, "\n");
1298 }
1299
1300 void print_net_client(Monitor *mon, NetClientState *nc)
1301 {
1302     NetFilterState *nf;
1303
1304     monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
1305                    nc->queue_index,
1306                    NetClientDriver_str(nc->info->type),
1307                    nc->info_str);
1308     if (!QTAILQ_EMPTY(&nc->filters)) {
1309         monitor_printf(mon, "filters:\n");
1310     }
1311     QTAILQ_FOREACH(nf, &nc->filters, next) {
1312         char *path = object_get_canonical_path_component(OBJECT(nf));
1313
1314         monitor_printf(mon, "  - %s: type=%s", path,
1315                        object_get_typename(OBJECT(nf)));
1316         netfilter_print_info(mon, nf);
1317         g_free(path);
1318     }
1319 }
1320
1321 RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
1322                                       Error **errp)
1323 {
1324     NetClientState *nc;
1325     RxFilterInfoList *filter_list = NULL, *last_entry = NULL;
1326
1327     QTAILQ_FOREACH(nc, &net_clients, next) {
1328         RxFilterInfoList *entry;
1329         RxFilterInfo *info;
1330
1331         if (has_name && strcmp(nc->name, name) != 0) {
1332             continue;
1333         }
1334
1335         /* only query rx-filter information of NIC */
1336         if (nc->info->type != NET_CLIENT_DRIVER_NIC) {
1337             if (has_name) {
1338                 error_setg(errp, "net client(%s) isn't a NIC", name);
1339                 return NULL;
1340             }
1341             continue;
1342         }
1343
1344         /* only query information on queue 0 since the info is per nic,
1345          * not per queue
1346          */
1347         if (nc->queue_index != 0)
1348             continue;
1349
1350         if (nc->info->query_rx_filter) {
1351             info = nc->info->query_rx_filter(nc);
1352             entry = g_malloc0(sizeof(*entry));
1353             entry->value = info;
1354
1355             if (!filter_list) {
1356                 filter_list = entry;
1357             } else {
1358                 last_entry->next = entry;
1359             }
1360             last_entry = entry;
1361         } else if (has_name) {
1362             error_setg(errp, "net client(%s) doesn't support"
1363                        " rx-filter querying", name);
1364             return NULL;
1365         }
1366
1367         if (has_name) {
1368             break;
1369         }
1370     }
1371
1372     if (filter_list == NULL && has_name) {
1373         error_setg(errp, "invalid net client name: %s", name);
1374     }
1375
1376     return filter_list;
1377 }
1378
1379 void hmp_info_network(Monitor *mon, const QDict *qdict)
1380 {
1381     NetClientState *nc, *peer;
1382     NetClientDriver type;
1383
1384     net_hub_info(mon);
1385
1386     QTAILQ_FOREACH(nc, &net_clients, next) {
1387         peer = nc->peer;
1388         type = nc->info->type;
1389
1390         /* Skip if already printed in hub info */
1391         if (net_hub_id_for_client(nc, NULL) == 0) {
1392             continue;
1393         }
1394
1395         if (!peer || type == NET_CLIENT_DRIVER_NIC) {
1396             print_net_client(mon, nc);
1397         } /* else it's a netdev connected to a NIC, printed with the NIC */
1398         if (peer && type == NET_CLIENT_DRIVER_NIC) {
1399             monitor_printf(mon, " \\ ");
1400             print_net_client(mon, peer);
1401         }
1402     }
1403 }
1404
1405 void qmp_set_link(const char *name, bool up, Error **errp)
1406 {
1407     NetClientState *ncs[MAX_QUEUE_NUM];
1408     NetClientState *nc;
1409     int queues, i;
1410
1411     queues = qemu_find_net_clients_except(name, ncs,
1412                                           NET_CLIENT_DRIVER__MAX,
1413                                           MAX_QUEUE_NUM);
1414
1415     if (queues == 0) {
1416         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1417                   "Device '%s' not found", name);
1418         return;
1419     }
1420     nc = ncs[0];
1421
1422     for (i = 0; i < queues; i++) {
1423         ncs[i]->link_down = !up;
1424     }
1425
1426     if (nc->info->link_status_changed) {
1427         nc->info->link_status_changed(nc);
1428     }
1429
1430     if (nc->peer) {
1431         /* Change peer link only if the peer is NIC and then notify peer.
1432          * If the peer is a HUBPORT or a backend, we do not change the
1433          * link status.
1434          *
1435          * This behavior is compatible with qemu vlans where there could be
1436          * multiple clients that can still communicate with each other in
1437          * disconnected mode. For now maintain this compatibility.
1438          */
1439         if (nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
1440             for (i = 0; i < queues; i++) {
1441                 ncs[i]->peer->link_down = !up;
1442             }
1443         }
1444         if (nc->peer->info->link_status_changed) {
1445             nc->peer->info->link_status_changed(nc->peer);
1446         }
1447     }
1448 }
1449
1450 static void net_vm_change_state_handler(void *opaque, int running,
1451                                         RunState state)
1452 {
1453     NetClientState *nc;
1454     NetClientState *tmp;
1455
1456     QTAILQ_FOREACH_SAFE(nc, &net_clients, next, tmp) {
1457         if (running) {
1458             /* Flush queued packets and wake up backends. */
1459             if (nc->peer && qemu_can_send_packet(nc)) {
1460                 qemu_flush_queued_packets(nc->peer);
1461             }
1462         } else {
1463             /* Complete all queued packets, to guarantee we don't modify
1464              * state later when VM is not running.
1465              */
1466             qemu_flush_or_purge_queued_packets(nc, true);
1467         }
1468     }
1469 }
1470
1471 void net_cleanup(void)
1472 {
1473     NetClientState *nc;
1474
1475     /* We may del multiple entries during qemu_del_net_client(),
1476      * so QTAILQ_FOREACH_SAFE() is also not safe here.
1477      */
1478     while (!QTAILQ_EMPTY(&net_clients)) {
1479         nc = QTAILQ_FIRST(&net_clients);
1480         if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
1481             qemu_del_nic(qemu_get_nic(nc));
1482         } else {
1483             qemu_del_net_client(nc);
1484         }
1485     }
1486
1487     qemu_del_vm_change_state_handler(net_change_state_entry);
1488 }
1489
1490 void net_check_clients(void)
1491 {
1492     NetClientState *nc;
1493     int i;
1494
1495     net_hub_check_clients();
1496
1497     QTAILQ_FOREACH(nc, &net_clients, next) {
1498         if (!nc->peer) {
1499             warn_report("%s %s has no peer",
1500                         nc->info->type == NET_CLIENT_DRIVER_NIC
1501                         ? "nic" : "netdev",
1502                         nc->name);
1503         }
1504     }
1505
1506     /* Check that all NICs requested via -net nic actually got created.
1507      * NICs created via -device don't need to be checked here because
1508      * they are always instantiated.
1509      */
1510     for (i = 0; i < MAX_NICS; i++) {
1511         NICInfo *nd = &nd_table[i];
1512         if (nd->used && !nd->instantiated) {
1513             warn_report("requested NIC (%s, model %s) "
1514                         "was not created (not supported by this machine?)",
1515                         nd->name ? nd->name : "anonymous",
1516                         nd->model ? nd->model : "unspecified");
1517         }
1518     }
1519 }
1520
1521 static int net_init_client(void *dummy, QemuOpts *opts, Error **errp)
1522 {
1523     Error *local_err = NULL;
1524
1525     net_client_init(opts, false, &local_err);
1526     if (local_err) {
1527         error_report_err(local_err);
1528         return -1;
1529     }
1530
1531     return 0;
1532 }
1533
1534 static int net_init_netdev(void *dummy, QemuOpts *opts, Error **errp)
1535 {
1536     Error *local_err = NULL;
1537     int ret;
1538
1539     ret = net_client_init(opts, true, &local_err);
1540     if (local_err) {
1541         error_report_err(local_err);
1542         return -1;
1543     }
1544
1545     return ret;
1546 }
1547
1548 int net_init_clients(void)
1549 {
1550     QemuOptsList *net = qemu_find_opts("net");
1551
1552     net_change_state_entry =
1553         qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
1554
1555     QTAILQ_INIT(&net_clients);
1556
1557     if (qemu_opts_foreach(qemu_find_opts("netdev"),
1558                           net_init_netdev, NULL, NULL)) {
1559         return -1;
1560     }
1561
1562     if (qemu_opts_foreach(net, net_init_client, NULL, NULL)) {
1563         return -1;
1564     }
1565
1566     return 0;
1567 }
1568
1569 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1570 {
1571     if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
1572         return -1;
1573     }
1574
1575     return 0;
1576 }
1577
1578 /* From FreeBSD */
1579 /* XXX: optimize */
1580 uint32_t net_crc32(const uint8_t *p, int len)
1581 {
1582     uint32_t crc;
1583     int carry, i, j;
1584     uint8_t b;
1585
1586     crc = 0xffffffff;
1587     for (i = 0; i < len; i++) {
1588         b = *p++;
1589         for (j = 0; j < 8; j++) {
1590             carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1591             crc <<= 1;
1592             b >>= 1;
1593             if (carry) {
1594                 crc = ((crc ^ POLYNOMIAL_BE) | carry);
1595             }
1596         }
1597     }
1598
1599     return crc;
1600 }
1601
1602 uint32_t net_crc32_le(const uint8_t *p, int len)
1603 {
1604     uint32_t crc;
1605     int carry, i, j;
1606     uint8_t b;
1607
1608     crc = 0xffffffff;
1609     for (i = 0; i < len; i++) {
1610         b = *p++;
1611         for (j = 0; j < 8; j++) {
1612             carry = (crc & 0x1) ^ (b & 0x01);
1613             crc >>= 1;
1614             b >>= 1;
1615             if (carry) {
1616                 crc ^= POLYNOMIAL_LE;
1617             }
1618         }
1619     }
1620
1621     return crc;
1622 }
1623
1624 QemuOptsList qemu_netdev_opts = {
1625     .name = "netdev",
1626     .implied_opt_name = "type",
1627     .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1628     .desc = {
1629         /*
1630          * no elements => accept any params
1631          * validation will happen later
1632          */
1633         { /* end of list */ }
1634     },
1635 };
1636
1637 QemuOptsList qemu_net_opts = {
1638     .name = "net",
1639     .implied_opt_name = "type",
1640     .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1641     .desc = {
1642         /*
1643          * no elements => accept any params
1644          * validation will happen later
1645          */
1646         { /* end of list */ }
1647     },
1648 };
1649
1650 void net_socket_rs_init(SocketReadState *rs,
1651                         SocketReadStateFinalize *finalize,
1652                         bool vnet_hdr)
1653 {
1654     rs->state = 0;
1655     rs->vnet_hdr = vnet_hdr;
1656     rs->index = 0;
1657     rs->packet_len = 0;
1658     rs->vnet_hdr_len = 0;
1659     memset(rs->buf, 0, sizeof(rs->buf));
1660     rs->finalize = finalize;
1661 }
1662
1663 /*
1664  * Returns
1665  * 0: success
1666  * -1: error occurs
1667  */
1668 int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
1669 {
1670     unsigned int l;
1671
1672     while (size > 0) {
1673         /* Reassemble a packet from the network.
1674          * 0 = getting length.
1675          * 1 = getting vnet header length.
1676          * 2 = getting data.
1677          */
1678         switch (rs->state) {
1679         case 0:
1680             l = 4 - rs->index;
1681             if (l > size) {
1682                 l = size;
1683             }
1684             memcpy(rs->buf + rs->index, buf, l);
1685             buf += l;
1686             size -= l;
1687             rs->index += l;
1688             if (rs->index == 4) {
1689                 /* got length */
1690                 rs->packet_len = ntohl(*(uint32_t *)rs->buf);
1691                 rs->index = 0;
1692                 if (rs->vnet_hdr) {
1693                     rs->state = 1;
1694                 } else {
1695                     rs->state = 2;
1696                     rs->vnet_hdr_len = 0;
1697                 }
1698             }
1699             break;
1700         case 1:
1701             l = 4 - rs->index;
1702             if (l > size) {
1703                 l = size;
1704             }
1705             memcpy(rs->buf + rs->index, buf, l);
1706             buf += l;
1707             size -= l;
1708             rs->index += l;
1709             if (rs->index == 4) {
1710                 /* got vnet header length */
1711                 rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
1712                 rs->index = 0;
1713                 rs->state = 2;
1714             }
1715             break;
1716         case 2:
1717             l = rs->packet_len - rs->index;
1718             if (l > size) {
1719                 l = size;
1720             }
1721             if (rs->index + l <= sizeof(rs->buf)) {
1722                 memcpy(rs->buf + rs->index, buf, l);
1723             } else {
1724                 fprintf(stderr, "serious error: oversized packet received,"
1725                     "connection terminated.\n");
1726                 rs->index = rs->state = 0;
1727                 return -1;
1728             }
1729
1730             rs->index += l;
1731             buf += l;
1732             size -= l;
1733             if (rs->index >= rs->packet_len) {
1734                 rs->index = 0;
1735                 rs->state = 0;
1736                 assert(rs->finalize);
1737                 rs->finalize(rs);
1738             }
1739             break;
1740         }
1741     }
1742
1743     assert(size == 0);
1744     return 0;
1745 }