Archipelago » qemu

/*

 * QEMU System Emulator

 *

 * Copyright (c) 2003-2008 Fabrice Bellard

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include <unistd.h>

#include <fcntl.h>

#include <signal.h>

#include <time.h>

#include <errno.h>

#include <sys/time.h>

#include <zlib.h>

/* Needed early for HOST_BSD etc. */

#include "config-host.h"

#ifndef _WIN32

#include <sys/times.h>

#include <sys/wait.h>

#include <termios.h>

#include <sys/mman.h>

#include <sys/ioctl.h>

#include <sys/resource.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <net/if.h>

#ifdef __NetBSD__

#include <net/if_tap.h>

#endif

#ifdef __linux__

#include <linux/if_tun.h>

#endif

#include <arpa/inet.h>

#include <dirent.h>

#include <netdb.h>

#include <sys/select.h>

#ifdef HOST_BSD

#include <sys/stat.h>

#if defined(__FreeBSD__) || defined(__DragonFly__)

#include <libutil.h>

#else

#include <util.h>

#endif

#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)

#include <freebsd/stdlib.h>

#else

#ifdef __linux__

#include <pty.h>

#include <malloc.h>

#include <linux/rtc.h>

/* For the benefit of older linux systems which don't supply it,

   we use a local copy of hpet.h. */

/* #include <linux/hpet.h> */

#include "hpet.h"

#include <linux/ppdev.h>

#include <linux/parport.h>

#endif

#ifdef __sun__

#include <sys/stat.h>

#include <sys/ethernet.h>

#include <sys/sockio.h>

#include <netinet/arp.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h> // must come after ip.h

#include <netinet/udp.h>

#include <netinet/tcp.h>

#include <net/if.h>

#include <syslog.h>

#include <stropts.h>

#endif

#endif

#endif

#if defined(__OpenBSD__)

#include <util.h>

#endif

#if defined(CONFIG_VDE)

#include <libvdeplug.h>

#endif

#ifdef _WIN32

#include <windows.h>

#include <malloc.h>

#include <sys/timeb.h>

#include <mmsystem.h>

#define getopt_long_only getopt_long

#define memalign(align, size) malloc(size)

#endif

#include "qemu-common.h"

#include "net.h"

#include "monitor.h"

#include "sysemu.h"

#include "qemu-timer.h"

#include "qemu-char.h"

#include "audio/audio.h"

#include "qemu_socket.h"

#include "qemu-log.h"

#if defined(CONFIG_SLIRP)

#include "libslirp.h"

#endif

static VLANState *first_vlan;

/***********************************************************/

/* network device redirectors */

#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)

static void hex_dump(FILE *f, const uint8_t *buf, int size)

{

    int len, i, j, c;

    for(i=0;i<size;i+=16) {

        len = size - i;

        if (len > 16)

            len = 16;

        fprintf(f, "%08x ", i);

        for(j=0;j<16;j++) {

            if (j < len)

                fprintf(f, " %02x", buf[i+j]);

            else

                fprintf(f, "   ");

        }

        fprintf(f, " ");

        for(j=0;j<len;j++) {

            c = buf[i+j];

            if (c < ' ' || c > '~')

                c = '.';

            fprintf(f, "%c", c);

        }

        fprintf(f, "\n");

    }

}

#endif

static int parse_macaddr(uint8_t *macaddr, const char *p)

{

    int i;

    char *last_char;

    long int offset;

    errno = 0;

    offset = strtol(p, &last_char, 0);    

    if (0 == errno && '\0' == *last_char &&

            offset >= 0 && offset <= 0xFFFFFF) {

        macaddr[3] = (offset & 0xFF0000) >> 16;

        macaddr[4] = (offset & 0xFF00) >> 8;

        macaddr[5] = offset & 0xFF;

        return 0;

    } else {

        for(i = 0; i < 6; i++) {

            macaddr[i] = strtol(p, (char **)&p, 16);

            if (i == 5) {

                if (*p != '\0')

                    return -1;

            } else {

                if (*p != ':' && *p != '-')

                    return -1;

                p++;

            }

        }

        return 0;    

    }

    return -1;

}

