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