File:  [Qemu by Fabrice Bellard] / qemu / net.c
Revision 1.1.1.14 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:34:22 2018 UTC (23 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu1101, HEAD
qemu 1.1.1

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

unix.superglobalmegacorp.com