static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)

{

    const char *p, *p1;

    int len;

    p = *pp;

    p1 = strchr(p, sep);

    if (!p1)

        return -1;

    len = p1 - p;

    p1++;

    if (buf_size > 0) {

        if (len > buf_size - 1)

            len = buf_size - 1;

        memcpy(buf, p, len);

        buf[len] = '\0';

    }

    *pp = p1;

    return 0;

}

int parse_host_src_port(struct sockaddr_in *haddr,

                        struct sockaddr_in *saddr,

                        const char *input_str)

{

    char *str = strdup(input_str);

    char *host_str = str;

    char *src_str;

    const char *src_str2;

    char *ptr;

    /*

     * Chop off any extra arguments at the end of the string which

     * would start with a comma, then fill in the src port information

     * if it was provided else use the "any address" and "any port".

     */

    if ((ptr = strchr(str,',')))

        *ptr = '\0';

    if ((src_str = strchr(input_str,'@'))) {

        *src_str = '\0';

        src_str++;

    }

    if (parse_host_port(haddr, host_str) < 0)

        goto fail;

    src_str2 = src_str;

    if (!src_str || *src_str == '\0')

        src_str2 = ":0";

    if (parse_host_port(saddr, src_str2) < 0)

        goto fail;

    free(str);

    return(0);

fail:

    free(str);

    return -1;

}

int parse_host_port(struct sockaddr_in *saddr, const char *str)

{

    char buf[512];

    struct hostent *he;

    const char *p, *r;

    int port;

    p = str;

    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)

        return -1;

    saddr->sin_family = AF_INET;

    if (buf[0] == '\0') {

        saddr->sin_addr.s_addr = 0;

    } else {

        if (qemu_isdigit(buf[0])) {

            if (!inet_aton(buf, &saddr->sin_addr))

                return -1;

        } else {

            if ((he = gethostbyname(buf)) == NULL)

                return - 1;

            saddr->sin_addr = *(struct in_addr *)he->h_addr;

        }

    }

    port = strtol(p, (char **)&r, 0);

    if (r == p)

        return -1;

    saddr->sin_port = htons(port);

    return 0;

}

#if !defined(_WIN32) && 0

static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)

{

    const char *p;

    int len;

    len = MIN(108, strlen(str));

    p = strchr(str, ',');

    if (p)

        len = MIN(len, p - str);

    memset(uaddr, 0, sizeof(*uaddr));

    uaddr->sun_family = AF_UNIX;

    memcpy(uaddr->sun_path, str, len);

    return 0;

}

#endif

void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])

{

    snprintf(vc->info_str, sizeof(vc->info_str),

             "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

             vc->model,

             macaddr[0], macaddr[1], macaddr[2],

             macaddr[3], macaddr[4], macaddr[5]);

}

static char *assign_name(VLANClientState *vc1, const char *model)

{

    VLANState *vlan;

    char buf[256];

    int id = 0;

    for (vlan = first_vlan; vlan; vlan = vlan->next) {

        VLANClientState *vc;

        for (vc = vlan->first_client; vc; vc = vc->next)

            if (vc != vc1 && strcmp(vc->model, model) == 0)

                id++;

    }

    snprintf(buf, sizeof(buf), "%s.%d", model, id);

    return strdup(buf);

}

VLANClientState *qemu_new_vlan_client(VLANState *vlan,

                                      const char *model,

                                      const char *name,

                                      IOReadHandler *fd_read,

                                      IOCanRWHandler *fd_can_read,

                                      NetCleanup *cleanup,

                                      void *opaque)

