net.c

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