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 #include "config-host.h"
  25
  26 #include "net/net.h"
  27 #include "clients.h"
  28 #include "hub.h"
  29 #include "net/slirp.h"
  30 #include "net/eth.h"
  31 #include "util.h"
  32
  33 #include "monitor/monitor.h"
  34 #include "qemu-common.h"
  35 #include "qemu/sockets.h"
  36 #include "qemu/config-file.h"
  37 #include "qmp-commands.h"
  38 #include "hw/qdev.h"
  39 #include "qemu/iov.h"
  40 #include "qemu/main-loop.h"
  41 #include "qapi-visit.h"
  42 #include "qapi/opts-visitor.h"
  43 #include "qapi/dealloc-visitor.h"
  44 #include "sysemu/sysemu.h"
  45
  46 /* Net bridge is currently not supported for W32. */
  47 #if !defined(_WIN32)
  48 # define CONFIG_NET_BRIDGE
  49 #endif
  50
  51 static VMChangeStateEntry *net_change_state_entry;
  52 static QTAILQ_HEAD(, NetClientState) net_clients;
  53
  54 const char *host_net_devices[] = {
  55     "tap",
  56     "socket",
  57     "dump",
  58 #ifdef CONFIG_NET_BRIDGE
  59     "bridge",
  60 #endif
  61 #ifdef CONFIG_SLIRP
  62     "user",
  63 #endif
  64 #ifdef CONFIG_VDE
  65     "vde",
  66 #endif
  67     "vhost-user",
  68     NULL,
  69 };
  70
  71 int default_net = 1;
  72
  73 /***********************************************************/
  74 /* network device redirectors */
  75
  76 #if defined(DEBUG_NET)
  77 static void hex_dump(FILE *f, const uint8_t *buf, int size)
  78 {
  79     int len, i, j, c;
  80
  81     for(i=0;i<size;i+=16) {
  82         len = size - i;
  83         if (len > 16)
  84             len = 16;
  85         fprintf(f, "%08x ", i);
  86         for(j=0;j<16;j++) {
  87             if (j < len)
  88                 fprintf(f, " %02x", buf[i+j]);
  89             else
  90                 fprintf(f, "   ");
  91         }
  92         fprintf(f, " ");
  93         for(j=0;j<len;j++) {
  94             c = buf[i+j];
  95             if (c < ' ' || c > '~')
  96                 c = '.';
  97             fprintf(f, "%c", c);
  98         }
  99         fprintf(f, "\n");
 100     }
 101 }
 102 #endif
 103
 104 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
 105 {
 106     const char *p, *p1;
 107     int len;
 108     p = *pp;
 109     p1 = strchr(p, sep);
 110     if (!p1)
 111         return -1;
 112     len = p1 - p;
 113     p1++;
 114     if (buf_size > 0) {
 115         if (len > buf_size - 1)
 116             len = buf_size - 1;
 117         memcpy(buf, p, len);
 118         buf[len] = '\0';
 119     }
 120     *pp = p1;
 121     return 0;
 122 }
 123
 124 int parse_host_port(struct sockaddr_in *saddr, const char *str)
 125 {
 126     char buf[512];
 127     struct hostent *he;
 128     const char *p, *r;
 129     int port;
 130
 131     p = str;
 132     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
 133         return -1;
 134     saddr->sin_family = AF_INET;
 135     if (buf[0] == '\0') {
 136         saddr->sin_addr.s_addr = 0;
 137     } else {
 138         if (qemu_isdigit(buf[0])) {
 139             if (!inet_aton(buf, &saddr->sin_addr))
 140                 return -1;
 141         } else {
 142             if ((he = gethostbyname(buf)) == NULL)
 143                 return - 1;
 144             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 145         }
 146     }
 147     port = strtol(p, (char **)&r, 0);
 148     if (r == p)
 149         return -1;
 150     saddr->sin_port = htons(port);
 151     return 0;
 152 }
 153
 154 char *qemu_mac_strdup_printf(const uint8_t *macaddr)
 155 {
 156     return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
 157                            macaddr[0], macaddr[1], macaddr[2],
 158                            macaddr[3], macaddr[4], macaddr[5]);
 159 }
 160
 161 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
 162 {
 163     snprintf(nc->info_str, sizeof(nc->info_str),
 164              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 165              nc->model,
 166              macaddr[0], macaddr[1], macaddr[2],
 167              macaddr[3], macaddr[4], macaddr[5]);
 168 }
 169
 170 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 171 {
 172     static int index = 0;
 173     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 174
 175     if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
 176         return;
 177     macaddr->a[0] = 0x52;
 178     macaddr->a[1] = 0x54;
 179     macaddr->a[2] = 0x00;
 180     macaddr->a[3] = 0x12;
 181     macaddr->a[4] = 0x34;
 182     macaddr->a[5] = 0x56 + index++;
 183 }
 184
 185 /**
 186  * Generate a name for net client
 187  *
 188  * Only net clients created with the legacy -net option and NICs need this.
 189  */
 190 static char *assign_name(NetClientState *nc1, const char *model)
 191 {
 192     NetClientState *nc;
 193     int id = 0;
 194
 195     QTAILQ_FOREACH(nc, &net_clients, next) {
 196         if (nc == nc1) {
 197             continue;
 198         }
 199         if (strcmp(nc->model, model) == 0) {
 200             id++;
 201         }
 202     }
 203
 204     return g_strdup_printf("%s.%d", model, id);
 205 }
 206
 207 static void qemu_net_client_destructor(NetClientState *nc)
 208 {
 209     g_free(nc);
 210 }
 211
 212 static void qemu_net_client_setup(NetClientState *nc,
 213                                   NetClientInfo *info,
 214                                   NetClientState *peer,
 215                                   const char *model,
 216                                   const char *name,
 217                                   NetClientDestructor *destructor)
 218 {
 219     nc->info = info;
 220     nc->model = g_strdup(model);
 221     if (name) {
 222         nc->name = g_strdup(name);
 223     } else {
 224         nc->name = assign_name(nc, model);
 225     }
 226
 227     if (peer) {
 228         assert(!peer->peer);
 229         nc->peer = peer;
 230         peer->peer = nc;
 231     }
 232     QTAILQ_INSERT_TAIL(&net_clients, nc, next);
 233
 234     nc->incoming_queue = qemu_new_net_queue(nc);
 235     nc->destructor = destructor;
 236 }
 237
 238 NetClientState *qemu_new_net_client(NetClientInfo *info,
 239                                     NetClientState *peer,
 240                                     const char *model,
 241                                     const char *name)
 242 {
 243     NetClientState *nc;
 244
 245     assert(info->size >= sizeof(NetClientState));
 246
 247     nc = g_malloc0(info->size);
 248     qemu_net_client_setup(nc, info, peer, model, name,
 249                           qemu_net_client_destructor);
 250
 251     return nc;
 252 }
 253
 254 NICState *qemu_new_nic(NetClientInfo *info,
 255                        NICConf *conf,
 256                        const char *model,
 257                        const char *name,
 258                        void *opaque)
 259 {
 260     NetClientState **peers = conf->peers.ncs;
 261     NICState *nic;
 262     int i, queues = MAX(1, conf->peers.queues);
 263
 264     assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
 265     assert(info->size >= sizeof(NICState));
 266
 267     nic = g_malloc0(info->size + sizeof(NetClientState) * queues);
 268     nic->ncs = (void *)nic + info->size;
 269     nic->conf = conf;
 270     nic->opaque = opaque;
 271
 272     for (i = 0; i < queues; i++) {
 273         qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, name,
 274                               NULL);
 275         nic->ncs[i].queue_index = i;
 276     }
 277
 278     return nic;
 279 }
 280
 281 NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
 282 {
 283     return nic->ncs + queue_index;
 284 }
 285
 286 NetClientState *qemu_get_queue(NICState *nic)
 287 {
 288     return qemu_get_subqueue(nic, 0);
 289 }
 290
 291 NICState *qemu_get_nic(NetClientState *nc)
 292 {
 293     NetClientState *nc0 = nc - nc->queue_index;
 294
 295     return (NICState *)((void *)nc0 - nc->info->size);
 296 }
 297
 298 void *qemu_get_nic_opaque(NetClientState *nc)
 299 {
 300     NICState *nic = qemu_get_nic(nc);
 301
 302     return nic->opaque;
 303 }
 304
 305 static void qemu_cleanup_net_client(NetClientState *nc)
 306 {
 307     QTAILQ_REMOVE(&net_clients, nc, next);
 308
 309     if (nc->info->cleanup) {
 310         nc->info->cleanup(nc);
 311     }
 312 }
 313
 314 static void qemu_free_net_client(NetClientState *nc)
 315 {
 316     if (nc->incoming_queue) {
 317         qemu_del_net_queue(nc->incoming_queue);
 318     }
 319     if (nc->peer) {
 320         nc->peer->peer = NULL;
 321     }
 322     g_free(nc->name);
 323     g_free(nc->model);
 324     if (nc->destructor) {
 325         nc->destructor(nc);
 326     }
 327 }
 328
 329 void qemu_del_net_client(NetClientState *nc)
 330 {
 331     NetClientState *ncs[MAX_QUEUE_NUM];
 332     int queues, i;
 333
 334     assert(nc->info->type != NET_CLIENT_OPTIONS_KIND_NIC);
 335
 336     /* If the NetClientState belongs to a multiqueue backend, we will change all
 337      * other NetClientStates also.
 338      */
 339     queues = qemu_find_net_clients_except(nc->name, ncs,
 340                                           NET_CLIENT_OPTIONS_KIND_NIC,
 341                                           MAX_QUEUE_NUM);
 342     assert(queues != 0);
 343
 344     /* If there is a peer NIC, delete and cleanup client, but do not free. */
 345     if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 346         NICState *nic = qemu_get_nic(nc->peer);
 347         if (nic->peer_deleted) {
 348             return;
 349         }
 350         nic->peer_deleted = true;
 351
 352         for (i = 0; i < queues; i++) {
 353             ncs[i]->peer->link_down = true;
 354         }
 355
 356         if (nc->peer->info->link_status_changed) {
 357             nc->peer->info->link_status_changed(nc->peer);
 358         }
 359
 360         for (i = 0; i < queues; i++) {
 361             qemu_cleanup_net_client(ncs[i]);
 362         }
 363
 364         return;
 365     }
 366
 367     for (i = 0; i < queues; i++) {
 368         qemu_cleanup_net_client(ncs[i]);
 369         qemu_free_net_client(ncs[i]);
 370     }
 371 }
 372
 373 void qemu_del_nic(NICState *nic)
 374 {
 375     int i, queues = MAX(nic->conf->peers.queues, 1);
 376
 377     /* If this is a peer NIC and peer has already been deleted, free it now. */
 378     if (nic->peer_deleted) {
 379         for (i = 0; i < queues; i++) {
 380             qemu_free_net_client(qemu_get_subqueue(nic, i)->peer);
 381         }
 382     }
 383
 384     for (i = queues - 1; i >= 0; i--) {
 385         NetClientState *nc = qemu_get_subqueue(nic, i);
 386
 387         qemu_cleanup_net_client(nc);
 388         qemu_free_net_client(nc);
 389     }
 390
 391     g_free(nic);
 392 }
 393
 394 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
 395 {
 396     NetClientState *nc;
 397
 398     QTAILQ_FOREACH(nc, &net_clients, next) {
 399         if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
 400             if (nc->queue_index == 0) {
 401                 func(qemu_get_nic(nc), opaque);
 402             }
 403         }
 404     }
 405 }
 406
 407 bool qemu_has_ufo(NetClientState *nc)
 408 {
 409     if (!nc || !nc->info->has_ufo) {
 410         return false;
 411     }
 412
 413     return nc->info->has_ufo(nc);
 414 }
 415
 416 bool qemu_has_vnet_hdr(NetClientState *nc)
 417 {
 418     if (!nc || !nc->info->has_vnet_hdr) {
 419         return false;
 420     }
 421
 422     return nc->info->has_vnet_hdr(nc);
 423 }
 424
 425 bool qemu_has_vnet_hdr_len(NetClientState *nc, int len)
 426 {
 427     if (!nc || !nc->info->has_vnet_hdr_len) {
 428         return false;
 429     }
 430
 431     return nc->info->has_vnet_hdr_len(nc, len);
 432 }
 433
 434 void qemu_using_vnet_hdr(NetClientState *nc, bool enable)
 435 {
 436     if (!nc || !nc->info->using_vnet_hdr) {
 437         return;
 438     }
 439
 440     nc->info->using_vnet_hdr(nc, enable);
 441 }
 442
 443 void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
 444                           int ecn, int ufo)
 445 {
 446     if (!nc || !nc->info->set_offload) {
 447         return;
 448     }
 449
 450     nc->info->set_offload(nc, csum, tso4, tso6, ecn, ufo);
 451 }
 452
 453 void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
 454 {
 455     if (!nc || !nc->info->set_vnet_hdr_len) {
 456         return;
 457     }
 458
 459     nc->info->set_vnet_hdr_len(nc, len);
 460 }
 461
 462 int qemu_can_send_packet(NetClientState *sender)
 463 {
 464     int vm_running = runstate_is_running();
 465
 466     if (!vm_running) {
 467         return 0;
 468     }
 469
 470     if (!sender->peer) {
 471         return 1;
 472     }
 473
 474     if (sender->peer->receive_disabled) {
 475         return 0;
 476     } else if (sender->peer->info->can_receive &&
 477                !sender->peer->info->can_receive(sender->peer)) {
 478         return 0;
 479     }
 480     return 1;
 481 }
 482
 483 ssize_t qemu_deliver_packet(NetClientState *sender,
 484                             unsigned flags,
 485                             const uint8_t *data,
 486                             size_t size,
 487                             void *opaque)
 488 {
 489     NetClientState *nc = opaque;
 490     ssize_t ret;
 491
 492     if (nc->link_down) {
 493         return size;
 494     }
 495
 496     if (nc->receive_disabled) {
 497         return 0;
 498     }
 499
 500     if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
 501         ret = nc->info->receive_raw(nc, data, size);
 502     } else {
 503         ret = nc->info->receive(nc, data, size);
 504     }
 505
 506     if (ret == 0) {
 507         nc->receive_disabled = 1;
 508     }
 509
 510     return ret;
 511 }
 512
 513 void qemu_purge_queued_packets(NetClientState *nc)
 514 {
 515     if (!nc->peer) {
 516         return;
 517     }
 518
 519     qemu_net_queue_purge(nc->peer->incoming_queue, nc);
 520 }
 521
 522 static
 523 void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge)
 524 {
 525     nc->receive_disabled = 0;
 526
 527     if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_HUBPORT) {
 528         if (net_hub_flush(nc->peer)) {
 529             qemu_notify_event();
 530         }
 531     }
 532     if (qemu_net_queue_flush(nc->incoming_queue)) {
 533         /* We emptied the queue successfully, signal to the IO thread to repoll
 534          * the file descriptor (for tap, for example).
 535          */
 536         qemu_notify_event();
 537     } else if (purge) {
 538         /* Unable to empty the queue, purge remaining packets */
 539         qemu_net_queue_purge(nc->incoming_queue, nc);
 540     }
 541 }
 542
 543 void qemu_flush_queued_packets(NetClientState *nc)
 544 {
 545     qemu_flush_or_purge_queued_packets(nc, false);
 546 }
 547
 548 static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
 549                                                  unsigned flags,
 550                                                  const uint8_t *buf, int size,
 551                                                  NetPacketSent *sent_cb)
 552 {
 553     NetQueue *queue;
 554
 555 #ifdef DEBUG_NET
 556     printf("qemu_send_packet_async:\n");
 557     hex_dump(stdout, buf, size);
 558 #endif
 559
 560     if (sender->link_down || !sender->peer) {
 561         return size;
 562     }
 563
 564     queue = sender->peer->incoming_queue;
 565
 566     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 567 }
 568
 569 ssize_t qemu_send_packet_async(NetClientState *sender,
 570                                const uint8_t *buf, int size,
 571                                NetPacketSent *sent_cb)
 572 {
 573     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 574                                              buf, size, sent_cb);
 575 }
 576
 577 void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
 578 {
 579     qemu_send_packet_async(nc, buf, size, NULL);
 580 }
 581
 582 ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
 583 {
 584     return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
 585                                              buf, size, NULL);
 586 }
 587
 588 static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
 589                                int iovcnt)
 590 {
 591     uint8_t buffer[NET_BUFSIZE];
 592     size_t offset;
 593
 594     offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
 595
 596     return nc->info->receive(nc, buffer, offset);
 597 }
 598
 599 ssize_t qemu_deliver_packet_iov(NetClientState *sender,
 600                                 unsigned flags,
 601                                 const struct iovec *iov,
 602                                 int iovcnt,
 603                                 void *opaque)
 604 {
 605     NetClientState *nc = opaque;
 606     int ret;
 607
 608     if (nc->link_down) {
 609         return iov_size(iov, iovcnt);
 610     }
 611
 612     if (nc->receive_disabled) {
 613         return 0;
 614     }
 615
 616     if (nc->info->receive_iov) {
 617         ret = nc->info->receive_iov(nc, iov, iovcnt);
 618     } else {
 619         ret = nc_sendv_compat(nc, iov, iovcnt);
 620     }
 621
 622     if (ret == 0) {
 623         nc->receive_disabled = 1;
 624     }
 625
 626     return ret;
 627 }
 628
 629 ssize_t qemu_sendv_packet_async(NetClientState *sender,
 630                                 const struct iovec *iov, int iovcnt,
 631                                 NetPacketSent *sent_cb)
 632 {
 633     NetQueue *queue;
 634
 635     if (sender->link_down || !sender->peer) {
 636         return iov_size(iov, iovcnt);
 637     }
 638
 639     queue = sender->peer->incoming_queue;
 640
 641     return qemu_net_queue_send_iov(queue, sender,
 642                                    QEMU_NET_PACKET_FLAG_NONE,
 643                                    iov, iovcnt, sent_cb);
 644 }
 645
 646 ssize_t
 647 qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
 648 {
 649     return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
 650 }
 651
 652 NetClientState *qemu_find_netdev(const char *id)
 653 {
 654     NetClientState *nc;
 655
 656     QTAILQ_FOREACH(nc, &net_clients, next) {
 657         if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
 658             continue;
 659         if (!strcmp(nc->name, id)) {
 660             return nc;
 661         }
 662     }
 663
 664     return NULL;
 665 }
 666
 667 int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
 668                                  NetClientOptionsKind type, int max)
 669 {
 670     NetClientState *nc;
 671     int ret = 0;
 672
 673     QTAILQ_FOREACH(nc, &net_clients, next) {
 674         if (nc->info->type == type) {
 675             continue;
 676         }
 677         if (!id || !strcmp(nc->name, id)) {
 678             if (ret < max) {
 679                 ncs[ret] = nc;
 680             }
 681             ret++;
 682         }
 683     }
 684
 685     return ret;
 686 }
 687
 688 static int nic_get_free_idx(void)
 689 {
 690     int index;
 691
 692     for (index = 0; index < MAX_NICS; index++)
 693         if (!nd_table[index].used)
 694             return index;
 695     return -1;
 696 }
 697
 698 int qemu_show_nic_models(const char *arg, const char *const *models)
 699 {
 700     int i;
 701
 702     if (!arg || !is_help_option(arg)) {
 703         return 0;
 704     }
 705
 706     fprintf(stderr, "qemu: Supported NIC models: ");
 707     for (i = 0 ; models[i]; i++)
 708         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 709     return 1;
 710 }
 711
 712 void qemu_check_nic_model(NICInfo *nd, const char *model)
 713 {
 714     const char *models[2];
 715
 716     models[0] = model;
 717     models[1] = NULL;
 718
 719     if (qemu_show_nic_models(nd->model, models))
 720         exit(0);
 721     if (qemu_find_nic_model(nd, models, model) < 0)
 722         exit(1);
 723 }
 724
 725 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
 726                         const char *default_model)
 727 {
 728     int i;
 729
 730     if (!nd->model)
 731         nd->model = g_strdup(default_model);
 732
 733     for (i = 0 ; models[i]; i++) {
 734         if (strcmp(nd->model, models[i]) == 0)
 735             return i;
 736     }
 737
 738     error_report("Unsupported NIC model: %s", nd->model);
 739     return -1;
 740 }
 741
 742 static int net_init_nic(const NetClientOptions *opts, const char *name,
 743                         NetClientState *peer, Error **errp)
 744 {
 745     int idx;
 746     NICInfo *nd;
 747     const NetLegacyNicOptions *nic;
 748
 749     assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
 750     nic = opts->nic;
 751
 752     idx = nic_get_free_idx();
 753     if (idx == -1 || nb_nics >= MAX_NICS) {
 754         error_setg(errp, "too many NICs");
 755         return -1;
 756     }
 757
 758     nd = &nd_table[idx];
 759
 760     memset(nd, 0, sizeof(*nd));
 761
 762     if (nic->has_netdev) {
 763         nd->netdev = qemu_find_netdev(nic->netdev);
 764         if (!nd->netdev) {
 765             error_setg(errp, "netdev '%s' not found", nic->netdev);
 766             return -1;
 767         }
 768     } else {
 769         assert(peer);
 770         nd->netdev = peer;
 771     }
 772     nd->name = g_strdup(name);
 773     if (nic->has_model) {
 774         nd->model = g_strdup(nic->model);
 775     }
 776     if (nic->has_addr) {
 777         nd->devaddr = g_strdup(nic->addr);
 778     }
 779
 780     if (nic->has_macaddr &&
 781         net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
 782         error_setg(errp, "invalid syntax for ethernet address");
 783         return -1;
 784     }
 785     if (nic->has_macaddr &&
 786         is_multicast_ether_addr(nd->macaddr.a)) {
 787         error_setg(errp,
 788                    "NIC cannot have multicast MAC address (odd 1st byte)");
 789         return -1;
 790     }
 791     qemu_macaddr_default_if_unset(&nd->macaddr);
 792
 793     if (nic->has_vectors) {
 794         if (nic->vectors > 0x7ffffff) {
 795             error_setg(errp, "invalid # of vectors: %"PRIu32, nic->vectors);
 796             return -1;
 797         }
 798         nd->nvectors = nic->vectors;
 799     } else {
 800         nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
 801     }
 802
 803     nd->used = 1;
 804     nb_nics++;
 805
 806     return idx;
 807 }
 808
 809
 810 static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
 811     const NetClientOptions *opts,
 812     const char *name,
 813     NetClientState *peer, Error **errp) = {
 814         [NET_CLIENT_OPTIONS_KIND_NIC]       = net_init_nic,
 815 #ifdef CONFIG_SLIRP
 816         [NET_CLIENT_OPTIONS_KIND_USER]      = net_init_slirp,
 817 #endif
 818         [NET_CLIENT_OPTIONS_KIND_TAP]       = net_init_tap,
 819         [NET_CLIENT_OPTIONS_KIND_SOCKET]    = net_init_socket,
 820 #ifdef CONFIG_VDE
 821         [NET_CLIENT_OPTIONS_KIND_VDE]       = net_init_vde,
 822 #endif
 823 #ifdef CONFIG_NETMAP
 824         [NET_CLIENT_OPTIONS_KIND_NETMAP]    = net_init_netmap,
 825 #endif
 826         [NET_CLIENT_OPTIONS_KIND_DUMP]      = net_init_dump,
 827 #ifdef CONFIG_NET_BRIDGE
 828         [NET_CLIENT_OPTIONS_KIND_BRIDGE]    = net_init_bridge,
 829 #endif
 830         [NET_CLIENT_OPTIONS_KIND_HUBPORT]   = net_init_hubport,
 831 #ifdef CONFIG_VHOST_NET_USED
 832         [NET_CLIENT_OPTIONS_KIND_VHOST_USER] = net_init_vhost_user,
 833 #endif
 834 #ifdef CONFIG_L2TPV3
 835         [NET_CLIENT_OPTIONS_KIND_L2TPV3]    = net_init_l2tpv3,
 836 #endif
 837 };
 838
 839
 840 static int net_client_init1(const void *object, int is_netdev, Error **errp)
 841 {
 842     union {
 843         const Netdev    *netdev;
 844         const NetLegacy *net;
 845     } u;
 846     const NetClientOptions *opts;
 847     const char *name;
 848
 849     if (is_netdev) {
 850         u.netdev = object;
 851         opts = u.netdev->opts;
 852         name = u.netdev->id;
 853
 854         switch (opts->kind) {
 855 #ifdef CONFIG_SLIRP
 856         case NET_CLIENT_OPTIONS_KIND_USER:
 857 #endif
 858         case NET_CLIENT_OPTIONS_KIND_TAP:
 859         case NET_CLIENT_OPTIONS_KIND_SOCKET:
 860 #ifdef CONFIG_VDE
 861         case NET_CLIENT_OPTIONS_KIND_VDE:
 862 #endif
 863 #ifdef CONFIG_NETMAP
 864         case NET_CLIENT_OPTIONS_KIND_NETMAP:
 865 #endif
 866 #ifdef CONFIG_NET_BRIDGE
 867         case NET_CLIENT_OPTIONS_KIND_BRIDGE:
 868 #endif
 869         case NET_CLIENT_OPTIONS_KIND_HUBPORT:
 870 #ifdef CONFIG_VHOST_NET_USED
 871         case NET_CLIENT_OPTIONS_KIND_VHOST_USER:
 872 #endif
 873 #ifdef CONFIG_L2TPV3
 874         case NET_CLIENT_OPTIONS_KIND_L2TPV3:
 875 #endif
 876             break;
 877
 878         default:
 879             error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
 880                       "a netdev backend type");
 881             return -1;
 882         }
 883     } else {
 884         u.net = object;
 885         opts = u.net->opts;
 886         if (opts->kind == NET_CLIENT_OPTIONS_KIND_HUBPORT) {
 887             error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
 888                       "a net type");
 889             return -1;
 890         }
 891         /* missing optional values have been initialized to "all bits zero" */
 892         name = u.net->has_id ? u.net->id : u.net->name;
 893     }
 894
 895     if (net_client_init_fun[opts->kind]) {
 896         NetClientState *peer = NULL;
 897
 898         /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
 899          * parameter. */
 900         if (!is_netdev &&
 901             (opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
 902              !opts->nic->has_netdev)) {
 903             peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
 904         }
 905
 906         if (net_client_init_fun[opts->kind](opts, name, peer, errp) < 0) {
 907             /* FIXME drop when all init functions store an Error */
 908             if (errp && !*errp) {
 909                 error_set(errp, QERR_DEVICE_INIT_FAILED,
 910                           NetClientOptionsKind_lookup[opts->kind]);
 911             }
 912             return -1;
 913         }
 914     }
 915     return 0;
 916 }
 917
 918
 919 static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
 920 {
 921     if (is_netdev) {
 922         visit_type_Netdev(v, (Netdev **)object, NULL, errp);
 923     } else {
 924         visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
 925     }
 926 }
 927
 928
 929 int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
 930 {
 931     void *object = NULL;
 932     Error *err = NULL;
 933     int ret = -1;
 934
 935     {
 936         OptsVisitor *ov = opts_visitor_new(opts);
 937
 938         net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
 939         opts_visitor_cleanup(ov);
 940     }
 941
 942     if (!err) {
 943         ret = net_client_init1(object, is_netdev, &err);
 944     }
 945
 946     if (object) {
 947         QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
 948
 949         net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
 950         qapi_dealloc_visitor_cleanup(dv);
 951     }
 952
 953     error_propagate(errp, err);
 954     return ret;
 955 }
 956
 957
 958 static int net_host_check_device(const char *device)
 959 {
 960     int i;
 961     for (i = 0; host_net_devices[i]; i++) {
 962         if (!strncmp(host_net_devices[i], device,
 963                      strlen(host_net_devices[i]))) {
 964             return 1;
 965         }
 966     }
 967
 968     return 0;
 969 }
 970
 971 void hmp_host_net_add(Monitor *mon, const QDict *qdict)
 972 {
 973     const char *device = qdict_get_str(qdict, "device");
 974     const char *opts_str = qdict_get_try_str(qdict, "opts");
 975     Error *local_err = NULL;
 976     QemuOpts *opts;
 977
 978     if (!net_host_check_device(device)) {
 979         monitor_printf(mon, "invalid host network device %s\n", device);
 980         return;
 981     }
 982
 983     opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
 984     if (!opts) {
 985         return;
 986     }
 987
 988     qemu_opt_set(opts, "type", device, &error_abort);
 989
 990     net_client_init(opts, 0, &local_err);
 991     if (local_err) {
 992         error_report_err(local_err);
 993         monitor_printf(mon, "adding host network device %s failed\n", device);
 994     }
 995 }
 996
 997 void hmp_host_net_remove(Monitor *mon, const QDict *qdict)
 998 {
 999     NetClientState *nc;
1000     int vlan_id = qdict_get_int(qdict, "vlan_id");
1001     const char *device = qdict_get_str(qdict, "device");
1002
1003     nc = net_hub_find_client_by_name(vlan_id, device);
1004     if (!nc) {
1005         error_report("Host network device '%s' on hub '%d' not found",
1006                      device, vlan_id);
1007         return;
1008     }
1009     if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
1010         error_report("invalid host network device '%s'", device);
1011         return;
1012     }
1013
1014     qemu_del_net_client(nc->peer);
1015     qemu_del_net_client(nc);
1016 }
1017
1018 void netdev_add(QemuOpts *opts, Error **errp)
1019 {
1020     net_client_init(opts, 1, errp);
1021 }
1022
1023 int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
1024 {
1025     Error *local_err = NULL;
1026     QemuOptsList *opts_list;
1027     QemuOpts *opts;
1028
1029     opts_list = qemu_find_opts_err("netdev", &local_err);
1030     if (local_err) {
1031         goto exit_err;
1032     }
1033
1034     opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
1035     if (local_err) {
1036         goto exit_err;
1037     }
1038
1039     netdev_add(opts, &local_err);
1040     if (local_err) {
1041         qemu_opts_del(opts);
1042         goto exit_err;
1043     }
1044
1045     return 0;
1046
1047 exit_err:
1048     qerror_report_err(local_err);
1049     error_free(local_err);
1050     return -1;
1051 }
1052
1053 void qmp_netdev_del(const char *id, Error **errp)
1054 {
1055     NetClientState *nc;
1056     QemuOpts *opts;
1057
1058     nc = qemu_find_netdev(id);
1059     if (!nc) {
1060         error_set(errp, QERR_DEVICE_NOT_FOUND, id);
1061         return;
1062     }
1063
1064     opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), id);
1065     if (!opts) {
1066         error_setg(errp, "Device '%s' is not a netdev", id);
1067         return;
1068     }
1069
1070     qemu_del_net_client(nc);
1071     qemu_opts_del(opts);
1072 }
1073
1074 void print_net_client(Monitor *mon, NetClientState *nc)
1075 {
1076     monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
1077                    nc->queue_index,
1078                    NetClientOptionsKind_lookup[nc->info->type],
1079                    nc->info_str);
1080 }
1081
1082 RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
1083                                       Error **errp)
1084 {
1085     NetClientState *nc;
1086     RxFilterInfoList *filter_list = NULL, *last_entry = NULL;
1087
1088     QTAILQ_FOREACH(nc, &net_clients, next) {
1089         RxFilterInfoList *entry;
1090         RxFilterInfo *info;
1091
1092         if (has_name && strcmp(nc->name, name) != 0) {
1093             continue;
1094         }
1095
1096         /* only query rx-filter information of NIC */
1097         if (nc->info->type != NET_CLIENT_OPTIONS_KIND_NIC) {
1098             if (has_name) {
1099                 error_setg(errp, "net client(%s) isn't a NIC", name);
1100                 return NULL;
1101             }
1102             continue;
1103         }
1104
1105         if (nc->info->query_rx_filter) {
1106             info = nc->info->query_rx_filter(nc);
1107             entry = g_malloc0(sizeof(*entry));
1108             entry->value = info;
1109
1110             if (!filter_list) {
1111                 filter_list = entry;
1112             } else {
1113                 last_entry->next = entry;
1114             }
1115             last_entry = entry;
1116         } else if (has_name) {
1117             error_setg(errp, "net client(%s) doesn't support"
1118                        " rx-filter querying", name);
1119             return NULL;
1120         }
1121
1122         if (has_name) {
1123             break;
1124         }
1125     }
1126
1127     if (filter_list == NULL && has_name) {
1128         error_setg(errp, "invalid net client name: %s", name);
1129     }
1130
1131     return filter_list;
1132 }
1133
1134 void hmp_info_network(Monitor *mon, const QDict *qdict)
1135 {
1136     NetClientState *nc, *peer;
1137     NetClientOptionsKind type;
1138
1139     net_hub_info(mon);
1140
1141     QTAILQ_FOREACH(nc, &net_clients, next) {
1142         peer = nc->peer;
1143         type = nc->info->type;
1144
1145         /* Skip if already printed in hub info */
1146         if (net_hub_id_for_client(nc, NULL) == 0) {
1147             continue;
1148         }
1149
1150         if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
1151             print_net_client(mon, nc);
1152         } /* else it's a netdev connected to a NIC, printed with the NIC */
1153         if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
1154             monitor_printf(mon, " \\ ");
1155             print_net_client(mon, peer);
1156         }
1157     }
1158 }
1159
1160 void qmp_set_link(const char *name, bool up, Error **errp)
1161 {
1162     NetClientState *ncs[MAX_QUEUE_NUM];
1163     NetClientState *nc;
1164     int queues, i;
1165
1166     queues = qemu_find_net_clients_except(name, ncs,
1167                                           NET_CLIENT_OPTIONS_KIND_MAX,
1168                                           MAX_QUEUE_NUM);
1169
1170     if (queues == 0) {
1171         error_set(errp, QERR_DEVICE_NOT_FOUND, name);
1172         return;
1173     }
1174     nc = ncs[0];
1175
1176     for (i = 0; i < queues; i++) {
1177         ncs[i]->link_down = !up;
1178     }
1179
1180     if (nc->info->link_status_changed) {
1181         nc->info->link_status_changed(nc);
1182     }
1183
1184     if (nc->peer) {
1185         /* Change peer link only if the peer is NIC and then notify peer.
1186          * If the peer is a HUBPORT or a backend, we do not change the
1187          * link status.
1188          *
1189          * This behavior is compatible with qemu vlans where there could be
1190          * multiple clients that can still communicate with each other in
1191          * disconnected mode. For now maintain this compatibility.
1192          */
1193         if (nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
1194             for (i = 0; i < queues; i++) {
1195                 ncs[i]->peer->link_down = !up;
1196             }
1197         }
1198         if (nc->peer->info->link_status_changed) {
1199             nc->peer->info->link_status_changed(nc->peer);
1200         }
1201     }
1202 }
1203
1204 static void net_vm_change_state_handler(void *opaque, int running,
1205                                         RunState state)
1206 {
1207     /* Complete all queued packets, to guarantee we don't modify
1208      * state later when VM is not running.
1209      */
1210     if (!running) {
1211         NetClientState *nc;
1212         NetClientState *tmp;
1213
1214         QTAILQ_FOREACH_SAFE(nc, &net_clients, next, tmp) {
1215             qemu_flush_or_purge_queued_packets(nc, true);
1216         }
1217     }
1218 }
1219
1220 void net_cleanup(void)
1221 {
1222     NetClientState *nc;
1223
1224     /* We may del multiple entries during qemu_del_net_client(),
1225      * so QTAILQ_FOREACH_SAFE() is also not safe here.
1226      */
1227     while (!QTAILQ_EMPTY(&net_clients)) {
1228         nc = QTAILQ_FIRST(&net_clients);
1229         if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
1230             qemu_del_nic(qemu_get_nic(nc));
1231         } else {
1232             qemu_del_net_client(nc);
1233         }
1234     }
1235
1236     qemu_del_vm_change_state_handler(net_change_state_entry);
1237 }
1238
1239 void net_check_clients(void)
1240 {
1241     NetClientState *nc;
1242     int i;
1243
1244     /* Don't warn about the default network setup that you get if
1245      * no command line -net or -netdev options are specified. There
1246      * are two cases that we would otherwise complain about:
1247      * (1) board doesn't support a NIC but the implicit "-net nic"
1248      * requested one
1249      * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1250      * sets up a nic that isn't connected to anything.
1251      */
1252     if (default_net) {
1253         return;
1254     }
1255
1256     net_hub_check_clients();
1257
1258     QTAILQ_FOREACH(nc, &net_clients, next) {
1259         if (!nc->peer) {
1260             fprintf(stderr, "Warning: %s %s has no peer\n",
1261                     nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ?
1262                     "nic" : "netdev", nc->name);
1263         }
1264     }
1265
1266     /* Check that all NICs requested via -net nic actually got created.
1267      * NICs created via -device don't need to be checked here because
1268      * they are always instantiated.
1269      */
1270     for (i = 0; i < MAX_NICS; i++) {
1271         NICInfo *nd = &nd_table[i];
1272         if (nd->used && !nd->instantiated) {
1273             fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1274                     "was not created (not supported by this machine?)\n",
1275                     nd->name ? nd->name : "anonymous",
1276                     nd->model ? nd->model : "unspecified");
1277         }
1278     }
1279 }
1280
1281 static int net_init_client(QemuOpts *opts, void *dummy)
1282 {
1283     Error *local_err = NULL;
1284
1285     net_client_init(opts, 0, &local_err);
1286     if (local_err) {
1287         error_report_err(local_err);
1288         return -1;
1289     }
1290
1291     return 0;
1292 }
1293
1294 static int net_init_netdev(QemuOpts *opts, void *dummy)
1295 {
1296     Error *local_err = NULL;
1297     int ret;
1298
1299     ret = net_client_init(opts, 1, &local_err);
1300     if (local_err) {
1301         error_report_err(local_err);
1302         return -1;
1303     }
1304
1305     return ret;
1306 }
1307
1308 int net_init_clients(void)
1309 {
1310     QemuOptsList *net = qemu_find_opts("net");
1311
1312     if (default_net) {
1313         /* if no clients, we use a default config */
1314         qemu_opts_set(net, NULL, "type", "nic", &error_abort);
1315 #ifdef CONFIG_SLIRP
1316         qemu_opts_set(net, NULL, "type", "user", &error_abort);
1317 #endif
1318     }
1319
1320     net_change_state_entry =
1321         qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
1322
1323     QTAILQ_INIT(&net_clients);
1324
1325     if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1326         return -1;
1327
1328     if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1329         return -1;
1330     }
1331
1332     return 0;
1333 }
1334
1335 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1336 {
1337 #if defined(CONFIG_SLIRP)
1338     int ret;
1339     if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1340         return ret;
1341     }
1342 #endif
1343
1344     if (!qemu_opts_parse(opts_list, optarg, 1)) {
1345         return -1;
1346     }
1347
1348     default_net = 0;
1349     return 0;
1350 }
1351
1352 /* From FreeBSD */
1353 /* XXX: optimize */
1354 unsigned compute_mcast_idx(const uint8_t *ep)
1355 {
1356     uint32_t crc;
1357     int carry, i, j;
1358     uint8_t b;
1359
1360     crc = 0xffffffff;
1361     for (i = 0; i < 6; i++) {
1362         b = *ep++;
1363         for (j = 0; j < 8; j++) {
1364             carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1365             crc <<= 1;
1366             b >>= 1;
1367             if (carry) {
1368                 crc = ((crc ^ POLYNOMIAL) | carry);
1369             }
1370         }
1371     }
1372     return crc >> 26;
1373 }
1374
1375 QemuOptsList qemu_netdev_opts = {
1376     .name = "netdev",
1377     .implied_opt_name = "type",
1378     .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1379     .desc = {
1380         /*
1381          * no elements => accept any params
1382          * validation will happen later
1383          */
1384         { /* end of list */ }
1385     },
1386 };
1387
1388 QemuOptsList qemu_net_opts = {
1389     .name = "net",
1390     .implied_opt_name = "type",
1391     .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1392     .desc = {
1393         /*
1394          * no elements => accept any params
1395          * validation will happen later
1396          */
1397         { /* end of list */ }
1398     },
1399 };