{

    VLANClientState *vc, **pvc;

    vc = qemu_mallocz(sizeof(VLANClientState));

    vc->model = strdup(model);

    if (name)

        vc->name = strdup(name);

    else

        vc->name = assign_name(vc, model);

    vc->fd_read = fd_read;

    vc->fd_can_read = fd_can_read;

    vc->cleanup = cleanup;

    vc->opaque = opaque;

    vc->vlan = vlan;

    vc->next = NULL;

    pvc = &vlan->first_client;

    while (*pvc != NULL)

        pvc = &(*pvc)->next;

    *pvc = vc;

    return vc;

}

void qemu_del_vlan_client(VLANClientState *vc)

{

    VLANClientState **pvc = &vc->vlan->first_client;

    while (*pvc != NULL)

        if (*pvc == vc) {

            *pvc = vc->next;

            if (vc->cleanup) {

                vc->cleanup(vc);

            }

            free(vc->name);

            free(vc->model);

            qemu_free(vc);

            break;

        } else

            pvc = &(*pvc)->next;

}

VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)

{

    VLANClientState **pvc = &vlan->first_client;

    while (*pvc != NULL)

        if ((*pvc)->opaque == opaque)

            return *pvc;

        else

            pvc = &(*pvc)->next;

    return NULL;

}

int qemu_can_send_packet(VLANClientState *vc1)

{

    VLANState *vlan = vc1->vlan;

    VLANClientState *vc;

    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {

        if (vc != vc1) {

            if (vc->fd_can_read && vc->fd_can_read(vc->opaque))

                return 1;

        }

    }

    return 0;

}

static void

qemu_deliver_packet(VLANClientState *sender, const uint8_t *buf, int size)

{

    VLANClientState *vc;

    for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) {

        if (vc != sender && !vc->link_down) {

            vc->fd_read(vc->opaque, buf, size);

        }

    }

}

void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)

{

    VLANState *vlan = vc->vlan;

    VLANPacket *packet;

    if (vc->link_down)

        return;

#ifdef DEBUG_NET

    printf("vlan %d send:\n", vlan->id);

    hex_dump(stdout, buf, size);

#endif

    if (vlan->delivering) {

        packet = qemu_malloc(sizeof(VLANPacket) + size);

        packet->next = vlan->send_queue;

        packet->sender = vc;

        packet->size = size;

        memcpy(packet->data, buf, size);

        vlan->send_queue = packet;

    } else {

        vlan->delivering = 1;

        qemu_deliver_packet(vc, buf, size);

        while ((packet = vlan->send_queue) != NULL) {

            qemu_deliver_packet(packet->sender, packet->data, packet->size);

            vlan->send_queue = packet->next;

            qemu_free(packet);

        }

        vlan->delivering = 0;

    }

}

static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,

                               int iovcnt)

{

    uint8_t buffer[4096];

    size_t offset = 0;

    int i;

    for (i = 0; i < iovcnt; i++) {

        size_t len;

        len = MIN(sizeof(buffer) - offset, iov[i].iov_len);

        memcpy(buffer + offset, iov[i].iov_base, len);

        offset += len;

    }

    vc->fd_read(vc->opaque, buffer, offset);

    return offset;

}

static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)

{

    size_t offset = 0;

    int i;

    for (i = 0; i < iovcnt; i++)

        offset += iov[i].iov_len;

    return offset;

}

ssize_t qemu_sendv_packet(VLANClientState *vc1, const struct iovec *iov,

                          int iovcnt)

{

    VLANState *vlan = vc1->vlan;

    VLANClientState *vc;

    ssize_t max_len = 0;

    if (vc1->link_down)

        return calc_iov_length(iov, iovcnt);

    for (vc = vlan->first_client; vc != NULL; vc = vc->next) {

        ssize_t len = 0;

        if (vc == vc1)

            continue;

        if (vc->link_down)

            len = calc_iov_length(iov, iovcnt);

        if (vc->fd_readv)

            len = vc->fd_readv(vc->opaque, iov, iovcnt);

        else if (vc->fd_read)

            len = vc_sendv_compat(vc, iov, iovcnt);

        max_len = MAX(max_len, len);

    }

    return max_len;

}

#if defined(CONFIG_SLIRP)

/* slirp network adapter */

