File:  [Qemu by Fabrice Bellard] / qemu / net.c
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:50:37 2018 UTC (3 years, 2 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu0101, qemu0100, HEAD
qemu 0.10.0

    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 "qemu-common.h"
   25: #include "net.h"
   26: #include "console.h"
   27: #include "sysemu.h"
   28: #include "qemu-timer.h"
   29: #include "qemu-char.h"
   30: #include "audio/audio.h"
   31: 
   32: #include <unistd.h>
   33: #include <fcntl.h>
   34: #include <signal.h>
   35: #include <time.h>
   36: #include <errno.h>
   37: #include <sys/time.h>
   38: #include <zlib.h>
   39: 
   40: #ifndef _WIN32
   41: #include <sys/times.h>
   42: #include <sys/wait.h>
   43: #include <termios.h>
   44: #include <sys/mman.h>
   45: #include <sys/ioctl.h>
   46: #include <sys/resource.h>
   47: #include <sys/socket.h>
   48: #include <netinet/in.h>
   49: #include <net/if.h>
   50: #ifdef __NetBSD__
   51: #include <net/if_tap.h>
   52: #endif
   53: #ifdef __linux__
   54: #include <linux/if_tun.h>
   55: #endif
   56: #include <arpa/inet.h>
   57: #include <dirent.h>
   58: #include <netdb.h>
   59: #include <sys/select.h>
   60: #ifdef _BSD
   61: #include <sys/stat.h>
   62: #ifdef __FreeBSD__
   63: #include <libutil.h>
   64: #else
   65: #include <util.h>
   66: #endif
   67: #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
   68: #include <freebsd/stdlib.h>
   69: #else
   70: #ifdef __linux__
   71: #include <pty.h>
   72: #include <malloc.h>
   73: #include <linux/rtc.h>
   74: 
   75: /* For the benefit of older linux systems which don't supply it,
   76:    we use a local copy of hpet.h. */
   77: /* #include <linux/hpet.h> */
   78: #include "hpet.h"
   79: 
   80: #include <linux/ppdev.h>
   81: #include <linux/parport.h>
   82: #endif
   83: #ifdef __sun__
   84: #include <sys/stat.h>
   85: #include <sys/ethernet.h>
   86: #include <sys/sockio.h>
   87: #include <netinet/arp.h>
   88: #include <netinet/in.h>
   89: #include <netinet/in_systm.h>
   90: #include <netinet/ip.h>
   91: #include <netinet/ip_icmp.h> // must come after ip.h
   92: #include <netinet/udp.h>
   93: #include <netinet/tcp.h>
   94: #include <net/if.h>
   95: #include <syslog.h>
   96: #include <stropts.h>
   97: #endif
   98: #endif
   99: #endif
  100: 
  101: #include "qemu_socket.h"
  102: 
  103: #if defined(CONFIG_SLIRP)
  104: #include "libslirp.h"
  105: #endif
  106: 
  107: #if defined(__OpenBSD__)
  108: #include <util.h>
  109: #endif
  110: 
  111: #if defined(CONFIG_VDE)
  112: #include <libvdeplug.h>
  113: #endif
  114: 
  115: #ifdef _WIN32
  116: #include <malloc.h>
  117: #include <sys/timeb.h>
  118: #include <mmsystem.h>
  119: #define getopt_long_only getopt_long
  120: #define memalign(align, size) malloc(size)
  121: #endif
  122: 
  123: static VLANState *first_vlan;
  124: 
  125: /***********************************************************/
  126: /* network device redirectors */
  127: 
  128: #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
  129: static void hex_dump(FILE *f, const uint8_t *buf, int size)
  130: {
  131:     int len, i, j, c;
  132: 
  133:     for(i=0;i<size;i+=16) {
  134:         len = size - i;
  135:         if (len > 16)
  136:             len = 16;
  137:         fprintf(f, "%08x ", i);
  138:         for(j=0;j<16;j++) {
  139:             if (j < len)
  140:                 fprintf(f, " %02x", buf[i+j]);
  141:             else
  142:                 fprintf(f, "   ");
  143:         }
  144:         fprintf(f, " ");
  145:         for(j=0;j<len;j++) {
  146:             c = buf[i+j];
  147:             if (c < ' ' || c > '~')
  148:                 c = '.';
  149:             fprintf(f, "%c", c);
  150:         }
  151:         fprintf(f, "\n");
  152:     }
  153: }
  154: #endif
  155: 
  156: static int parse_macaddr(uint8_t *macaddr, const char *p)
  157: {
  158:     int i;
  159:     char *last_char;
  160:     long int offset;
  161: 
  162:     errno = 0;
  163:     offset = strtol(p, &last_char, 0);    
  164:     if (0 == errno && '\0' == *last_char &&
  165:             offset >= 0 && offset <= 0xFFFFFF) {
  166:         macaddr[3] = (offset & 0xFF0000) >> 16;
  167:         macaddr[4] = (offset & 0xFF00) >> 8;
  168:         macaddr[5] = offset & 0xFF;
  169:         return 0;
  170:     } else {
  171:         for(i = 0; i < 6; i++) {
  172:             macaddr[i] = strtol(p, (char **)&p, 16);
  173:             if (i == 5) {
  174:                 if (*p != '\0')
  175:                     return -1;
  176:             } else {
  177:                 if (*p != ':' && *p != '-')
  178:                     return -1;
  179:                 p++;
  180:             }
  181:         }
  182:         return 0;    
  183:     }
  184: 
  185:     return -1;
  186: }
  187: 
  188: static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
  189: {
  190:     const char *p, *p1;
  191:     int len;
  192:     p = *pp;
  193:     p1 = strchr(p, sep);
  194:     if (!p1)
  195:         return -1;
  196:     len = p1 - p;
  197:     p1++;
  198:     if (buf_size > 0) {
  199:         if (len > buf_size - 1)
  200:             len = buf_size - 1;
  201:         memcpy(buf, p, len);
  202:         buf[len] = '\0';
  203:     }
  204:     *pp = p1;
  205:     return 0;
  206: }
  207: 
  208: int parse_host_src_port(struct sockaddr_in *haddr,
  209:                         struct sockaddr_in *saddr,
  210:                         const char *input_str)
  211: {
  212:     char *str = strdup(input_str);
  213:     char *host_str = str;
  214:     char *src_str;
  215:     const char *src_str2;
  216:     char *ptr;
  217: 
  218:     /*
  219:      * Chop off any extra arguments at the end of the string which
  220:      * would start with a comma, then fill in the src port information
  221:      * if it was provided else use the "any address" and "any port".
  222:      */
  223:     if ((ptr = strchr(str,',')))
  224:         *ptr = '\0';
  225: 
  226:     if ((src_str = strchr(input_str,'@'))) {
  227:         *src_str = '\0';
  228:         src_str++;
  229:     }
  230: 
  231:     if (parse_host_port(haddr, host_str) < 0)
  232:         goto fail;
  233: 
  234:     src_str2 = src_str;
  235:     if (!src_str || *src_str == '\0')
  236:         src_str2 = ":0";
  237: 
  238:     if (parse_host_port(saddr, src_str2) < 0)
  239:         goto fail;
  240: 
  241:     free(str);
  242:     return(0);
  243: 
  244: fail:
  245:     free(str);
  246:     return -1;
  247: }
  248: 
  249: int parse_host_port(struct sockaddr_in *saddr, const char *str)
  250: {
  251:     char buf[512];
  252:     struct hostent *he;
  253:     const char *p, *r;
  254:     int port;
  255: 
  256:     p = str;
  257:     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
  258:         return -1;
  259:     saddr->sin_family = AF_INET;
  260:     if (buf[0] == '\0') {
  261:         saddr->sin_addr.s_addr = 0;
  262:     } else {
  263:         if (qemu_isdigit(buf[0])) {
  264:             if (!inet_aton(buf, &saddr->sin_addr))
  265:                 return -1;
  266:         } else {
  267:             if ((he = gethostbyname(buf)) == NULL)
  268:                 return - 1;
  269:             saddr->sin_addr = *(struct in_addr *)he->h_addr;
  270:         }
  271:     }
  272:     port = strtol(p, (char **)&r, 0);
  273:     if (r == p)
  274:         return -1;
  275:     saddr->sin_port = htons(port);
  276:     return 0;
  277: }
  278: 
  279: #if !defined(_WIN32) && 0
  280: static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
  281: {
  282:     const char *p;
  283:     int len;
  284: 
  285:     len = MIN(108, strlen(str));
  286:     p = strchr(str, ',');
  287:     if (p)
  288: 	len = MIN(len, p - str);
  289: 
  290:     memset(uaddr, 0, sizeof(*uaddr));
  291: 
  292:     uaddr->sun_family = AF_UNIX;
  293:     memcpy(uaddr->sun_path, str, len);
  294: 
  295:     return 0;
  296: }
  297: #endif
  298: 
  299: void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
  300: {
  301:     snprintf(vc->info_str, sizeof(vc->info_str),
  302:              "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
  303:              vc->model,
  304:              macaddr[0], macaddr[1], macaddr[2],
  305:              macaddr[3], macaddr[4], macaddr[5]);
  306: }
  307: 
  308: static char *assign_name(VLANClientState *vc1, const char *model)
  309: {
  310:     VLANState *vlan;
  311:     char buf[256];
  312:     int id = 0;
  313: 
  314:     for (vlan = first_vlan; vlan; vlan = vlan->next) {
  315:         VLANClientState *vc;
  316: 
  317:         for (vc = vlan->first_client; vc; vc = vc->next)
  318:             if (vc != vc1 && strcmp(vc->model, model) == 0)
  319:                 id++;
  320:     }
  321: 
  322:     snprintf(buf, sizeof(buf), "%s.%d", model, id);
  323: 
  324:     return strdup(buf);
  325: }
  326: 
  327: VLANClientState *qemu_new_vlan_client(VLANState *vlan,
  328:                                       const char *model,
  329:                                       const char *name,
  330:                                       IOReadHandler *fd_read,
  331:                                       IOCanRWHandler *fd_can_read,
  332:                                       void *opaque)
  333: {
  334:     VLANClientState *vc, **pvc;
  335:     vc = qemu_mallocz(sizeof(VLANClientState));
  336:     vc->model = strdup(model);
  337:     if (name)
  338:         vc->name = strdup(name);
  339:     else
  340:         vc->name = assign_name(vc, model);
  341:     vc->fd_read = fd_read;
  342:     vc->fd_can_read = fd_can_read;
  343:     vc->opaque = opaque;
  344:     vc->vlan = vlan;
  345: 
  346:     vc->next = NULL;
  347:     pvc = &vlan->first_client;
  348:     while (*pvc != NULL)
  349:         pvc = &(*pvc)->next;
  350:     *pvc = vc;
  351:     return vc;
  352: }
  353: 
  354: void qemu_del_vlan_client(VLANClientState *vc)
  355: {
  356:     VLANClientState **pvc = &vc->vlan->first_client;
  357: 
  358:     while (*pvc != NULL)
  359:         if (*pvc == vc) {
  360:             *pvc = vc->next;
  361:             free(vc->name);
  362:             free(vc->model);
  363:             free(vc);
  364:             break;
  365:         } else
  366:             pvc = &(*pvc)->next;
  367: }
  368: 
  369: VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
  370: {
  371:     VLANClientState **pvc = &vlan->first_client;
  372: 
  373:     while (*pvc != NULL)
  374:         if ((*pvc)->opaque == opaque)
  375:             return *pvc;
  376:         else
  377:             pvc = &(*pvc)->next;
  378: 
  379:     return NULL;
  380: }
  381: 
  382: int qemu_can_send_packet(VLANClientState *vc1)
  383: {
  384:     VLANState *vlan = vc1->vlan;
  385:     VLANClientState *vc;
  386: 
  387:     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
  388:         if (vc != vc1) {
  389:             if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
  390:                 return 1;
  391:         }
  392:     }
  393:     return 0;
  394: }
  395: 
  396: void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
  397: {
  398:     VLANState *vlan = vc1->vlan;
  399:     VLANClientState *vc;
  400: 
  401:     if (vc1->link_down)
  402:         return;
  403: 
  404: #ifdef DEBUG_NET
  405:     printf("vlan %d send:\n", vlan->id);
  406:     hex_dump(stdout, buf, size);
  407: #endif
  408:     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
  409:         if (vc != vc1 && !vc->link_down) {
  410:             vc->fd_read(vc->opaque, buf, size);
  411:         }
  412:     }
  413: }
  414: 
  415: static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
  416:                                int iovcnt)
  417: {
  418:     uint8_t buffer[4096];
  419:     size_t offset = 0;
  420:     int i;
  421: 
  422:     for (i = 0; i < iovcnt; i++) {
  423:         size_t len;
  424: 
  425:         len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
  426:         memcpy(buffer + offset, iov[i].iov_base, len);
  427:         offset += len;
  428:     }
  429: 
  430:     vc->fd_read(vc->opaque, buffer, offset);
  431: 
  432:     return offset;
  433: }
  434: 
  435: static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
  436: {
  437:     size_t offset = 0;
  438:     int i;
  439: 
  440:     for (i = 0; i < iovcnt; i++)
  441:         offset += iov[i].iov_len;
  442:     return offset;
  443: }
  444: 
  445: ssize_t qemu_sendv_packet(VLANClientState *vc1, const struct iovec *iov,
  446:                           int iovcnt)
  447: {
  448:     VLANState *vlan = vc1->vlan;
  449:     VLANClientState *vc;
  450:     ssize_t max_len = 0;
  451: 
  452:     if (vc1->link_down)
  453:         return calc_iov_length(iov, iovcnt);
  454: 
  455:     for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
  456:         ssize_t len = 0;
  457: 
  458:         if (vc == vc1)
  459:             continue;
  460: 
  461:         if (vc->link_down)
  462:             len = calc_iov_length(iov, iovcnt);
  463:         if (vc->fd_readv)
  464:             len = vc->fd_readv(vc->opaque, iov, iovcnt);
  465:         else if (vc->fd_read)
  466:             len = vc_sendv_compat(vc, iov, iovcnt);
  467: 
  468:         max_len = MAX(max_len, len);
  469:     }
  470: 
  471:     return max_len;
  472: }
  473: 
  474: #if defined(CONFIG_SLIRP)
  475: 
  476: /* slirp network adapter */
  477: 
  478: static int slirp_inited;
  479: static int slirp_restrict;
  480: static char *slirp_ip;
  481: static VLANClientState *slirp_vc;
  482: 
  483: int slirp_can_output(void)
  484: {
  485:     return !slirp_vc || qemu_can_send_packet(slirp_vc);
  486: }
  487: 
  488: void slirp_output(const uint8_t *pkt, int pkt_len)
  489: {
  490: #ifdef DEBUG_SLIRP
  491:     printf("slirp output:\n");
  492:     hex_dump(stdout, pkt, pkt_len);
  493: #endif
  494:     if (!slirp_vc)
  495:         return;
  496:     qemu_send_packet(slirp_vc, pkt, pkt_len);
  497: }
  498: 
  499: int slirp_is_inited(void)
  500: {
  501:     return slirp_inited;
  502: }
  503: 
  504: static void slirp_receive(void *opaque, const uint8_t *buf, int size)
  505: {
  506: #ifdef DEBUG_SLIRP
  507:     printf("slirp input:\n");
  508:     hex_dump(stdout, buf, size);
  509: #endif
  510:     slirp_input(buf, size);
  511: }
  512: 
  513: static int net_slirp_init(VLANState *vlan, const char *model, const char *name)
  514: {
  515:     if (!slirp_inited) {
  516:         slirp_inited = 1;
  517:         slirp_init(slirp_restrict, slirp_ip);
  518:     }
  519:     slirp_vc = qemu_new_vlan_client(vlan, model, name,
  520:                                     slirp_receive, NULL, NULL);
  521:     slirp_vc->info_str[0] = '\0';
  522:     return 0;
  523: }
  524: 
  525: void net_slirp_redir(const char *redir_str)
  526: {
  527:     int is_udp;
  528:     char buf[256], *r;
  529:     const char *p;
  530:     struct in_addr guest_addr;
  531:     int host_port, guest_port;
  532: 
  533:     if (!slirp_inited) {
  534:         slirp_inited = 1;
  535:         slirp_init(slirp_restrict, slirp_ip);
  536:     }
  537: 
  538:     p = redir_str;
  539:     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
  540:         goto fail;
  541:     if (!strcmp(buf, "tcp")) {
  542:         is_udp = 0;
  543:     } else if (!strcmp(buf, "udp")) {
  544:         is_udp = 1;
  545:     } else {
  546:         goto fail;
  547:     }
  548: 
  549:     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
  550:         goto fail;
  551:     host_port = strtol(buf, &r, 0);
  552:     if (r == buf)
  553:         goto fail;
  554: 
  555:     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
  556:         goto fail;
  557:     if (buf[0] == '\0') {
  558:         pstrcpy(buf, sizeof(buf), "10.0.2.15");
  559:     }
  560:     if (!inet_aton(buf, &guest_addr))
  561:         goto fail;
  562: 
  563:     guest_port = strtol(p, &r, 0);
  564:     if (r == p)
  565:         goto fail;
  566: 
  567:     if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
  568:         fprintf(stderr, "qemu: could not set up redirection\n");
  569:         exit(1);
  570:     }
  571:     return;
  572:  fail:
  573:     fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
  574:     exit(1);
  575: }
  576: 
  577: #ifndef _WIN32
  578: 
  579: static char smb_dir[1024];
  580: 
  581: static void erase_dir(char *dir_name)
  582: {
  583:     DIR *d;
  584:     struct dirent *de;
  585:     char filename[1024];
  586: 
  587:     /* erase all the files in the directory */
  588:     if ((d = opendir(dir_name)) != 0) {
  589:         for(;;) {
  590:             de = readdir(d);
  591:             if (!de)
  592:                 break;
  593:             if (strcmp(de->d_name, ".") != 0 &&
  594:                 strcmp(de->d_name, "..") != 0) {
  595:                 snprintf(filename, sizeof(filename), "%s/%s",
  596:                          smb_dir, de->d_name);
  597:                 if (unlink(filename) != 0)  /* is it a directory? */
  598:                     erase_dir(filename);
  599:             }
  600:         }
  601:         closedir(d);
  602:         rmdir(dir_name);
  603:     }
  604: }
  605: 
  606: /* automatic user mode samba server configuration */
  607: static void smb_exit(void)
  608: {
  609:     erase_dir(smb_dir);
  610: }
  611: 
  612: /* automatic user mode samba server configuration */
  613: void net_slirp_smb(const char *exported_dir)
  614: {
  615:     char smb_conf[1024];
  616:     char smb_cmdline[1024];
  617:     FILE *f;
  618: 
  619:     if (!slirp_inited) {
  620:         slirp_inited = 1;
  621:         slirp_init(slirp_restrict, slirp_ip);
  622:     }
  623: 
  624:     /* XXX: better tmp dir construction */
  625:     snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
  626:     if (mkdir(smb_dir, 0700) < 0) {
  627:         fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
  628:         exit(1);
  629:     }
  630:     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
  631: 
  632:     f = fopen(smb_conf, "w");
  633:     if (!f) {
  634:         fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
  635:         exit(1);
  636:     }
  637:     fprintf(f,
  638:             "[global]\n"
  639:             "private dir=%s\n"
  640:             "smb ports=0\n"
  641:             "socket address=127.0.0.1\n"
  642:             "pid directory=%s\n"
  643:             "lock directory=%s\n"
  644:             "log file=%s/log.smbd\n"
  645:             "smb passwd file=%s/smbpasswd\n"
  646:             "security = share\n"
  647:             "[qemu]\n"
  648:             "path=%s\n"
  649:             "read only=no\n"
  650:             "guest ok=yes\n",
  651:             smb_dir,
  652:             smb_dir,
  653:             smb_dir,
  654:             smb_dir,
  655:             smb_dir,
  656:             exported_dir
  657:             );
  658:     fclose(f);
  659:     atexit(smb_exit);
  660: 
  661:     snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
  662:              SMBD_COMMAND, smb_conf);
  663: 
  664:     slirp_add_exec(0, smb_cmdline, 4, 139);
  665: }
  666: 
  667: #endif /* !defined(_WIN32) */
  668: void do_info_slirp(void)
  669: {
  670:     slirp_stats();
  671: }
  672: 
  673: struct VMChannel {
  674:     CharDriverState *hd;
  675:     int port;
  676: } *vmchannels;
  677: 
  678: static int vmchannel_can_read(void *opaque)
  679: {
  680:     struct VMChannel *vmc = (struct VMChannel*)opaque;
  681:     return slirp_socket_can_recv(4, vmc->port);
  682: }
  683: 
  684: static void vmchannel_read(void *opaque, const uint8_t *buf, int size)
  685: {
  686:     struct VMChannel *vmc = (struct VMChannel*)opaque;
  687:     slirp_socket_recv(4, vmc->port, buf, size);
  688: }
  689: 
  690: #endif /* CONFIG_SLIRP */
  691: 
  692: #if !defined(_WIN32)
  693: 
  694: typedef struct TAPState {
  695:     VLANClientState *vc;
  696:     int fd;
  697:     char down_script[1024];
  698:     char down_script_arg[128];
  699: } TAPState;
  700: 
  701: #ifdef HAVE_IOVEC
  702: static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov,
  703:                                int iovcnt)
  704: {
  705:     TAPState *s = opaque;
  706:     ssize_t len;
  707: 
  708:     do {
  709:         len = writev(s->fd, iov, iovcnt);
  710:     } while (len == -1 && (errno == EINTR || errno == EAGAIN));
  711: 
  712:     return len;
  713: }
  714: #endif
  715: 
  716: static void tap_receive(void *opaque, const uint8_t *buf, int size)
  717: {
  718:     TAPState *s = opaque;
  719:     int ret;
  720:     for(;;) {
  721:         ret = write(s->fd, buf, size);
  722:         if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
  723:         } else {
  724:             break;
  725:         }
  726:     }
  727: }
  728: 
  729: static void tap_send(void *opaque)
  730: {
  731:     TAPState *s = opaque;
  732:     uint8_t buf[4096];
  733:     int size;
  734: 
  735: #ifdef __sun__
  736:     struct strbuf sbuf;
  737:     int f = 0;
  738:     sbuf.maxlen = sizeof(buf);
  739:     sbuf.buf = buf;
  740:     size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
  741: #else
  742:     size = read(s->fd, buf, sizeof(buf));
  743: #endif
  744:     if (size > 0) {
  745:         qemu_send_packet(s->vc, buf, size);
  746:     }
  747: }
  748: 
  749: /* fd support */
  750: 
  751: static TAPState *net_tap_fd_init(VLANState *vlan,
  752:                                  const char *model,
  753:                                  const char *name,
  754:                                  int fd)
  755: {
  756:     TAPState *s;
  757: 
  758:     s = qemu_mallocz(sizeof(TAPState));
  759:     s->fd = fd;
  760:     s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive, NULL, s);
  761: #ifdef HAVE_IOVEC
  762:     s->vc->fd_readv = tap_receive_iov;
  763: #endif
  764:     qemu_set_fd_handler(s->fd, tap_send, NULL, s);
  765:     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
  766:     return s;
  767: }
  768: 
  769: #if defined (_BSD) || defined (__FreeBSD_kernel__)
  770: static int tap_open(char *ifname, int ifname_size)
  771: {
  772:     int fd;
  773:     char *dev;
  774:     struct stat s;
  775: 
  776:     TFR(fd = open("/dev/tap", O_RDWR));
  777:     if (fd < 0) {
  778:         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
  779:         return -1;
  780:     }
  781: 
  782:     fstat(fd, &s);
  783:     dev = devname(s.st_rdev, S_IFCHR);
  784:     pstrcpy(ifname, ifname_size, dev);
  785: 
  786:     fcntl(fd, F_SETFL, O_NONBLOCK);
  787:     return fd;
  788: }
  789: #elif defined(__sun__)
  790: #define TUNNEWPPA       (('T'<<16) | 0x0001)
  791: /*
  792:  * Allocate TAP device, returns opened fd.
  793:  * Stores dev name in the first arg(must be large enough).
  794:  */
  795: int tap_alloc(char *dev, size_t dev_size)
  796: {
  797:     int tap_fd, if_fd, ppa = -1;
  798:     static int ip_fd = 0;
  799:     char *ptr;
  800: 
  801:     static int arp_fd = 0;
  802:     int ip_muxid, arp_muxid;
  803:     struct strioctl  strioc_if, strioc_ppa;
  804:     int link_type = I_PLINK;;
  805:     struct lifreq ifr;
  806:     char actual_name[32] = "";
  807: 
  808:     memset(&ifr, 0x0, sizeof(ifr));
  809: 
  810:     if( *dev ){
  811:        ptr = dev;
  812:        while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
  813:        ppa = atoi(ptr);
  814:     }
  815: 
  816:     /* Check if IP device was opened */
  817:     if( ip_fd )
  818:        close(ip_fd);
  819: 
  820:     TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
  821:     if (ip_fd < 0) {
  822:        syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
  823:        return -1;
  824:     }
  825: 
  826:     TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
  827:     if (tap_fd < 0) {
  828:        syslog(LOG_ERR, "Can't open /dev/tap");
  829:        return -1;
  830:     }
  831: 
  832:     /* Assign a new PPA and get its unit number. */
  833:     strioc_ppa.ic_cmd = TUNNEWPPA;
  834:     strioc_ppa.ic_timout = 0;
  835:     strioc_ppa.ic_len = sizeof(ppa);
  836:     strioc_ppa.ic_dp = (char *)&ppa;
  837:     if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
  838:        syslog (LOG_ERR, "Can't assign new interface");
  839: 
  840:     TFR(if_fd = open("/dev/tap", O_RDWR, 0));
  841:     if (if_fd < 0) {
  842:        syslog(LOG_ERR, "Can't open /dev/tap (2)");
  843:        return -1;
  844:     }
  845:     if(ioctl(if_fd, I_PUSH, "ip") < 0){
  846:        syslog(LOG_ERR, "Can't push IP module");
  847:        return -1;
  848:     }
  849: 
  850:     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
  851: 	syslog(LOG_ERR, "Can't get flags\n");
  852: 
  853:     snprintf (actual_name, 32, "tap%d", ppa);
  854:     pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
  855: 
  856:     ifr.lifr_ppa = ppa;
  857:     /* Assign ppa according to the unit number returned by tun device */
  858: 
  859:     if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
  860:         syslog (LOG_ERR, "Can't set PPA %d", ppa);
  861:     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
  862:         syslog (LOG_ERR, "Can't get flags\n");
  863:     /* Push arp module to if_fd */
  864:     if (ioctl (if_fd, I_PUSH, "arp") < 0)
  865:         syslog (LOG_ERR, "Can't push ARP module (2)");
  866: 
  867:     /* Push arp module to ip_fd */
  868:     if (ioctl (ip_fd, I_POP, NULL) < 0)
  869:         syslog (LOG_ERR, "I_POP failed\n");
  870:     if (ioctl (ip_fd, I_PUSH, "arp") < 0)
  871:         syslog (LOG_ERR, "Can't push ARP module (3)\n");
  872:     /* Open arp_fd */
  873:     TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
  874:     if (arp_fd < 0)
  875:        syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
  876: 
  877:     /* Set ifname to arp */
  878:     strioc_if.ic_cmd = SIOCSLIFNAME;
  879:     strioc_if.ic_timout = 0;
  880:     strioc_if.ic_len = sizeof(ifr);
  881:     strioc_if.ic_dp = (char *)&ifr;
  882:     if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
  883:         syslog (LOG_ERR, "Can't set ifname to arp\n");
  884:     }
  885: 
  886:     if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
  887:        syslog(LOG_ERR, "Can't link TAP device to IP");
  888:        return -1;
  889:     }
  890: 
  891:     if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
  892:         syslog (LOG_ERR, "Can't link TAP device to ARP");
  893: 
  894:     close (if_fd);
  895: 
  896:     memset(&ifr, 0x0, sizeof(ifr));
  897:     pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
  898:     ifr.lifr_ip_muxid  = ip_muxid;
  899:     ifr.lifr_arp_muxid = arp_muxid;
  900: 
  901:     if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
  902:     {
  903:       ioctl (ip_fd, I_PUNLINK , arp_muxid);
  904:       ioctl (ip_fd, I_PUNLINK, ip_muxid);
  905:       syslog (LOG_ERR, "Can't set multiplexor id");
  906:     }
  907: 
  908:     snprintf(dev, dev_size, "tap%d", ppa);
  909:     return tap_fd;
  910: }
  911: 
  912: static int tap_open(char *ifname, int ifname_size)
  913: {
  914:     char  dev[10]="";
  915:     int fd;
  916:     if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
  917:        fprintf(stderr, "Cannot allocate TAP device\n");
  918:        return -1;
  919:     }
  920:     pstrcpy(ifname, ifname_size, dev);
  921:     fcntl(fd, F_SETFL, O_NONBLOCK);
  922:     return fd;
  923: }
  924: #elif defined (_AIX)
  925: static int tap_open(char *ifname, int ifname_size)
  926: {
  927:     fprintf (stderr, "no tap on AIX\n");
  928:     return -1;
  929: }
  930: #else
  931: static int tap_open(char *ifname, int ifname_size)
  932: {
  933:     struct ifreq ifr;
  934:     int fd, ret;
  935: 
  936:     TFR(fd = open("/dev/net/tun", O_RDWR));
  937:     if (fd < 0) {
  938:         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
  939:         return -1;
  940:     }
  941:     memset(&ifr, 0, sizeof(ifr));
  942:     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
  943:     if (ifname[0] != '\0')
  944:         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
  945:     else
  946:         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
  947:     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
  948:     if (ret != 0) {
  949:         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
  950:         close(fd);
  951:         return -1;
  952:     }
  953:     pstrcpy(ifname, ifname_size, ifr.ifr_name);
  954:     fcntl(fd, F_SETFL, O_NONBLOCK);
  955:     return fd;
  956: }
  957: #endif
  958: 
  959: static int launch_script(const char *setup_script, const char *ifname, int fd)
  960: {
  961:     int pid, status;
  962:     char *args[3];
  963:     char **parg;
  964: 
  965:         /* try to launch network script */
  966:         pid = fork();
  967:         if (pid >= 0) {
  968:             if (pid == 0) {
  969:                 int open_max = sysconf (_SC_OPEN_MAX), i;
  970:                 for (i = 0; i < open_max; i++)
  971:                     if (i != STDIN_FILENO &&
  972:                         i != STDOUT_FILENO &&
  973:                         i != STDERR_FILENO &&
  974:                         i != fd)
  975:                         close(i);
  976: 
  977:                 parg = args;
  978:                 *parg++ = (char *)setup_script;
  979:                 *parg++ = (char *)ifname;
  980:                 *parg++ = NULL;
  981:                 execv(setup_script, args);
  982:                 _exit(1);
  983:             }
  984:             while (waitpid(pid, &status, 0) != pid);
  985:             if (!WIFEXITED(status) ||
  986:                 WEXITSTATUS(status) != 0) {
  987:                 fprintf(stderr, "%s: could not launch network script\n",
  988:                         setup_script);
  989:                 return -1;
  990:             }
  991:         }
  992:     return 0;
  993: }
  994: 
  995: static int net_tap_init(VLANState *vlan, const char *model,
  996:                         const char *name, const char *ifname1,
  997:                         const char *setup_script, const char *down_script)
  998: {
  999:     TAPState *s;
 1000:     int fd;
 1001:     char ifname[128];
 1002: 
 1003:     if (ifname1 != NULL)
 1004:         pstrcpy(ifname, sizeof(ifname), ifname1);
 1005:     else
 1006:         ifname[0] = '\0';
 1007:     TFR(fd = tap_open(ifname, sizeof(ifname)));
 1008:     if (fd < 0)
 1009:         return -1;
 1010: 
 1011:     if (!setup_script || !strcmp(setup_script, "no"))
 1012:         setup_script = "";
 1013:     if (setup_script[0] != '\0') {
 1014: 	if (launch_script(setup_script, ifname, fd))
 1015: 	    return -1;
 1016:     }
 1017:     s = net_tap_fd_init(vlan, model, name, fd);
 1018:     if (!s)
 1019:         return -1;
 1020:     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 1021:              "ifname=%s,script=%s,downscript=%s",
 1022:              ifname, setup_script, down_script);
 1023:     if (down_script && strcmp(down_script, "no")) {
 1024:         snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
 1025:         snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
 1026:     }
 1027:     return 0;
 1028: }
 1029: 
 1030: #endif /* !_WIN32 */
 1031: 
 1032: #if defined(CONFIG_VDE)
 1033: typedef struct VDEState {
 1034:     VLANClientState *vc;
 1035:     VDECONN *vde;
 1036: } VDEState;
 1037: 
 1038: static void vde_to_qemu(void *opaque)
 1039: {
 1040:     VDEState *s = opaque;
 1041:     uint8_t buf[4096];
 1042:     int size;
 1043: 
 1044:     size = vde_recv(s->vde, buf, sizeof(buf), 0);
 1045:     if (size > 0) {
 1046:         qemu_send_packet(s->vc, buf, size);
 1047:     }
 1048: }
 1049: 
 1050: static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
 1051: {
 1052:     VDEState *s = opaque;
 1053:     int ret;
 1054:     for(;;) {
 1055:         ret = vde_send(s->vde, buf, size, 0);
 1056:         if (ret < 0 && errno == EINTR) {
 1057:         } else {
 1058:             break;
 1059:         }
 1060:     }
 1061: }
 1062: 
 1063: static int net_vde_init(VLANState *vlan, const char *model,
 1064:                         const char *name, const char *sock,
 1065:                         int port, const char *group, int mode)
 1066: {
 1067:     VDEState *s;
 1068:     char *init_group = strlen(group) ? (char *)group : NULL;
 1069:     char *init_sock = strlen(sock) ? (char *)sock : NULL;
 1070: 
 1071:     struct vde_open_args args = {
 1072:         .port = port,
 1073:         .group = init_group,
 1074:         .mode = mode,
 1075:     };
 1076: 
 1077:     s = qemu_mallocz(sizeof(VDEState));
 1078:     s->vde = vde_open(init_sock, "QEMU", &args);
 1079:     if (!s->vde){
 1080:         free(s);
 1081:         return -1;
 1082:     }
 1083:     s->vc = qemu_new_vlan_client(vlan, model, name, vde_from_qemu, NULL, s);
 1084:     qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
 1085:     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
 1086:              sock, vde_datafd(s->vde));
 1087:     return 0;
 1088: }
 1089: #endif
 1090: 
 1091: /* network connection */
 1092: typedef struct NetSocketState {
 1093:     VLANClientState *vc;
 1094:     int fd;
 1095:     int state; /* 0 = getting length, 1 = getting data */
 1096:     unsigned int index;
 1097:     unsigned int packet_len;
 1098:     uint8_t buf[4096];
 1099:     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
 1100: } NetSocketState;
 1101: 
 1102: typedef struct NetSocketListenState {
 1103:     VLANState *vlan;
 1104:     char *model;
 1105:     char *name;
 1106:     int fd;
 1107: } NetSocketListenState;
 1108: 
 1109: /* XXX: we consider we can send the whole packet without blocking */
 1110: static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
 1111: {
 1112:     NetSocketState *s = opaque;
 1113:     uint32_t len;
 1114:     len = htonl(size);
 1115: 
 1116:     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
 1117:     send_all(s->fd, buf, size);
 1118: }
 1119: 
 1120: static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
 1121: {
 1122:     NetSocketState *s = opaque;
 1123:     sendto(s->fd, buf, size, 0,
 1124:            (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
 1125: }
 1126: 
 1127: static void net_socket_send(void *opaque)
 1128: {
 1129:     NetSocketState *s = opaque;
 1130:     int size, err;
 1131:     unsigned l;
 1132:     uint8_t buf1[4096];
 1133:     const uint8_t *buf;
 1134: 
 1135:     size = recv(s->fd, buf1, sizeof(buf1), 0);
 1136:     if (size < 0) {
 1137:         err = socket_error();
 1138:         if (err != EWOULDBLOCK)
 1139:             goto eoc;
 1140:     } else if (size == 0) {
 1141:         /* end of connection */
 1142:     eoc:
 1143:         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
 1144:         closesocket(s->fd);
 1145:         return;
 1146:     }
 1147:     buf = buf1;
 1148:     while (size > 0) {
 1149:         /* reassemble a packet from the network */
 1150:         switch(s->state) {
 1151:         case 0:
 1152:             l = 4 - s->index;
 1153:             if (l > size)
 1154:                 l = size;
 1155:             memcpy(s->buf + s->index, buf, l);
 1156:             buf += l;
 1157:             size -= l;
 1158:             s->index += l;
 1159:             if (s->index == 4) {
 1160:                 /* got length */
 1161:                 s->packet_len = ntohl(*(uint32_t *)s->buf);
 1162:                 s->index = 0;
 1163:                 s->state = 1;
 1164:             }
 1165:             break;
 1166:         case 1:
 1167:             l = s->packet_len - s->index;
 1168:             if (l > size)
 1169:                 l = size;
 1170:             if (s->index + l <= sizeof(s->buf)) {
 1171:                 memcpy(s->buf + s->index, buf, l);
 1172:             } else {
 1173:                 fprintf(stderr, "serious error: oversized packet received,"
 1174:                     "connection terminated.\n");
 1175:                 s->state = 0;
 1176:                 goto eoc;
 1177:             }
 1178: 
 1179:             s->index += l;
 1180:             buf += l;
 1181:             size -= l;
 1182:             if (s->index >= s->packet_len) {
 1183:                 qemu_send_packet(s->vc, s->buf, s->packet_len);
 1184:                 s->index = 0;
 1185:                 s->state = 0;
 1186:             }
 1187:             break;
 1188:         }
 1189:     }
 1190: }
 1191: 
 1192: static void net_socket_send_dgram(void *opaque)
 1193: {
 1194:     NetSocketState *s = opaque;
 1195:     int size;
 1196: 
 1197:     size = recv(s->fd, s->buf, sizeof(s->buf), 0);
 1198:     if (size < 0)
 1199:         return;
 1200:     if (size == 0) {
 1201:         /* end of connection */
 1202:         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
 1203:         return;
 1204:     }
 1205:     qemu_send_packet(s->vc, s->buf, size);
 1206: }
 1207: 
 1208: static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
 1209: {
 1210:     struct ip_mreq imr;
 1211:     int fd;
 1212:     int val, ret;
 1213:     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
 1214: 	fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
 1215: 		inet_ntoa(mcastaddr->sin_addr),
 1216:                 (int)ntohl(mcastaddr->sin_addr.s_addr));
 1217: 	return -1;
 1218: 
 1219:     }
 1220:     fd = socket(PF_INET, SOCK_DGRAM, 0);
 1221:     if (fd < 0) {
 1222:         perror("socket(PF_INET, SOCK_DGRAM)");
 1223:         return -1;
 1224:     }
 1225: 
 1226:     val = 1;
 1227:     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
 1228:                    (const char *)&val, sizeof(val));
 1229:     if (ret < 0) {
 1230: 	perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
 1231: 	goto fail;
 1232:     }
 1233: 
 1234:     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
 1235:     if (ret < 0) {
 1236:         perror("bind");
 1237:         goto fail;
 1238:     }
 1239: 
 1240:     /* Add host to multicast group */
 1241:     imr.imr_multiaddr = mcastaddr->sin_addr;
 1242:     imr.imr_interface.s_addr = htonl(INADDR_ANY);
 1243: 
 1244:     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 1245:                      (const char *)&imr, sizeof(struct ip_mreq));
 1246:     if (ret < 0) {
 1247: 	perror("setsockopt(IP_ADD_MEMBERSHIP)");
 1248: 	goto fail;
 1249:     }
 1250: 
 1251:     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
 1252:     val = 1;
 1253:     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
 1254:                    (const char *)&val, sizeof(val));
 1255:     if (ret < 0) {
 1256: 	perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
 1257: 	goto fail;
 1258:     }
 1259: 
 1260:     socket_set_nonblock(fd);
 1261:     return fd;
 1262: fail:
 1263:     if (fd >= 0)
 1264:         closesocket(fd);
 1265:     return -1;
 1266: }
 1267: 
 1268: static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
 1269:                                                 const char *model,
 1270:                                                 const char *name,
 1271:                                                 int fd, int is_connected)
 1272: {
 1273:     struct sockaddr_in saddr;
 1274:     int newfd;
 1275:     socklen_t saddr_len;
 1276:     NetSocketState *s;
 1277: 
 1278:     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
 1279:      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
 1280:      * by ONLY ONE process: we must "clone" this dgram socket --jjo
 1281:      */
 1282: 
 1283:     if (is_connected) {
 1284: 	if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
 1285: 	    /* must be bound */
 1286: 	    if (saddr.sin_addr.s_addr==0) {
 1287: 		fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
 1288: 			fd);
 1289: 		return NULL;
 1290: 	    }
 1291: 	    /* clone dgram socket */
 1292: 	    newfd = net_socket_mcast_create(&saddr);
 1293: 	    if (newfd < 0) {
 1294: 		/* error already reported by net_socket_mcast_create() */
 1295: 		close(fd);
 1296: 		return NULL;
 1297: 	    }
 1298: 	    /* clone newfd to fd, close newfd */
 1299: 	    dup2(newfd, fd);
 1300: 	    close(newfd);
 1301: 
 1302: 	} else {
 1303: 	    fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
 1304: 		    fd, strerror(errno));
 1305: 	    return NULL;
 1306: 	}
 1307:     }
 1308: 
 1309:     s = qemu_mallocz(sizeof(NetSocketState));
 1310:     s->fd = fd;
 1311: 
 1312:     s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive_dgram, NULL, s);
 1313:     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
 1314: 
 1315:     /* mcast: save bound address as dst */
 1316:     if (is_connected) s->dgram_dst=saddr;
 1317: 
 1318:     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 1319: 	    "socket: fd=%d (%s mcast=%s:%d)",
 1320: 	    fd, is_connected? "cloned" : "",
 1321: 	    inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 1322:     return s;
 1323: }
 1324: 
 1325: static void net_socket_connect(void *opaque)
 1326: {
 1327:     NetSocketState *s = opaque;
 1328:     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
 1329: }
 1330: 
 1331: static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
 1332:                                                  const char *model,
 1333:                                                  const char *name,
 1334:                                                  int fd, int is_connected)
 1335: {
 1336:     NetSocketState *s;
 1337:     s = qemu_mallocz(sizeof(NetSocketState));
 1338:     s->fd = fd;
 1339:     s->vc = qemu_new_vlan_client(vlan, model, name,
 1340:                                  net_socket_receive, NULL, s);
 1341:     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 1342:              "socket: fd=%d", fd);
 1343:     if (is_connected) {
 1344:         net_socket_connect(s);
 1345:     } else {
 1346:         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
 1347:     }
 1348:     return s;
 1349: }
 1350: 
 1351: static NetSocketState *net_socket_fd_init(VLANState *vlan,
 1352:                                           const char *model, const char *name,
 1353:                                           int fd, int is_connected)
 1354: {
 1355:     int so_type=-1, optlen=sizeof(so_type);
 1356: 
 1357:     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
 1358:         (socklen_t *)&optlen)< 0) {
 1359: 	fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
 1360: 	return NULL;
 1361:     }
 1362:     switch(so_type) {
 1363:     case SOCK_DGRAM:
 1364:         return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
 1365:     case SOCK_STREAM:
 1366:         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
 1367:     default:
 1368:         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
 1369:         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
 1370:         return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
 1371:     }
 1372:     return NULL;
 1373: }
 1374: 
 1375: static void net_socket_accept(void *opaque)
 1376: {
 1377:     NetSocketListenState *s = opaque;
 1378:     NetSocketState *s1;
 1379:     struct sockaddr_in saddr;
 1380:     socklen_t len;
 1381:     int fd;
 1382: 
 1383:     for(;;) {
 1384:         len = sizeof(saddr);
 1385:         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
 1386:         if (fd < 0 && errno != EINTR) {
 1387:             return;
 1388:         } else if (fd >= 0) {
 1389:             break;
 1390:         }
 1391:     }
 1392:     s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
 1393:     if (!s1) {
 1394:         closesocket(fd);
 1395:     } else {
 1396:         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
 1397:                  "socket: connection from %s:%d",
 1398:                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 1399:     }
 1400: }
 1401: 
 1402: static int net_socket_listen_init(VLANState *vlan,
 1403:                                   const char *model,
 1404:                                   const char *name,
 1405:                                   const char *host_str)
 1406: {
 1407:     NetSocketListenState *s;
 1408:     int fd, val, ret;
 1409:     struct sockaddr_in saddr;
 1410: 
 1411:     if (parse_host_port(&saddr, host_str) < 0)
 1412:         return -1;
 1413: 
 1414:     s = qemu_mallocz(sizeof(NetSocketListenState));
 1415: 
 1416:     fd = socket(PF_INET, SOCK_STREAM, 0);
 1417:     if (fd < 0) {
 1418:         perror("socket");
 1419:         return -1;
 1420:     }
 1421:     socket_set_nonblock(fd);
 1422: 
 1423:     /* allow fast reuse */
 1424:     val = 1;
 1425:     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
 1426: 
 1427:     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
 1428:     if (ret < 0) {
 1429:         perror("bind");
 1430:         return -1;
 1431:     }
 1432:     ret = listen(fd, 0);
 1433:     if (ret < 0) {
 1434:         perror("listen");
 1435:         return -1;
 1436:     }
 1437:     s->vlan = vlan;
 1438:     s->model = strdup(model);
 1439:     s->name = strdup(name);
 1440:     s->fd = fd;
 1441:     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
 1442:     return 0;
 1443: }
 1444: 
 1445: static int net_socket_connect_init(VLANState *vlan,
 1446:                                    const char *model,
 1447:                                    const char *name,
 1448:                                    const char *host_str)
 1449: {
 1450:     NetSocketState *s;
 1451:     int fd, connected, ret, err;
 1452:     struct sockaddr_in saddr;
 1453: 
 1454:     if (parse_host_port(&saddr, host_str) < 0)
 1455:         return -1;
 1456: 
 1457:     fd = socket(PF_INET, SOCK_STREAM, 0);
 1458:     if (fd < 0) {
 1459:         perror("socket");
 1460:         return -1;
 1461:     }
 1462:     socket_set_nonblock(fd);
 1463: 
 1464:     connected = 0;
 1465:     for(;;) {
 1466:         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
 1467:         if (ret < 0) {
 1468:             err = socket_error();
 1469:             if (err == EINTR || err == EWOULDBLOCK) {
 1470:             } else if (err == EINPROGRESS) {
 1471:                 break;
 1472: #ifdef _WIN32
 1473:             } else if (err == WSAEALREADY) {
 1474:                 break;
 1475: #endif
 1476:             } else {
 1477:                 perror("connect");
 1478:                 closesocket(fd);
 1479:                 return -1;
 1480:             }
 1481:         } else {
 1482:             connected = 1;
 1483:             break;
 1484:         }
 1485:     }
 1486:     s = net_socket_fd_init(vlan, model, name, fd, connected);
 1487:     if (!s)
 1488:         return -1;
 1489:     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 1490:              "socket: connect to %s:%d",
 1491:              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 1492:     return 0;
 1493: }
 1494: 
 1495: static int net_socket_mcast_init(VLANState *vlan,
 1496:                                  const char *model,
 1497:                                  const char *name,
 1498:                                  const char *host_str)
 1499: {
 1500:     NetSocketState *s;
 1501:     int fd;
 1502:     struct sockaddr_in saddr;
 1503: 
 1504:     if (parse_host_port(&saddr, host_str) < 0)
 1505:         return -1;
 1506: 
 1507: 
 1508:     fd = net_socket_mcast_create(&saddr);
 1509:     if (fd < 0)
 1510: 	return -1;
 1511: 
 1512:     s = net_socket_fd_init(vlan, model, name, fd, 0);
 1513:     if (!s)
 1514:         return -1;
 1515: 
 1516:     s->dgram_dst = saddr;
 1517: 
 1518:     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
 1519:              "socket: mcast=%s:%d",
 1520:              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 1521:     return 0;
 1522: 
 1523: }
 1524: 
 1525: /* find or alloc a new VLAN */
 1526: VLANState *qemu_find_vlan(int id)
 1527: {
 1528:     VLANState **pvlan, *vlan;
 1529:     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
 1530:         if (vlan->id == id)
 1531:             return vlan;
 1532:     }
 1533:     vlan = qemu_mallocz(sizeof(VLANState));
 1534:     vlan->id = id;
 1535:     vlan->next = NULL;
 1536:     pvlan = &first_vlan;
 1537:     while (*pvlan != NULL)
 1538:         pvlan = &(*pvlan)->next;
 1539:     *pvlan = vlan;
 1540:     return vlan;
 1541: }
 1542: 
 1543: static int nic_get_free_idx(void)
 1544: {
 1545:     int index;
 1546: 
 1547:     for (index = 0; index < MAX_NICS; index++)
 1548:         if (!nd_table[index].used)
 1549:             return index;
 1550:     return -1;
 1551: }
 1552: 
 1553: void qemu_check_nic_model(NICInfo *nd, const char *model)
 1554: {
 1555:     const char *models[2];
 1556: 
 1557:     models[0] = model;
 1558:     models[1] = NULL;
 1559: 
 1560:     qemu_check_nic_model_list(nd, models, model);
 1561: }
 1562: 
 1563: void qemu_check_nic_model_list(NICInfo *nd, const char * const *models,
 1564:                                const char *default_model)
 1565: {
 1566:     int i, exit_status = 0;
 1567: 
 1568:     if (!nd->model)
 1569:         nd->model = strdup(default_model);
 1570: 
 1571:     if (strcmp(nd->model, "?") != 0) {
 1572:         for (i = 0 ; models[i]; i++)
 1573:             if (strcmp(nd->model, models[i]) == 0)
 1574:                 return;
 1575: 
 1576:         fprintf(stderr, "qemu: Unsupported NIC model: %s\n", nd->model);
 1577:         exit_status = 1;
 1578:     }
 1579: 
 1580:     fprintf(stderr, "qemu: Supported NIC models: ");
 1581:     for (i = 0 ; models[i]; i++)
 1582:         fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
 1583: 
 1584:     exit(exit_status);
 1585: }
 1586: 
 1587: int net_client_init(const char *device, const char *p)
 1588: {
 1589:     char buf[1024];
 1590:     int vlan_id, ret;
 1591:     VLANState *vlan;
 1592:     char *name = NULL;
 1593: 
 1594:     vlan_id = 0;
 1595:     if (get_param_value(buf, sizeof(buf), "vlan", p)) {
 1596:         vlan_id = strtol(buf, NULL, 0);
 1597:     }
 1598:     vlan = qemu_find_vlan(vlan_id);
 1599:     if (!vlan) {
 1600:         fprintf(stderr, "Could not create vlan %d\n", vlan_id);
 1601:         return -1;
 1602:     }
 1603:     if (get_param_value(buf, sizeof(buf), "name", p)) {
 1604:         name = strdup(buf);
 1605:     }
 1606:     if (!strcmp(device, "nic")) {
 1607:         NICInfo *nd;
 1608:         uint8_t *macaddr;
 1609:         int idx = nic_get_free_idx();
 1610: 
 1611:         if (idx == -1 || nb_nics >= MAX_NICS) {
 1612:             fprintf(stderr, "Too Many NICs\n");
 1613:             return -1;
 1614:         }
 1615:         nd = &nd_table[idx];
 1616:         macaddr = nd->macaddr;
 1617:         macaddr[0] = 0x52;
 1618:         macaddr[1] = 0x54;
 1619:         macaddr[2] = 0x00;
 1620:         macaddr[3] = 0x12;
 1621:         macaddr[4] = 0x34;
 1622:         macaddr[5] = 0x56 + idx;
 1623: 
 1624:         if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
 1625:             if (parse_macaddr(macaddr, buf) < 0) {
 1626:                 fprintf(stderr, "invalid syntax for ethernet address\n");
 1627:                 return -1;
 1628:             }
 1629:         }
 1630:         if (get_param_value(buf, sizeof(buf), "model", p)) {
 1631:             nd->model = strdup(buf);
 1632:         }
 1633:         nd->vlan = vlan;
 1634:         nd->name = name;
 1635:         nd->used = 1;
 1636:         name = NULL;
 1637:         nb_nics++;
 1638:         vlan->nb_guest_devs++;
 1639:         ret = idx;
 1640:     } else
 1641:     if (!strcmp(device, "none")) {
 1642:         /* does nothing. It is needed to signal that no network cards
 1643:            are wanted */
 1644:         ret = 0;
 1645:     } else
 1646: #ifdef CONFIG_SLIRP
 1647:     if (!strcmp(device, "user")) {
 1648:         if (get_param_value(buf, sizeof(buf), "hostname", p)) {
 1649:             pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
 1650:         }
 1651:         if (get_param_value(buf, sizeof(buf), "restrict", p)) {
 1652:             slirp_restrict = (buf[0] == 'y') ? 1 : 0;
 1653:         }
 1654:         if (get_param_value(buf, sizeof(buf), "ip", p)) {
 1655:             slirp_ip = strdup(buf);
 1656:         }
 1657:         vlan->nb_host_devs++;
 1658:         ret = net_slirp_init(vlan, device, name);
 1659:     } else if (!strcmp(device, "channel")) {
 1660:         long port;
 1661:         char name[20], *devname;
 1662:         struct VMChannel *vmc;
 1663: 
 1664:         port = strtol(p, &devname, 10);
 1665:         devname++;
 1666:         if (port < 1 || port > 65535) {
 1667:             fprintf(stderr, "vmchannel wrong port number\n"); 
 1668:             return -1;
 1669:         }
 1670:         vmc = malloc(sizeof(struct VMChannel));
 1671:         snprintf(name, 20, "vmchannel%ld", port);
 1672:         vmc->hd = qemu_chr_open(name, devname, NULL);
 1673:         if (!vmc->hd) {
 1674:             fprintf(stderr, "qemu: could not open vmchannel device"
 1675:                     "'%s'\n", devname);
 1676:             return -1;
 1677:         }
 1678:         vmc->port = port;
 1679:         slirp_add_exec(3, vmc->hd, 4, port);
 1680:         qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
 1681:                 NULL, vmc);
 1682:         ret = 0;
 1683:     } else
 1684: #endif
 1685: #ifdef _WIN32
 1686:     if (!strcmp(device, "tap")) {
 1687:         char ifname[64];
 1688:         if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
 1689:             fprintf(stderr, "tap: no interface name\n");
 1690:             return -1;
 1691:         }
 1692:         vlan->nb_host_devs++;
 1693:         ret = tap_win32_init(vlan, device, name, ifname);
 1694:     } else
 1695: #elif defined (_AIX)
 1696: #else
 1697:     if (!strcmp(device, "tap")) {
 1698:         char ifname[64];
 1699:         char setup_script[1024], down_script[1024];
 1700:         int fd;
 1701:         vlan->nb_host_devs++;
 1702:         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
 1703:             fd = strtol(buf, NULL, 0);
 1704:             fcntl(fd, F_SETFL, O_NONBLOCK);
 1705:             ret = -1;
 1706:             if (net_tap_fd_init(vlan, device, name, fd))
 1707:                 ret = 0;
 1708:         } else {
 1709:             if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
 1710:                 ifname[0] = '\0';
 1711:             }
 1712:             if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
 1713:                 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
 1714:             }
 1715:             if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
 1716:                 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
 1717:             }
 1718:             ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
 1719:         }
 1720:     } else
 1721: #endif
 1722:     if (!strcmp(device, "socket")) {
 1723:         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
 1724:             int fd;
 1725:             fd = strtol(buf, NULL, 0);
 1726:             ret = -1;
 1727:             if (net_socket_fd_init(vlan, device, name, fd, 1))
 1728:                 ret = 0;
 1729:         } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
 1730:             ret = net_socket_listen_init(vlan, device, name, buf);
 1731:         } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
 1732:             ret = net_socket_connect_init(vlan, device, name, buf);
 1733:         } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
 1734:             ret = net_socket_mcast_init(vlan, device, name, buf);
 1735:         } else {
 1736:             fprintf(stderr, "Unknown socket options: %s\n", p);
 1737:             return -1;
 1738:         }
 1739:         vlan->nb_host_devs++;
 1740:     } else
 1741: #ifdef CONFIG_VDE
 1742:     if (!strcmp(device, "vde")) {
 1743:         char vde_sock[1024], vde_group[512];
 1744: 	int vde_port, vde_mode;
 1745:         vlan->nb_host_devs++;
 1746:         if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
 1747: 	    vde_sock[0] = '\0';
 1748: 	}
 1749: 	if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
 1750: 	    vde_port = strtol(buf, NULL, 10);
 1751: 	} else {
 1752: 	    vde_port = 0;
 1753: 	}
 1754: 	if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
 1755: 	    vde_group[0] = '\0';
 1756: 	}
 1757: 	if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
 1758: 	    vde_mode = strtol(buf, NULL, 8);
 1759: 	} else {
 1760: 	    vde_mode = 0700;
 1761: 	}
 1762: 	ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode);
 1763:     } else
 1764: #endif
 1765:     {
 1766:         fprintf(stderr, "Unknown network device: %s\n", device);
 1767:         if (name)
 1768:             free(name);
 1769:         return -1;
 1770:     }
 1771:     if (ret < 0) {
 1772:         fprintf(stderr, "Could not initialize device '%s'\n", device);
 1773:     }
 1774:     if (name)
 1775:         free(name);
 1776:     return ret;
 1777: }
 1778: 
 1779: void net_client_uninit(NICInfo *nd)
 1780: {
 1781:     nd->vlan->nb_guest_devs--;
 1782:     nb_nics--;
 1783:     nd->used = 0;
 1784:     free((void *)nd->model);
 1785: }
 1786: 
 1787: static int net_host_check_device(const char *device)
 1788: {
 1789:     int i;
 1790:     const char *valid_param_list[] = { "tap", "socket"
 1791: #ifdef CONFIG_SLIRP
 1792:                                        ,"user"
 1793: #endif
 1794: #ifdef CONFIG_VDE
 1795:                                        ,"vde"
 1796: #endif
 1797:     };
 1798:     for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
 1799:         if (!strncmp(valid_param_list[i], device,
 1800:                      strlen(valid_param_list[i])))
 1801:             return 1;
 1802:     }
 1803: 
 1804:     return 0;
 1805: }
 1806: 
 1807: void net_host_device_add(const char *device, const char *opts)
 1808: {
 1809:     if (!net_host_check_device(device)) {
 1810:         term_printf("invalid host network device %s\n", device);
 1811:         return;
 1812:     }
 1813:     net_client_init(device, opts);
 1814: }
 1815: 
 1816: void net_host_device_remove(int vlan_id, const char *device)
 1817: {
 1818:     VLANState *vlan;
 1819:     VLANClientState *vc;
 1820: 
 1821:     if (!net_host_check_device(device)) {
 1822:         term_printf("invalid host network device %s\n", device);
 1823:         return;
 1824:     }
 1825: 
 1826:     vlan = qemu_find_vlan(vlan_id);
 1827:     if (!vlan) {
 1828:         term_printf("can't find vlan %d\n", vlan_id);
 1829:         return;
 1830:     }
 1831: 
 1832:    for(vc = vlan->first_client; vc != NULL; vc = vc->next)
 1833:         if (!strcmp(vc->name, device))
 1834:             break;
 1835: 
 1836:     if (!vc) {
 1837:         term_printf("can't find device %s\n", device);
 1838:         return;
 1839:     }
 1840:     qemu_del_vlan_client(vc);
 1841: }
 1842: 
 1843: int net_client_parse(const char *str)
 1844: {
 1845:     const char *p;
 1846:     char *q;
 1847:     char device[64];
 1848: 
 1849:     p = str;
 1850:     q = device;
 1851:     while (*p != '\0' && *p != ',') {
 1852:         if ((q - device) < sizeof(device) - 1)
 1853:             *q++ = *p;
 1854:         p++;
 1855:     }
 1856:     *q = '\0';
 1857:     if (*p == ',')
 1858:         p++;
 1859: 
 1860:     return net_client_init(device, p);
 1861: }
 1862: 
 1863: void do_info_network(void)
 1864: {
 1865:     VLANState *vlan;
 1866:     VLANClientState *vc;
 1867: 
 1868:     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
 1869:         term_printf("VLAN %d devices:\n", vlan->id);
 1870:         for(vc = vlan->first_client; vc != NULL; vc = vc->next)
 1871:             term_printf("  %s: %s\n", vc->name, vc->info_str);
 1872:     }
 1873: }
 1874: 
 1875: int do_set_link(const char *name, const char *up_or_down)
 1876: {
 1877:     VLANState *vlan;
 1878:     VLANClientState *vc = NULL;
 1879: 
 1880:     for (vlan = first_vlan; vlan != NULL; vlan = vlan->next)
 1881:         for (vc = vlan->first_client; vc != NULL; vc = vc->next)
 1882:             if (strcmp(vc->name, name) == 0)
 1883:                 goto done;
 1884: done:
 1885: 
 1886:     if (!vc) {
 1887:         term_printf("could not find network device '%s'", name);
 1888:         return 0;
 1889:     }
 1890: 
 1891:     if (strcmp(up_or_down, "up") == 0)
 1892:         vc->link_down = 0;
 1893:     else if (strcmp(up_or_down, "down") == 0)
 1894:         vc->link_down = 1;
 1895:     else
 1896:         term_printf("invalid link status '%s'; only 'up' or 'down' valid\n",
 1897:                     up_or_down);
 1898: 
 1899:     if (vc->link_status_changed)
 1900:         vc->link_status_changed(vc);
 1901: 
 1902:     return 1;
 1903: }
 1904: 
 1905: void net_cleanup(void)
 1906: {
 1907:     VLANState *vlan;
 1908: 
 1909: #if !defined(_WIN32)
 1910:     /* close network clients */
 1911:     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
 1912:         VLANClientState *vc;
 1913: 
 1914:         for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
 1915:             if (vc->fd_read == tap_receive) {
 1916:                 TAPState *s = vc->opaque;
 1917: 
 1918:                 if (s->down_script[0])
 1919:                     launch_script(s->down_script, s->down_script_arg, s->fd);
 1920:             }
 1921: #if defined(CONFIG_VDE)
 1922:             if (vc->fd_read == vde_from_qemu) {
 1923:                 VDEState *s = vc->opaque;
 1924:                 vde_close(s->vde);
 1925:             }
 1926: #endif
 1927:         }
 1928:     }
 1929: #endif
 1930: }
 1931: 
 1932: void net_client_check(void)
 1933: {
 1934:     VLANState *vlan;
 1935: 
 1936:     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
 1937:         if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
 1938:             continue;
 1939:         if (vlan->nb_guest_devs == 0)
 1940:             fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
 1941:         if (vlan->nb_host_devs == 0)
 1942:             fprintf(stderr,
 1943:                     "Warning: vlan %d is not connected to host network\n",
 1944:                     vlan->id);
 1945:     }
 1946: }

unix.superglobalmegacorp.com