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/util.h"
  34 #include "monitor.h"
  35 #include "sysemu.h"
  36 #include "qemu-common.h"
  37 #include "qemu_socket.h"
  38 #include "hw/qdev.h"
  39 #include "iov.h"
  40
  41 static QTAILQ_HEAD(, VLANState) vlans;
  42 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
  43
  44 int default_net = 1;
  45
  46 /***********************************************************/
  47 /* network device redirectors */
  48
  49 #if defined(DEBUG_NET)
  50 static void hex_dump(FILE *f, const uint8_t *buf, int size)
  51 {
  52     int len, i, j, c;
  53
  54     for(i=0;i<size;i+=16) {
  55         len = size - i;
  56         if (len > 16)
  57             len = 16;
  58         fprintf(f, "%08x ", i);
  59         for(j=0;j<16;j++) {
  60             if (j < len)
  61                 fprintf(f, " %02x", buf[i+j]);
  62             else
  63                 fprintf(f, "   ");
  64         }
  65         fprintf(f, " ");
  66         for(j=0;j<len;j++) {
  67             c = buf[i+j];
  68             if (c < ' ' || c > '~')
  69                 c = '.';
  70             fprintf(f, "%c", c);
  71         }
  72         fprintf(f, "\n");
  73     }
  74 }
  75 #endif
  76
  77 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
  78 {
  79     const char *p, *p1;
  80     int len;
  81     p = *pp;
  82     p1 = strchr(p, sep);
  83     if (!p1)
  84         return -1;
  85     len = p1 - p;
  86     p1++;
  87     if (buf_size > 0) {
  88         if (len > buf_size - 1)
  89             len = buf_size - 1;
  90         memcpy(buf, p, len);
  91         buf[len] = '\0';
  92     }
  93     *pp = p1;
  94     return 0;
  95 }
  96
  97 int parse_host_port(struct sockaddr_in *saddr, const char *str)
  98 {
  99     char buf[512];
 100     struct hostent *he;
 101     const char *p, *r;
 102     int port;
 103
 104     p = str;
 105     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
 106         return -1;
 107     saddr->sin_family = AF_INET;
 108     if (buf[0] == '\0') {
 109         saddr->sin_addr.s_addr = 0;
 110     } else {
 111         if (qemu_isdigit(buf[0])) {
 112             if (!inet_aton(buf, &saddr->sin_addr))
 113                 return -1;
 114         } else {
 115             if ((he = gethostbyname(buf)) == NULL)
 116                 return - 1;
 117             saddr->sin_addr = *(struct in_addr *)he->h_addr;
 118         }
 119     }
 120     port = strtol(p, (char **)&r, 0);
 121     if (r == p)
 122         return -1;
 123     saddr->sin_port = htons(port);
 124     return 0;
 125 }
 126
 127 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
 128 {
 129     snprintf(vc->info_str, sizeof(vc->info_str),
 130              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 131              vc->model,
 132              macaddr[0], macaddr[1], macaddr[2],
 133              macaddr[3], macaddr[4], macaddr[5]);
 134 }
 135
 136 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 137 {
 138     static int index = 0;
 139     static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
 140
 141     if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
 142         return;
 143     macaddr->a[0] = 0x52;
 144     macaddr->a[1] = 0x54;
 145     macaddr->a[2] = 0x00;
 146     macaddr->a[3] = 0x12;
 147     macaddr->a[4] = 0x34;
 148     macaddr->a[5] = 0x56 + index++;
 149 }
 150
 151 static char *assign_name(VLANClientState *vc1, const char *model)
 152 {
 153     VLANState *vlan;
 154     char buf[256];
 155     int id = 0;
 156
 157     QTAILQ_FOREACH(vlan, &vlans, next) {
 158         VLANClientState *vc;
 159
 160         QTAILQ_FOREACH(vc, &vlan->clients, next) {
 161             if (vc != vc1 && strcmp(vc->model, model) == 0) {
 162                 id++;
 163             }
 164         }
 165     }
 166
 167     snprintf(buf, sizeof(buf), "%s.%d", model, id);
 168
 169     return qemu_strdup(buf);
 170 }
 171
 172 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 173                                    unsigned flags,
 174                                    const uint8_t *data,
 175                                    size_t size,
 176                                    void *opaque);
 177 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 178                                        unsigned flags,
 179                                        const struct iovec *iov,
 180                                        int iovcnt,
 181                                        void *opaque);
 182
 183 VLANClientState *qemu_new_net_client(NetClientInfo *info,
 184                                      VLANState *vlan,
 185                                      VLANClientState *peer,
 186                                      const char *model,
 187                                      const char *name)
 188 {
 189     VLANClientState *vc;
 190
 191     assert(info->size >= sizeof(VLANClientState));
 192
 193     vc = qemu_mallocz(info->size);
 194
 195     vc->info = info;
 196     vc->model = qemu_strdup(model);
 197     if (name) {
 198         vc->name = qemu_strdup(name);
 199     } else {
 200         vc->name = assign_name(vc, model);
 201     }
 202
 203     if (vlan) {
 204         assert(!peer);
 205         vc->vlan = vlan;
 206         QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
 207     } else {
 208         if (peer) {
 209             assert(!peer->peer);
 210             vc->peer = peer;
 211             peer->peer = vc;
 212         }
 213         QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
 214
 215         vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
 216                                             qemu_deliver_packet_iov,
 217                                             vc);
 218     }
 219
 220     return vc;
 221 }
 222
 223 NICState *qemu_new_nic(NetClientInfo *info,
 224                        NICConf *conf,
 225                        const char *model,
 226                        const char *name,
 227                        void *opaque)
 228 {
 229     VLANClientState *nc;
 230     NICState *nic;
 231
 232     assert(info->type == NET_CLIENT_TYPE_NIC);
 233     assert(info->size >= sizeof(NICState));
 234
 235     nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
 236
 237     nic = DO_UPCAST(NICState, nc, nc);
 238     nic->conf = conf;
 239     nic->opaque = opaque;
 240
 241     return nic;
 242 }
 243
 244 static void qemu_cleanup_vlan_client(VLANClientState *vc)
 245 {
 246     if (vc->vlan) {
 247         QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
 248     } else {
 249         QTAILQ_REMOVE(&non_vlan_clients, vc, next);
 250     }
 251
 252     if (vc->info->cleanup) {
 253         vc->info->cleanup(vc);
 254     }
 255 }
 256
 257 static void qemu_free_vlan_client(VLANClientState *vc)
 258 {
 259     if (!vc->vlan) {
 260         if (vc->send_queue) {
 261             qemu_del_net_queue(vc->send_queue);
 262         }
 263         if (vc->peer) {
 264             vc->peer->peer = NULL;
 265         }
 266     }
 267     qemu_free(vc->name);
 268     qemu_free(vc->model);
 269     qemu_free(vc);
 270 }
 271
 272 void qemu_del_vlan_client(VLANClientState *vc)
 273 {
 274     /* If there is a peer NIC, delete and cleanup client, but do not free. */
 275     if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
 276         NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
 277         if (nic->peer_deleted) {
 278             return;
 279         }
 280         nic->peer_deleted = true;
 281         /* Let NIC know peer is gone. */
 282         vc->peer->link_down = true;
 283         if (vc->peer->info->link_status_changed) {
 284             vc->peer->info->link_status_changed(vc->peer);
 285         }
 286         qemu_cleanup_vlan_client(vc);
 287         return;
 288     }
 289
 290     /* If this is a peer NIC and peer has already been deleted, free it now. */
 291     if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
 292         NICState *nic = DO_UPCAST(NICState, nc, vc);
 293         if (nic->peer_deleted) {
 294             qemu_free_vlan_client(vc->peer);
 295         }
 296     }
 297
 298     qemu_cleanup_vlan_client(vc);
 299     qemu_free_vlan_client(vc);
 300 }
 301
 302 VLANClientState *
 303 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
 304                               const char *client_str)
 305 {
 306     VLANState *vlan;
 307     VLANClientState *vc;
 308
 309     vlan = qemu_find_vlan(vlan_id, 0);
 310     if (!vlan) {
 311         monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
 312         return NULL;
 313     }
 314
 315     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 316         if (!strcmp(vc->name, client_str)) {
 317             break;
 318         }
 319     }
 320     if (!vc) {
 321         monitor_printf(mon, "can't find device %s on VLAN %d\n",
 322                        client_str, vlan_id);
 323     }
 324
 325     return vc;
 326 }
 327
 328 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
 329 {
 330     VLANClientState *nc;
 331     VLANState *vlan;
 332
 333     QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
 334         if (nc->info->type == NET_CLIENT_TYPE_NIC) {
 335             func(DO_UPCAST(NICState, nc, nc), opaque);
 336         }
 337     }
 338
 339     QTAILQ_FOREACH(vlan, &vlans, next) {
 340         QTAILQ_FOREACH(nc, &vlan->clients, next) {
 341             if (nc->info->type == NET_CLIENT_TYPE_NIC) {
 342                 func(DO_UPCAST(NICState, nc, nc), opaque);
 343             }
 344         }
 345     }
 346 }
 347
 348 int qemu_can_send_packet(VLANClientState *sender)
 349 {
 350     VLANState *vlan = sender->vlan;
 351     VLANClientState *vc;
 352
 353     if (sender->peer) {
 354         if (sender->peer->receive_disabled) {
 355             return 0;
 356         } else if (sender->peer->info->can_receive &&
 357                    !sender->peer->info->can_receive(sender->peer)) {
 358             return 0;
 359         } else {
 360             return 1;
 361         }
 362     }
 363
 364     if (!sender->vlan) {
 365         return 1;
 366     }
 367
 368     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 369         if (vc == sender) {
 370             continue;
 371         }
 372
 373         /* no can_receive() handler, they can always receive */
 374         if (vc->info->can_receive && !vc->info->can_receive(vc)) {
 375             return 0;
 376         }
 377     }
 378     return 1;
 379 }
 380
 381 static ssize_t qemu_deliver_packet(VLANClientState *sender,
 382                                    unsigned flags,
 383                                    const uint8_t *data,
 384                                    size_t size,
 385                                    void *opaque)
 386 {
 387     VLANClientState *vc = opaque;
 388     ssize_t ret;
 389
 390     if (vc->link_down) {
 391         return size;
 392     }
 393
 394     if (vc->receive_disabled) {
 395         return 0;
 396     }
 397
 398     if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 399         ret = vc->info->receive_raw(vc, data, size);
 400     } else {
 401         ret = vc->info->receive(vc, data, size);
 402     }
 403
 404     if (ret == 0) {
 405         vc->receive_disabled = 1;
 406     };
 407
 408     return ret;
 409 }
 410
 411 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
 412                                         unsigned flags,
 413                                         const uint8_t *buf,
 414                                         size_t size,
 415                                         void *opaque)
 416 {
 417     VLANState *vlan = opaque;
 418     VLANClientState *vc;
 419     ssize_t ret = -1;
 420
 421     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 422         ssize_t len;
 423
 424         if (vc == sender) {
 425             continue;
 426         }
 427
 428         if (vc->link_down) {
 429             ret = size;
 430             continue;
 431         }
 432
 433         if (vc->receive_disabled) {
 434             ret = 0;
 435             continue;
 436         }
 437
 438         if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
 439             len = vc->info->receive_raw(vc, buf, size);
 440         } else {
 441             len = vc->info->receive(vc, buf, size);
 442         }
 443
 444         if (len == 0) {
 445             vc->receive_disabled = 1;
 446         }
 447
 448         ret = (ret >= 0) ? ret : len;
 449
 450     }
 451
 452     return ret;
 453 }
 454
 455 void qemu_purge_queued_packets(VLANClientState *vc)
 456 {
 457     NetQueue *queue;
 458
 459     if (!vc->peer && !vc->vlan) {
 460         return;
 461     }
 462
 463     if (vc->peer) {
 464         queue = vc->peer->send_queue;
 465     } else {
 466         queue = vc->vlan->send_queue;
 467     }
 468
 469     qemu_net_queue_purge(queue, vc);
 470 }
 471
 472 void qemu_flush_queued_packets(VLANClientState *vc)
 473 {
 474     NetQueue *queue;
 475
 476     vc->receive_disabled = 0;
 477
 478     if (vc->vlan) {
 479         queue = vc->vlan->send_queue;
 480     } else {
 481         queue = vc->send_queue;
 482     }
 483
 484     qemu_net_queue_flush(queue);
 485 }
 486
 487 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
 488                                                  unsigned flags,
 489                                                  const uint8_t *buf, int size,
 490                                                  NetPacketSent *sent_cb)
 491 {
 492     NetQueue *queue;
 493
 494 #ifdef DEBUG_NET
 495     printf("qemu_send_packet_async:\n");
 496     hex_dump(stdout, buf, size);
 497 #endif
 498
 499     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 500         return size;
 501     }
 502
 503     if (sender->peer) {
 504         queue = sender->peer->send_queue;
 505     } else {
 506         queue = sender->vlan->send_queue;
 507     }
 508
 509     return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
 510 }
 511
 512 ssize_t qemu_send_packet_async(VLANClientState *sender,
 513                                const uint8_t *buf, int size,
 514                                NetPacketSent *sent_cb)
 515 {
 516     return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
 517                                              buf, size, sent_cb);
 518 }
 519
 520 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
 521 {
 522     qemu_send_packet_async(vc, buf, size, NULL);
 523 }
 524
 525 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
 526 {
 527     return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
 528                                              buf, size, NULL);
 529 }
 530
 531 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
 532                                int iovcnt)
 533 {
 534     uint8_t buffer[4096];
 535     size_t offset;
 536
 537     offset = iov_to_buf(iov, iovcnt, buffer, 0, sizeof(buffer));
 538
 539     return vc->info->receive(vc, buffer, offset);
 540 }
 541
 542 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
 543                                        unsigned flags,
 544                                        const struct iovec *iov,
 545                                        int iovcnt,
 546                                        void *opaque)
 547 {
 548     VLANClientState *vc = opaque;
 549
 550     if (vc->link_down) {
 551         return iov_size(iov, iovcnt);
 552     }
 553
 554     if (vc->info->receive_iov) {
 555         return vc->info->receive_iov(vc, iov, iovcnt);
 556     } else {
 557         return vc_sendv_compat(vc, iov, iovcnt);
 558     }
 559 }
 560
 561 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
 562                                             unsigned flags,
 563                                             const struct iovec *iov,
 564                                             int iovcnt,
 565                                             void *opaque)
 566 {
 567     VLANState *vlan = opaque;
 568     VLANClientState *vc;
 569     ssize_t ret = -1;
 570
 571     QTAILQ_FOREACH(vc, &vlan->clients, next) {
 572         ssize_t len;
 573
 574         if (vc == sender) {
 575             continue;
 576         }
 577
 578         if (vc->link_down) {
 579             ret = iov_size(iov, iovcnt);
 580             continue;
 581         }
 582
 583         assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
 584
 585         if (vc->info->receive_iov) {
 586             len = vc->info->receive_iov(vc, iov, iovcnt);
 587         } else {
 588             len = vc_sendv_compat(vc, iov, iovcnt);
 589         }
 590
 591         ret = (ret >= 0) ? ret : len;
 592     }
 593
 594     return ret;
 595 }
 596
 597 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
 598                                 const struct iovec *iov, int iovcnt,
 599                                 NetPacketSent *sent_cb)
 600 {
 601     NetQueue *queue;
 602
 603     if (sender->link_down || (!sender->peer && !sender->vlan)) {
 604         return iov_size(iov, iovcnt);
 605     }
 606
 607     if (sender->peer) {
 608         queue = sender->peer->send_queue;
 609     } else {
 610         queue = sender->vlan->send_queue;
 611     }
 612
 613     return qemu_net_queue_send_iov(queue, sender,
 614                                    QEMU_NET_PACKET_FLAG_NONE,
 615                                    iov, iovcnt, sent_cb);
 616 }
 617
 618 ssize_t
 619 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
 620 {
 621     return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
 622 }
 623
 624 /* find or alloc a new VLAN */
 625 VLANState *qemu_find_vlan(int id, int allocate)
 626 {
 627     VLANState *vlan;
 628
 629     QTAILQ_FOREACH(vlan, &vlans, next) {
 630         if (vlan->id == id) {
 631             return vlan;
 632         }
 633     }
 634
 635     if (!allocate) {
 636         return NULL;
 637     }
 638
 639     vlan = qemu_mallocz(sizeof(VLANState));
 640     vlan->id = id;
 641     QTAILQ_INIT(&vlan->clients);
 642
 643     vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
 644                                           qemu_vlan_deliver_packet_iov,
 645                                           vlan);
 646
 647     QTAILQ_INSERT_TAIL(&vlans, vlan, next);
 648
 649     return vlan;
 650 }
 651
 652 VLANClientState *qemu_find_netdev(const char *id)
 653 {
 654     VLANClientState *vc;
 655
 656     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
 657         if (!strcmp(vc->name, id)) {
 658             return vc;
 659         }
 660     }
 661
 662     return NULL;
 663 }
 664
 665 static int nic_get_free_idx(void)
 666 {
 667     int index;
 668
 669     for (index = 0; index < MAX_NICS; index++)
 670         if (!nd_table[index].used)
 671             return index;
 672     return -1;
 673 }
 674
 675 int qemu_show_nic_models(const char *arg, const char *const *models)
 676 {
 677     int i;
 678
 679     if (!arg || strcmp(arg, "?"))
 680         return 0;
 681
 682     fprintf(stderr, "qemu: Supported NIC models: ");
 683     for (i = 0 ; models[i]; i++)
 684         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 685     return 1;
 686 }
 687
 688 void qemu_check_nic_model(NICInfo *nd, const char *model)
 689 {
 690     const char *models[2];
 691
 692     models[0] = model;
 693     models[1] = NULL;
 694
 695     if (qemu_show_nic_models(nd->model, models))
 696         exit(0);
 697     if (qemu_find_nic_model(nd, models, model) < 0)
 698         exit(1);
 699 }
 700
 701 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
 702                         const char *default_model)
 703 {
 704     int i;
 705
 706     if (!nd->model)
 707         nd->model = qemu_strdup(default_model);
 708
 709     for (i = 0 ; models[i]; i++) {
 710         if (strcmp(nd->model, models[i]) == 0)
 711             return i;
 712     }
 713
 714     error_report("qemu: Unsupported NIC model: %s", nd->model);
 715     return -1;
 716 }
 717
 718 int net_handle_fd_param(Monitor *mon, const char *param)
 719 {
 720     int fd;
 721
 722     if (!qemu_isdigit(param[0]) && mon) {
 723
 724         fd = monitor_get_fd(mon, param);
 725         if (fd == -1) {
 726             error_report("No file descriptor named %s found", param);
 727             return -1;
 728         }
 729     } else {
 730         char *endptr = NULL;
 731
 732         fd = strtol(param, &endptr, 10);
 733         if (*endptr || (fd == 0 && param == endptr)) {
 734             return -1;
 735         }
 736     }
 737
 738     return fd;
 739 }
 740
 741 static int net_init_nic(QemuOpts *opts,
 742                         Monitor *mon,
 743                         const char *name,
 744                         VLANState *vlan)
 745 {
 746     int idx;
 747     NICInfo *nd;
 748     const char *netdev;
 749
 750     idx = nic_get_free_idx();
 751     if (idx == -1 || nb_nics >= MAX_NICS) {
 752         error_report("Too Many NICs");
 753         return -1;
 754     }
 755
 756     nd = &nd_table[idx];
 757
 758     memset(nd, 0, sizeof(*nd));
 759
 760     if ((netdev = qemu_opt_get(opts, "netdev"))) {
 761         nd->netdev = qemu_find_netdev(netdev);
 762         if (!nd->netdev) {
 763             error_report("netdev '%s' not found", netdev);
 764             return -1;
 765         }
 766     } else {
 767         assert(vlan);
 768         nd->vlan = vlan;
 769     }
 770     if (name) {
 771         nd->name = qemu_strdup(name);
 772     }
 773     if (qemu_opt_get(opts, "model")) {
 774         nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
 775     }
 776     if (qemu_opt_get(opts, "addr")) {
 777         nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
 778     }
 779
 780     nd->macaddr[0] = 0x52;
 781     nd->macaddr[1] = 0x54;
 782     nd->macaddr[2] = 0x00;
 783     nd->macaddr[3] = 0x12;
 784     nd->macaddr[4] = 0x34;
 785     nd->macaddr[5] = 0x56 + idx;
 786
 787     if (qemu_opt_get(opts, "macaddr") &&
 788         net_parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
 789         error_report("invalid syntax for ethernet address");
 790         return -1;
 791     }
 792
 793     nd->nvectors = qemu_opt_get_number(opts, "vectors",
 794                                        DEV_NVECTORS_UNSPECIFIED);
 795     if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
 796         (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
 797         error_report("invalid # of vectors: %d", nd->nvectors);
 798         return -1;
 799     }
 800
 801     nd->used = 1;
 802     nb_nics++;
 803
 804     return idx;
 805 }
 806
 807 #define NET_COMMON_PARAMS_DESC                     \
 808     {                                              \
 809         .name = "type",                            \
 810         .type = QEMU_OPT_STRING,                   \
 811         .help = "net client type (nic, tap etc.)", \
 812      }, {                                          \
 813         .name = "vlan",                            \
 814         .type = QEMU_OPT_NUMBER,                   \
 815         .help = "vlan number",                     \
 816      }, {                                          \
 817         .name = "name",                            \
 818         .type = QEMU_OPT_STRING,                   \
 819         .help = "identifier for monitor commands", \
 820      }
 821
 822 typedef int (*net_client_init_func)(QemuOpts *opts,
 823                                     Monitor *mon,
 824                                     const char *name,
 825                                     VLANState *vlan);
 826
 827 /* magic number, but compiler will warn if too small */
 828 #define NET_MAX_DESC 20
 829
 830 static const struct {
 831     const char *type;
 832     net_client_init_func init;
 833     QemuOptDesc desc[NET_MAX_DESC];
 834 } net_client_types[] = {
 835     {
 836         .type = "none",
 837         .desc = {
 838             NET_COMMON_PARAMS_DESC,
 839             { /* end of list */ }
 840         },
 841     }, {
 842         .type = "nic",
 843         .init = net_init_nic,
 844         .desc = {
 845             NET_COMMON_PARAMS_DESC,
 846             {
 847                 .name = "netdev",
 848                 .type = QEMU_OPT_STRING,
 849                 .help = "id of -netdev to connect to",
 850             },
 851             {
 852                 .name = "macaddr",
 853                 .type = QEMU_OPT_STRING,
 854                 .help = "MAC address",
 855             }, {
 856                 .name = "model",
 857                 .type = QEMU_OPT_STRING,
 858                 .help = "device model (e1000, rtl8139, virtio etc.)",
 859             }, {
 860                 .name = "addr",
 861                 .type = QEMU_OPT_STRING,
 862                 .help = "PCI device address",
 863             }, {
 864                 .name = "vectors",
 865                 .type = QEMU_OPT_NUMBER,
 866                 .help = "number of MSI-x vectors, 0 to disable MSI-X",
 867             },
 868             { /* end of list */ }
 869         },
 870 #ifdef CONFIG_SLIRP
 871     }, {
 872         .type = "user",
 873         .init = net_init_slirp,
 874         .desc = {
 875             NET_COMMON_PARAMS_DESC,
 876             {
 877                 .name = "hostname",
 878                 .type = QEMU_OPT_STRING,
 879                 .help = "client hostname reported by the builtin DHCP server",
 880             }, {
 881                 .name = "restrict",
 882                 .type = QEMU_OPT_STRING,
 883                 .help = "isolate the guest from the host (y|yes|n|no)",
 884             }, {
 885                 .name = "ip",
 886                 .type = QEMU_OPT_STRING,
 887                 .help = "legacy parameter, use net= instead",
 888             }, {
 889                 .name = "net",
 890                 .type = QEMU_OPT_STRING,
 891                 .help = "IP address and optional netmask",
 892             }, {
 893                 .name = "host",
 894                 .type = QEMU_OPT_STRING,
 895                 .help = "guest-visible address of the host",
 896             }, {
 897                 .name = "tftp",
 898                 .type = QEMU_OPT_STRING,
 899                 .help = "root directory of the built-in TFTP server",
 900             }, {
 901                 .name = "bootfile",
 902                 .type = QEMU_OPT_STRING,
 903                 .help = "BOOTP filename, for use with tftp=",
 904             }, {
 905                 .name = "dhcpstart",
 906                 .type = QEMU_OPT_STRING,
 907                 .help = "the first of the 16 IPs the built-in DHCP server can assign",
 908             }, {
 909                 .name = "dns",
 910                 .type = QEMU_OPT_STRING,
 911                 .help = "guest-visible address of the virtual nameserver",
 912             }, {
 913                 .name = "smb",
 914                 .type = QEMU_OPT_STRING,
 915                 .help = "root directory of the built-in SMB server",
 916             }, {
 917                 .name = "smbserver",
 918                 .type = QEMU_OPT_STRING,
 919                 .help = "IP address of the built-in SMB server",
 920             }, {
 921                 .name = "hostfwd",
 922                 .type = QEMU_OPT_STRING,
 923                 .help = "guest port number to forward incoming TCP or UDP connections",
 924             }, {
 925                 .name = "guestfwd",
 926                 .type = QEMU_OPT_STRING,
 927                 .help = "IP address and port to forward guest TCP connections",
 928             },
 929             { /* end of list */ }
 930         },
 931 #endif
 932     }, {
 933         .type = "tap",
 934         .init = net_init_tap,
 935         .desc = {
 936             NET_COMMON_PARAMS_DESC,
 937             {
 938                 .name = "ifname",
 939                 .type = QEMU_OPT_STRING,
 940                 .help = "interface name",
 941             },
 942 #ifndef _WIN32
 943             {
 944                 .name = "fd",
 945                 .type = QEMU_OPT_STRING,
 946                 .help = "file descriptor of an already opened tap",
 947             }, {
 948                 .name = "script",
 949                 .type = QEMU_OPT_STRING,
 950                 .help = "script to initialize the interface",
 951             }, {
 952                 .name = "downscript",
 953                 .type = QEMU_OPT_STRING,
 954                 .help = "script to shut down the interface",
 955             }, {
 956                 .name = "sndbuf",
 957                 .type = QEMU_OPT_SIZE,
 958                 .help = "send buffer limit"
 959             }, {
 960                 .name = "vnet_hdr",
 961                 .type = QEMU_OPT_BOOL,
 962                 .help = "enable the IFF_VNET_HDR flag on the tap interface"
 963             }, {
 964                 .name = "vhost",
 965                 .type = QEMU_OPT_BOOL,
 966                 .help = "enable vhost-net network accelerator",
 967             }, {
 968                 .name = "vhostfd",
 969                 .type = QEMU_OPT_STRING,
 970                 .help = "file descriptor of an already opened vhost net device",
 971             }, {
 972                 .name = "vhostforce",
 973                 .type = QEMU_OPT_BOOL,
 974                 .help = "force vhost on for non-MSIX virtio guests",
 975         },
 976 #endif /* _WIN32 */
 977             { /* end of list */ }
 978         },
 979     }, {
 980         .type = "socket",
 981         .init = net_init_socket,
 982         .desc = {
 983             NET_COMMON_PARAMS_DESC,
 984             {
 985                 .name = "fd",
 986                 .type = QEMU_OPT_STRING,
 987                 .help = "file descriptor of an already opened socket",
 988             }, {
 989                 .name = "listen",
 990                 .type = QEMU_OPT_STRING,
 991                 .help = "port number, and optional hostname, to listen on",
 992             }, {
 993                 .name = "connect",
 994                 .type = QEMU_OPT_STRING,
 995                 .help = "port number, and optional hostname, to connect to",
 996             }, {
 997                 .name = "mcast",
 998                 .type = QEMU_OPT_STRING,
 999                 .help = "UDP multicast address and port number",
1000             }, {
1001                 .name = "localaddr",
1002                 .type = QEMU_OPT_STRING,
1003                 .help = "source address for multicast packets",
1004             },
1005             { /* end of list */ }
1006         },
1007 #ifdef CONFIG_VDE
1008     }, {
1009         .type = "vde",
1010         .init = net_init_vde,
1011         .desc = {
1012             NET_COMMON_PARAMS_DESC,
1013             {
1014                 .name = "sock",
1015                 .type = QEMU_OPT_STRING,
1016                 .help = "socket path",
1017             }, {
1018                 .name = "port",
1019                 .type = QEMU_OPT_NUMBER,
1020                 .help = "port number",
1021             }, {
1022                 .name = "group",
1023                 .type = QEMU_OPT_STRING,
1024                 .help = "group owner of socket",
1025             }, {
1026                 .name = "mode",
1027                 .type = QEMU_OPT_NUMBER,
1028                 .help = "permissions for socket",
1029             },
1030             { /* end of list */ }
1031         },
1032 #endif
1033     }, {
1034         .type = "dump",
1035         .init = net_init_dump,
1036         .desc = {
1037             NET_COMMON_PARAMS_DESC,
1038             {
1039                 .name = "len",
1040                 .type = QEMU_OPT_SIZE,
1041                 .help = "per-packet size limit (64k default)",
1042             }, {
1043                 .name = "file",
1044                 .type = QEMU_OPT_STRING,
1045                 .help = "dump file path (default is qemu-vlan0.pcap)",
1046             },
1047             { /* end of list */ }
1048         },
1049     },
1050     { /* end of list */ }
1051 };
1052
1053 int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
1054 {
1055     const char *name;
1056     const char *type;
1057     int i;
1058
1059     type = qemu_opt_get(opts, "type");
1060     if (!type) {
1061         qerror_report(QERR_MISSING_PARAMETER, "type");
1062         return -1;
1063     }
1064
1065     if (is_netdev) {
1066         if (strcmp(type, "tap") != 0 &&
1067 #ifdef CONFIG_SLIRP
1068             strcmp(type, "user") != 0 &&
1069 #endif
1070 #ifdef CONFIG_VDE
1071             strcmp(type, "vde") != 0 &&
1072 #endif
1073             strcmp(type, "socket") != 0) {
1074             qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1075                           "a netdev backend type");
1076             return -1;
1077         }
1078
1079         if (qemu_opt_get(opts, "vlan")) {
1080             qerror_report(QERR_INVALID_PARAMETER, "vlan");
1081             return -1;
1082         }
1083         if (qemu_opt_get(opts, "name")) {
1084             qerror_report(QERR_INVALID_PARAMETER, "name");
1085             return -1;
1086         }
1087         if (!qemu_opts_id(opts)) {
1088             qerror_report(QERR_MISSING_PARAMETER, "id");
1089             return -1;
1090         }
1091     }
1092
1093     name = qemu_opts_id(opts);
1094     if (!name) {
1095         name = qemu_opt_get(opts, "name");
1096     }
1097
1098     for (i = 0; net_client_types[i].type != NULL; i++) {
1099         if (!strcmp(net_client_types[i].type, type)) {
1100             VLANState *vlan = NULL;
1101             int ret;
1102
1103             if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
1104                 return -1;
1105             }
1106
1107             /* Do not add to a vlan if it's a -netdev or a nic with a
1108              * netdev= parameter. */
1109             if (!(is_netdev ||
1110                   (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1111                 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1112             }
1113
1114             ret = 0;
1115             if (net_client_types[i].init) {
1116                 ret = net_client_types[i].init(opts, mon, name, vlan);
1117                 if (ret < 0) {
1118                     /* TODO push error reporting into init() methods */
1119                     qerror_report(QERR_DEVICE_INIT_FAILED, type);
1120                     return -1;
1121                 }
1122             }
1123             return ret;
1124         }
1125     }
1126
1127     qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1128                   "a network client type");
1129     return -1;
1130 }
1131
1132 static int net_host_check_device(const char *device)
1133 {
1134     int i;
1135     const char *valid_param_list[] = { "tap", "socket", "dump"
1136 #ifdef CONFIG_SLIRP
1137                                        ,"user"
1138 #endif
1139 #ifdef CONFIG_VDE
1140                                        ,"vde"
1141 #endif
1142     };
1143     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1144         if (!strncmp(valid_param_list[i], device,
1145                      strlen(valid_param_list[i])))
1146             return 1;
1147     }
1148
1149     return 0;
1150 }
1151
1152 void net_host_device_add(Monitor *mon, const QDict *qdict)
1153 {
1154     const char *device = qdict_get_str(qdict, "device");
1155     const char *opts_str = qdict_get_try_str(qdict, "opts");
1156     QemuOpts *opts;
1157
1158     if (!net_host_check_device(device)) {
1159         monitor_printf(mon, "invalid host network device %s\n", device);
1160         return;
1161     }
1162
1163     opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
1164     if (!opts) {
1165         return;
1166     }
1167
1168     qemu_opt_set(opts, "type", device);
1169
1170     if (net_client_init(mon, opts, 0) < 0) {
1171         monitor_printf(mon, "adding host network device %s failed\n", device);
1172     }
1173 }
1174
1175 void net_host_device_remove(Monitor *mon, const QDict *qdict)
1176 {
1177     VLANClientState *vc;
1178     int vlan_id = qdict_get_int(qdict, "vlan_id");
1179     const char *device = qdict_get_str(qdict, "device");
1180
1181     vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1182     if (!vc) {
1183         return;
1184     }
1185     if (!net_host_check_device(vc->model)) {
1186         monitor_printf(mon, "invalid host network device %s\n", device);
1187         return;
1188     }
1189     qemu_del_vlan_client(vc);
1190 }
1191
1192 int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
1193 {
1194     QemuOpts *opts;
1195     int res;
1196
1197     opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict);
1198     if (!opts) {
1199         return -1;
1200     }
1201
1202     res = net_client_init(mon, opts, 1);
1203     if (res < 0) {
1204         qemu_opts_del(opts);
1205     }
1206
1207     return res;
1208 }
1209
1210 int do_netdev_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1211 {
1212     const char *id = qdict_get_str(qdict, "id");
1213     VLANClientState *vc;
1214
1215     vc = qemu_find_netdev(id);
1216     if (!vc || vc->info->type == NET_CLIENT_TYPE_NIC) {
1217         qerror_report(QERR_DEVICE_NOT_FOUND, id);
1218         return -1;
1219     }
1220     qemu_del_vlan_client(vc);
1221     qemu_opts_del(qemu_opts_find(qemu_find_opts("netdev"), id));
1222     return 0;
1223 }
1224
1225 void do_info_network(Monitor *mon)
1226 {
1227     VLANState *vlan;
1228     VLANClientState *vc;
1229
1230     QTAILQ_FOREACH(vlan, &vlans, next) {
1231         monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1232
1233         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1234             monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
1235         }
1236     }
1237     monitor_printf(mon, "Devices not on any VLAN:\n");
1238     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1239         monitor_printf(mon, "  %s: %s", vc->name, vc->info_str);
1240         if (vc->peer) {
1241             monitor_printf(mon, " peer=%s", vc->peer->name);
1242         }
1243         monitor_printf(mon, "\n");
1244     }
1245 }
1246
1247 int do_set_link(Monitor *mon, const QDict *qdict, QObject **ret_data)
1248 {
1249     VLANState *vlan;
1250     VLANClientState *vc = NULL;
1251     const char *name = qdict_get_str(qdict, "name");
1252     int up = qdict_get_bool(qdict, "up");
1253
1254     QTAILQ_FOREACH(vlan, &vlans, next) {
1255         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1256             if (strcmp(vc->name, name) == 0) {
1257                 goto done;
1258             }
1259         }
1260     }
1261     vc = qemu_find_netdev(name);
1262 done:
1263
1264     if (!vc) {
1265         qerror_report(QERR_DEVICE_NOT_FOUND, name);
1266         return -1;
1267     }
1268
1269     vc->link_down = !up;
1270
1271     if (vc->info->link_status_changed) {
1272         vc->info->link_status_changed(vc);
1273     }
1274
1275     /* Notify peer. Don't update peer link status: this makes it possible to
1276      * disconnect from host network without notifying the guest.
1277      * FIXME: is disconnected link status change operation useful?
1278      *
1279      * Current behaviour is compatible with qemu vlans where there could be
1280      * multiple clients that can still communicate with each other in
1281      * disconnected mode. For now maintain this compatibility. */
1282     if (vc->peer && vc->peer->info->link_status_changed) {
1283         vc->peer->info->link_status_changed(vc->peer);
1284     }
1285     return 0;
1286 }
1287
1288 void net_cleanup(void)
1289 {
1290     VLANState *vlan;
1291     VLANClientState *vc, *next_vc;
1292
1293     QTAILQ_FOREACH(vlan, &vlans, next) {
1294         QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1295             qemu_del_vlan_client(vc);
1296         }
1297     }
1298
1299     QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1300         qemu_del_vlan_client(vc);
1301     }
1302 }
1303
1304 void net_check_clients(void)
1305 {
1306     VLANState *vlan;
1307     VLANClientState *vc;
1308     int has_nic = 0, has_host_dev = 0;
1309
1310     QTAILQ_FOREACH(vlan, &vlans, next) {
1311         QTAILQ_FOREACH(vc, &vlan->clients, next) {
1312             switch (vc->info->type) {
1313             case NET_CLIENT_TYPE_NIC:
1314                 has_nic = 1;
1315                 break;
1316             case NET_CLIENT_TYPE_SLIRP:
1317             case NET_CLIENT_TYPE_TAP:
1318             case NET_CLIENT_TYPE_SOCKET:
1319             case NET_CLIENT_TYPE_VDE:
1320                 has_host_dev = 1;
1321                 break;
1322             default: ;
1323             }
1324         }
1325         if (has_host_dev && !has_nic)
1326             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1327         if (has_nic && !has_host_dev)
1328             fprintf(stderr,
1329                     "Warning: vlan %d is not connected to host network\n",
1330                     vlan->id);
1331     }
1332     QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1333         if (!vc->peer) {
1334             fprintf(stderr, "Warning: %s %s has no peer\n",
1335                     vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1336                     vc->name);
1337         }
1338     }
1339 }
1340
1341 static int net_init_client(QemuOpts *opts, void *dummy)
1342 {
1343     if (net_client_init(NULL, opts, 0) < 0)
1344         return -1;
1345     return 0;
1346 }
1347
1348 static int net_init_netdev(QemuOpts *opts, void *dummy)
1349 {
1350     return net_client_init(NULL, opts, 1);
1351 }
1352
1353 int net_init_clients(void)
1354 {
1355     QemuOptsList *net = qemu_find_opts("net");
1356
1357     if (default_net) {
1358         /* if no clients, we use a default config */
1359         qemu_opts_set(net, NULL, "type", "nic");
1360 #ifdef CONFIG_SLIRP
1361         qemu_opts_set(net, NULL, "type", "user");
1362 #endif
1363     }
1364
1365     QTAILQ_INIT(&vlans);
1366     QTAILQ_INIT(&non_vlan_clients);
1367
1368     if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1369         return -1;
1370
1371     if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1372         return -1;
1373     }
1374
1375     return 0;
1376 }
1377
1378 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1379 {
1380 #if defined(CONFIG_SLIRP)
1381     int ret;
1382     if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1383         return ret;
1384     }
1385 #endif
1386
1387     if (!qemu_opts_parse(opts_list, optarg, 1)) {
1388         return -1;
1389     }
1390
1391     default_net = 0;
1392     return 0;
1393 }