static int slirp_inited;

static int slirp_restrict;

static char *slirp_ip;

static VLANClientState *slirp_vc;

int slirp_can_output(void)

{

    return !slirp_vc || qemu_can_send_packet(slirp_vc);

}

void slirp_output(const uint8_t *pkt, int pkt_len)

{

#ifdef DEBUG_SLIRP

    printf("slirp output:\n");

    hex_dump(stdout, pkt, pkt_len);

#endif

    if (!slirp_vc)

        return;

    qemu_send_packet(slirp_vc, pkt, pkt_len);

}

int slirp_is_inited(void)

{

    return slirp_inited;

}

static void slirp_receive(void *opaque, const uint8_t *buf, int size)

{

#ifdef DEBUG_SLIRP

    printf("slirp input:\n");

    hex_dump(stdout, buf, size);

#endif

    slirp_input(buf, size);

}

static int slirp_in_use;

static void net_slirp_cleanup(VLANClientState *vc)

{

    slirp_in_use = 0;

}

static int net_slirp_init(VLANState *vlan, const char *model, const char *name)

{

    if (slirp_in_use) {

        /* slirp only supports a single instance so far */

        return -1;

    }

    if (!slirp_inited) {

        slirp_inited = 1;

        slirp_init(slirp_restrict, slirp_ip);

    }

    slirp_vc = qemu_new_vlan_client(vlan, model, name,

                                    slirp_receive, NULL, net_slirp_cleanup, NULL);

    slirp_vc->info_str[0] = '\0';

    slirp_in_use = 1;

    return 0;

}

void net_slirp_redir(Monitor *mon, const char *redir_str)

{

    int is_udp;

    char buf[256], *r;

    const char *p, *errmsg;

    struct in_addr guest_addr;

    int host_port, guest_port;

    if (!slirp_inited) {

        slirp_inited = 1;

        slirp_init(slirp_restrict, slirp_ip);

    }

    p = redir_str;

    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)

        goto fail_syntax;

    if (!strcmp(buf, "tcp") || buf[0] == '\0') {

        is_udp = 0;

    } else if (!strcmp(buf, "udp")) {

        is_udp = 1;

    } else {

        goto fail_syntax;

    }

    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)

        goto fail_syntax;

    host_port = strtol(buf, &r, 0);

    if (r == buf)

        goto fail_syntax;

    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)

        goto fail_syntax;

    if (buf[0] == '\0') {

        pstrcpy(buf, sizeof(buf), "10.0.2.15");

    }

    if (!inet_aton(buf, &guest_addr))

        goto fail_syntax;

    guest_port = strtol(p, &r, 0);

    if (r == p)

        goto fail_syntax;

    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {

        errmsg = "could not set up redirection\n";

        goto fail;

    }

    return;

 fail_syntax:

    errmsg = "invalid redirection format\n";

 fail:

    if (mon) {

        monitor_printf(mon, "%s", errmsg);

    } else {

        fprintf(stderr, "qemu: %s", errmsg);

        exit(1);

    }

}

#ifndef _WIN32

static char smb_dir[1024];

static void erase_dir(char *dir_name)

{

    DIR *d;

    struct dirent *de;

    char filename[1024];

    /* erase all the files in the directory */

    if ((d = opendir(dir_name)) != NULL) {

        for(;;) {

            de = readdir(d);

            if (!de)

                break;

            if (strcmp(de->d_name, ".") != 0 &&

                strcmp(de->d_name, "..") != 0) {

                snprintf(filename, sizeof(filename), "%s/%s",

                         smb_dir, de->d_name);

                if (unlink(filename) != 0)  /* is it a directory? */

                    erase_dir(filename);

            }

        }

        closedir(d);

        rmdir(dir_name);

    }

}

/* automatic user mode samba server configuration */

static void smb_exit(void)

{

    erase_dir(smb_dir);

}

/* automatic user mode samba server configuration */

void net_slirp_smb(const char *exported_dir)

