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