{

    char smb_conf[1024];

    char smb_cmdline[1024];

    FILE *f;

    if (!slirp_inited) {

        slirp_inited = 1;

        slirp_init(slirp_restrict, slirp_ip);

    }

    /* XXX: better tmp dir construction */

    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%ld", (long)getpid());

    if (mkdir(smb_dir, 0700) < 0) {

        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);

        exit(1);

    }

    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");

    f = fopen(smb_conf, "w");

    if (!f) {

        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);

        exit(1);

    }

    fprintf(f,

            "[global]\n"

            "private dir=%s\n"

            "smb ports=0\n"

            "socket address=127.0.0.1\n"

            "pid directory=%s\n"

            "lock directory=%s\n"

            "log file=%s/log.smbd\n"

            "smb passwd file=%s/smbpasswd\n"

            "security = share\n"

            "[qemu]\n"

            "path=%s\n"

            "read only=no\n"

            "guest ok=yes\n",

            smb_dir,

            smb_dir,

            smb_dir,

            smb_dir,

            smb_dir,

            exported_dir

            );

    fclose(f);

    atexit(smb_exit);

    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",

             SMBD_COMMAND, smb_conf);

    slirp_add_exec(0, smb_cmdline, 4, 139);

}

#endif /* !defined(_WIN32) */

void do_info_slirp(Monitor *mon)

{

    slirp_stats();

}

struct VMChannel {

    CharDriverState *hd;

    int port;

};

static int vmchannel_can_read(void *opaque)

{

    struct VMChannel *vmc = (struct VMChannel*)opaque;

    return slirp_socket_can_recv(4, vmc->port);

}

static void vmchannel_read(void *opaque, const uint8_t *buf, int size)

{

    struct VMChannel *vmc = (struct VMChannel*)opaque;

    slirp_socket_recv(4, vmc->port, buf, size);

}

#endif /* CONFIG_SLIRP */

#if !defined(_WIN32)

typedef struct TAPState {

    VLANClientState *vc;

    int fd;

    char down_script[1024];

    char down_script_arg[128];

} TAPState;

static int launch_script(const char *setup_script, const char *ifname, int fd);

static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov,

                               int iovcnt)

{

    TAPState *s = opaque;

    ssize_t len;

    do {

        len = writev(s->fd, iov, iovcnt);

    } while (len == -1 && (errno == EINTR || errno == EAGAIN));

    return len;

}

static void tap_receive(void *opaque, const uint8_t *buf, int size)

{

    TAPState *s = opaque;

    int ret;

    for(;;) {

        ret = write(s->fd, buf, size);

        if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {

        } else {

            break;

        }

    }

}

static void tap_send(void *opaque)

{

    TAPState *s = opaque;

    uint8_t buf[4096];

    int size;

#ifdef __sun__

    struct strbuf sbuf;

    int f = 0;

    sbuf.maxlen = sizeof(buf);

    sbuf.buf = (char *)buf;

    size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;

#else

    size = read(s->fd, buf, sizeof(buf));

#endif

    if (size > 0) {

        qemu_send_packet(s->vc, buf, size);

    }

}

static void tap_cleanup(VLANClientState *vc)

{

    TAPState *s = vc->opaque;

    if (s->down_script[0])

        launch_script(s->down_script, s->down_script_arg, s->fd);

    qemu_set_fd_handler(s->fd, NULL, NULL, NULL);

    close(s->fd);

    qemu_free(s);

}

/* fd support */

static TAPState *net_tap_fd_init(VLANState *vlan,

                                 const char *model,

                                 const char *name,

                                 int fd)

{

    TAPState *s;

    s = qemu_mallocz(sizeof(TAPState));

    s->fd = fd;

    s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive,

                                 NULL, tap_cleanup, s);

    s->vc->fd_readv = tap_receive_iov;

    qemu_set_fd_handler(s->fd, tap_send, NULL, s);

    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);

    return s;

}

#if defined (HOST_BSD) || defined (__FreeBSD_kernel__)

static int tap_open(char *ifname, int ifname_size)

{

    int fd;

    char *dev;

    struct stat s;

    TFR(fd = open("/dev/tap", O_RDWR));

    if (fd < 0) {

        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");

        return -1;

    }

    fstat(fd, &s);

    dev = devname(s.st_rdev, S_IFCHR);

    pstrcpy(ifname, ifname_size, dev);

    fcntl(fd, F_SETFL, O_NONBLOCK);

    return fd;

}

#elif defined(__sun__)

#define TUNNEWPPA       (('T'<<16) | 0x0001)

/*

 * Allocate TAP device, returns opened fd.

 * Stores dev name in the first arg(must be large enough).

 */

static int tap_alloc(char *dev, size_t dev_size)

{

    int tap_fd, if_fd, ppa = -1;

    static int ip_fd = 0;

    char *ptr;

    static int arp_fd = 0;

    int ip_muxid, arp_muxid;

    struct strioctl  strioc_if, strioc_ppa;

    int link_type = I_PLINK;;

    struct lifreq ifr;

    char actual_name[32] = "";

    memset(&ifr, 0x0, sizeof(ifr));

    if( *dev ){

       ptr = dev;

       while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;

       ppa = atoi(ptr);

    }

    /* Check if IP device was opened */

    if( ip_fd )

       close(ip_fd);

    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));

    if (ip_fd < 0) {

       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");

       return -1;

    }

    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));

    if (tap_fd < 0) {

       syslog(LOG_ERR, "Can't open /dev/tap");

       return -1;

    }

    /* Assign a new PPA and get its unit number. */

    strioc_ppa.ic_cmd = TUNNEWPPA;

    strioc_ppa.ic_timout = 0;

    strioc_ppa.ic_len = sizeof(ppa);

    strioc_ppa.ic_dp = (char *)&ppa;

    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)

       syslog (LOG_ERR, "Can't assign new interface");

    TFR(if_fd = open("/dev/tap", O_RDWR, 0));

    if (if_fd < 0) {

       syslog(LOG_ERR, "Can't open /dev/tap (2)");

       return -1;

    }

    if(ioctl(if_fd, I_PUSH, "ip") < 0){

       syslog(LOG_ERR, "Can't push IP module");

       return -1;

    }

    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)

        syslog(LOG_ERR, "Can't get flags\n");

    snprintf (actual_name, 32, "tap%d", ppa);

    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);

    ifr.lifr_ppa = ppa;

    /* Assign ppa according to the unit number returned by tun device */

    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)

        syslog (LOG_ERR, "Can't set PPA %d", ppa);

    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)

        syslog (LOG_ERR, "Can't get flags\n");

    /* Push arp module to if_fd */

    if (ioctl (if_fd, I_PUSH, "arp") < 0)

        syslog (LOG_ERR, "Can't push ARP module (2)");

    /* Push arp module to ip_fd */

    if (ioctl (ip_fd, I_POP, NULL) < 0)

        syslog (LOG_ERR, "I_POP failed\n");

    if (ioctl (ip_fd, I_PUSH, "arp") < 0)

        syslog (LOG_ERR, "Can't push ARP module (3)\n");

    /* Open arp_fd */

    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));

    if (arp_fd < 0)

       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");

    /* Set ifname to arp */

    strioc_if.ic_cmd = SIOCSLIFNAME;

    strioc_if.ic_timout = 0;

    strioc_if.ic_len = sizeof(ifr);

    strioc_if.ic_dp = (char *)𝔦

    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){

        syslog (LOG_ERR, "Can't set ifname to arp\n");

    }

    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){

       syslog(LOG_ERR, "Can't link TAP device to IP");

       return -1;

    }

    if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)

        syslog (LOG_ERR, "Can't link TAP device to ARP");

    close (if_fd);

    memset(&ifr, 0x0, sizeof(ifr));

    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);

    ifr.lifr_ip_muxid  = ip_muxid;

    ifr.lifr_arp_muxid = arp_muxid;

    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)

    {

      ioctl (ip_fd, I_PUNLINK , arp_muxid);

      ioctl (ip_fd, I_PUNLINK, ip_muxid);

      syslog (LOG_ERR, "Can't set multiplexor id");

    }

    snprintf(dev, dev_size, "tap%d", ppa);

    return tap_fd;

}

static int tap_open(char *ifname, int ifname_size)

{

    char  dev[10]="";

    int fd;

    if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){

       fprintf(stderr, "Cannot allocate TAP device\n");

       return -1;

    }

    pstrcpy(ifname, ifname_size, dev);

    fcntl(fd, F_SETFL, O_NONBLOCK);

    return fd;

}

#elif defined (_AIX)

static int tap_open(char *ifname, int ifname_size)

{

    fprintf (stderr, "no tap on AIX\n");

    return -1;

}

#else

static int tap_open(char *ifname, int ifname_size)

{

    struct ifreq ifr;

    int fd, ret;

    TFR(fd = open("/dev/net/tun", O_RDWR));

    if (fd < 0) {

        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");

        return -1;

    }

    memset(&ifr, 0, sizeof(ifr));

    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;

    if (ifname[0] != '\0')

        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);

    else

        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");

    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);

    if (ret != 0) {

        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");

        close(fd);

        return -1;

    }

    pstrcpy(ifname, ifname_size, ifr.ifr_name);

    fcntl(fd, F_SETFL, O_NONBLOCK);

    return fd;

}

#endif

static int launch_script(const char *setup_script, const char *ifname, int fd)

{

    int pid, status;

    char *args[3];

    char **parg;

        /* try to launch network script */

        pid = fork();

        if (pid >= 0) {

            if (pid == 0) {

                int open_max = sysconf (_SC_OPEN_MAX), i;

                for (i = 0; i < open_max; i++)

                    if (i != STDIN_FILENO &&

                        i != STDOUT_FILENO &&

                        i != STDERR_FILENO &&

                        i != fd)

                        close(i);

                parg = args;

                *parg++ = (char *)setup_script;

                *parg++ = (char *)ifname;

                *parg++ = NULL;

                execv(setup_script, args);

                _exit(1);

            }

            while (waitpid(pid, &status, 0) != pid);

            if (!WIFEXITED(status) ||

                WEXITSTATUS(status) != 0) {

                fprintf(stderr, "%s: could not launch network script\n",

                        setup_script);

                return -1;

            }

        }

    return 0;

}

static int net_tap_init(VLANState *vlan, const char *model,

                        const char *name, const char *ifname1,

                        const char *setup_script, const char *down_script)

{

    TAPState *s;

    int fd;

    char ifname[128];

    if (ifname1 != NULL)

        pstrcpy(ifname, sizeof(ifname), ifname1);

    else

        ifname[0] = '\0';

    TFR(fd = tap_open(ifname, sizeof(ifname)));

    if (fd < 0)

        return -1;

    if (!setup_script || !strcmp(setup_script, "no"))

        setup_script = "";

    if (setup_script[0] != '\0') {

        if (launch_script(setup_script, ifname, fd))

            return -1;

    }

    s = net_tap_fd_init(vlan, model, name, fd);

    snprintf(s->vc->info_str, sizeof(s->vc->info_str),

             "ifname=%s,script=%s,downscript=%s",

             ifname, setup_script, down_script);

    if (down_script && strcmp(down_script, "no")) {

        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);

        snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);

    }

    return 0;

}

#endif /* !_WIN32 */

#if defined(CONFIG_VDE)

typedef struct VDEState {

    VLANClientState *vc;

    VDECONN *vde;

} VDEState;

static void vde_to_qemu(void *opaque)

{

    VDEState *s = opaque;

    uint8_t buf[4096];

    int size;

    size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);

    if (size > 0) {

        qemu_send_packet(s->vc, buf, size);

    }

}

static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)

{

    VDEState *s = opaque;

    int ret;

    for(;;) {

        ret = vde_send(s->vde, (const char *)buf, size, 0);

        if (ret < 0 && errno == EINTR) {

        } else {

            break;

        }

    }

}

static void vde_cleanup(VLANClientState *vc)

{

    VDEState *s = vc->opaque;

    qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);

    vde_close(s->vde);

    qemu_free(s);

}

static int net_vde_init(VLANState *vlan, const char *model,

                        const char *name, const char *sock,

                        int port, const char *group, int mode)

{

    VDEState *s;

    char *init_group = strlen(group) ? (char *)group : NULL;

    char *init_sock = strlen(sock) ? (char *)sock : NULL;

    struct vde_open_args args = {

        .port = port,

        .group = init_group,

        .mode = mode,

    };

    s = qemu_mallocz(sizeof(VDEState));

    s->vde = vde_open(init_sock, (char *)"QEMU", &args);

    if (!s->vde){

        free(s);

        return -1;

    }

    s->vc = qemu_new_vlan_client(vlan, model, name, vde_from_qemu,

                                 NULL, vde_cleanup, s);

    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);

    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",

             sock, vde_datafd(s->vde));

    return 0;

}

#endif

/* network connection */

typedef struct NetSocketState {

    VLANClientState *vc;

    int fd;

    int state; /* 0 = getting length, 1 = getting data */

    unsigned int index;

    unsigned int packet_len;

    uint8_t buf[4096];

    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */

} NetSocketState;

typedef struct NetSocketListenState {

    VLANState *vlan;

    char *model;

    char *name;

    int fd;

} NetSocketListenState;

/* XXX: we consider we can send the whole packet without blocking */

static void net_socket_receive(void *opaque, const uint8_t *buf, int size)

{

    NetSocketState *s = opaque;

    uint32_t len;

    len = htonl(size);

    send_all(s->fd, (const uint8_t *)&len, sizeof(len));

    send_all(s->fd, buf, size);

}

static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)

{

    NetSocketState *s = opaque;

    sendto(s->fd, buf, size, 0,

           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));

}

static void net_socket_send(void *opaque)

{

    NetSocketState *s = opaque;

    int size, err;

    unsigned l;

    uint8_t buf1[4096];

    const uint8_t *buf;

    size = recv(s->fd, buf1, sizeof(buf1), 0);

    if (size < 0) {

        err = socket_error();

        if (err != EWOULDBLOCK)

            goto eoc;

    } else if (size == 0) {

        /* end of connection */

    eoc:

        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);

        closesocket(s->fd);

        return;

    }

    buf = buf1;

    while (size > 0) {

        /* reassemble a packet from the network */

        switch(s->state) {

        case 0:

            l = 4 - s->index;

            if (l > size)

                l = size;

            memcpy(s->buf + s->index, buf, l);

            buf += l;

            size -= l;

            s->index += l;

            if (s->index == 4) {

                /* got length */

                s->packet_len = ntohl(*(uint32_t *)s->buf);

                s->index = 0;

                s->state = 1;

            }

            break;

        case 1:

            l = s->packet_len - s->index;

            if (l > size)

                l = size;

            if (s->index + l <= sizeof(s->buf)) {

                memcpy(s->buf + s->index, buf, l);

            } else {

                fprintf(stderr, "serious error: oversized packet received,"

                    "connection terminated.\n");

                s->state = 0;

                goto eoc;

            }

            s->index += l;

            buf += l;

            size -= l;

            if (s->index >= s->packet_len) {

                qemu_send_packet(s->vc, s->buf, s->packet_len);

                s->index = 0;

                s->state = 0;

            }

            break;

        }

    }

}

static void net_socket_send_dgram(void *opaque)

{

    NetSocketState *s = opaque;

    int size;

    size = recv(s->fd, s->buf, sizeof(s->buf), 0);

    if (size < 0)

        return;

    if (size == 0) {

        /* end of connection */

        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);

        return;

    }

    qemu_send_packet(s->vc, s->buf, size);

}

static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)

{

    struct ip_mreq imr;

    int fd;