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 CONFIG_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 CONFIG_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

#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"

#include "slirp/libslirp.h"

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;

}

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,

                                      NetCanReceive *can_receive,

                                      NetReceive *receive,

                                      NetReceiveIOV *receive_iov,

                                      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->can_receive = can_receive;

    vc->receive = receive;

    vc->receive_iov = receive_iov;

    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;

}

static VLANClientState *

qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,

                              const char *client_str)

{

    VLANState *vlan;

    VLANClientState *vc;

    vlan = qemu_find_vlan(vlan_id, 0);

    if (!vlan) {

        monitor_printf(mon, "unknown VLAN %d\n", vlan_id);

        return NULL;

    }

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

        if (!strcmp(vc->name, client_str)) {

            break;

        }

    }

    if (!vc) {

        monitor_printf(mon, "can't find device %s on VLAN %d\n",

                       client_str, vlan_id);

    }

    return vc;

}

int qemu_can_send_packet(VLANClientState *sender)

{

    VLANState *vlan = sender->vlan;

    VLANClientState *vc;

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

        if (vc == sender) {

            continue;

        }

        /* no can_receive() handler, they can always receive */

        if (!vc->can_receive || vc->can_receive(vc)) {

            return 1;

        }

    }

    return 0;

}

static int

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

{

    VLANClientState *vc;

    int ret = -1;

    sender->vlan->delivering = 1;

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

        ssize_t len;

        if (vc == sender) {

            continue;

        }

        if (vc->link_down) {

            ret = size;

            continue;

        }

        len = vc->receive(vc, buf, size);

        ret = (ret >= 0) ? ret : len;

    }

    sender->vlan->delivering = 0;

    return ret;

}

void qemu_purge_queued_packets(VLANClientState *vc)

{

    VLANPacket *packet, *next;

    TAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) {

        if (packet->sender == vc) {

            TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);

            qemu_free(packet);

        }

    }

}

void qemu_flush_queued_packets(VLANClientState *vc)

{

    while (!TAILQ_EMPTY(&vc->vlan->send_queue)) {

        VLANPacket *packet;

        int ret;

        packet = TAILQ_FIRST(&vc->vlan->send_queue);

        TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);

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

        if (ret == 0 && packet->sent_cb != NULL) {

            TAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry);

            break;

        }

        if (packet->sent_cb)

            packet->sent_cb(packet->sender, ret);

        qemu_free(packet);

    }

}

static void qemu_enqueue_packet(VLANClientState *sender,

                                const uint8_t *buf, int size,

                                NetPacketSent *sent_cb)

{

    VLANPacket *packet;

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

    packet->sender = sender;

    packet->size = size;

    packet->sent_cb = sent_cb;

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

    TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);

}

ssize_t qemu_send_packet_async(VLANClientState *sender,

                               const uint8_t *buf, int size,

                               NetPacketSent *sent_cb)

{

    int ret;

    if (sender->link_down) {

        return size;

    }

#ifdef DEBUG_NET

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

    hex_dump(stdout, buf, size);

#endif

    if (sender->vlan->delivering) {

        qemu_enqueue_packet(sender, buf, size, NULL);

        return size;

    }

    ret = qemu_deliver_packet(sender, buf, size);

    if (ret == 0 && sent_cb != NULL) {

        qemu_enqueue_packet(sender, buf, size, sent_cb);

        return 0;

    }

    qemu_flush_queued_packets(sender);

    return ret;

}

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

{

    qemu_send_packet_async(vc, buf, size, NULL);

}

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;

    }

    return vc->receive(vc, buffer, 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;

}

static int qemu_deliver_packet_iov(VLANClientState *sender,

                                   const struct iovec *iov, int iovcnt)

{

    VLANClientState *vc;

    int ret = -1;

    sender->vlan->delivering = 1;

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

        ssize_t len;

        if (vc == sender) {

            continue;

        }

        if (vc->link_down) {

            ret = calc_iov_length(iov, iovcnt);

            continue;

        }

        if (vc->receive_iov) {

            len = vc->receive_iov(vc, iov, iovcnt);

        } else {

            len = vc_sendv_compat(vc, iov, iovcnt);

        }

        ret = (ret >= 0) ? ret : len;

    }

    sender->vlan->delivering = 0;

    return ret;

}

static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender,

                                       const struct iovec *iov, int iovcnt,

                                       NetPacketSent *sent_cb)

{

    VLANPacket *packet;

    size_t max_len = 0;

    int i;

    max_len = calc_iov_length(iov, iovcnt);

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

    packet->sender = sender;

    packet->sent_cb = sent_cb;

    packet->size = 0;

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

        size_t len = iov[i].iov_len;

        memcpy(packet->data + packet->size, iov[i].iov_base, len);

        packet->size += len;

    }

    TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);

    return packet->size;

}

ssize_t qemu_sendv_packet_async(VLANClientState *sender,

                                const struct iovec *iov, int iovcnt,

                                NetPacketSent *sent_cb)

{

    int ret;

    if (sender->link_down) {

        return calc_iov_length(iov, iovcnt);

    }

    if (sender->vlan->delivering) {

        return qemu_enqueue_packet_iov(sender, iov, iovcnt, NULL);

    }

    ret = qemu_deliver_packet_iov(sender, iov, iovcnt);

    if (ret == 0 && sent_cb != NULL) {

        qemu_enqueue_packet_iov(sender, iov, iovcnt, sent_cb);

        return 0;

    }

    qemu_flush_queued_packets(sender);

    return ret;

}

ssize_t

qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)

{

    return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);

}

static void config_error(Monitor *mon, const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    if (mon) {

        monitor_vprintf(mon, fmt, ap);

    } else {

        fprintf(stderr, "qemu: ");

        vfprintf(stderr, fmt, ap);

        exit(1);

    }

    va_end(ap);

}

#if defined(CONFIG_SLIRP)

/* slirp network adapter */

#define SLIRP_CFG_HOSTFWD 1

#define SLIRP_CFG_LEGACY  2

struct slirp_config_str {

    struct slirp_config_str *next;

    int flags;

    char str[1024];

    int legacy_format;

};

typedef struct SlirpState {

    TAILQ_ENTRY(SlirpState) entry;

    VLANClientState *vc;

    Slirp *slirp;

#ifndef _WIN32

    char smb_dir[128];

#endif

} SlirpState;

static struct slirp_config_str *slirp_configs;

const char *legacy_tftp_prefix;

const char *legacy_bootp_filename;

static TAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =

    TAILQ_HEAD_INITIALIZER(slirp_stacks);

static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str,

                          int legacy_format);

static void slirp_guestfwd(SlirpState *s, Monitor *mon, const char *config_str,

                           int legacy_format);

#ifndef _WIN32

static const char *legacy_smb_export;

static void slirp_smb(SlirpState *s, Monitor *mon, const char *exported_dir,

                      struct in_addr vserver_addr);

static void slirp_smb_cleanup(SlirpState *s);

#else

static inline void slirp_smb_cleanup(SlirpState *s) { }

#endif

int slirp_can_output(void *opaque)

{

    SlirpState *s = opaque;

    return qemu_can_send_packet(s->vc);

}

void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)

{

    SlirpState *s = opaque;

#ifdef DEBUG_SLIRP

    printf("slirp output:\n");

    hex_dump(stdout, pkt, pkt_len);

#endif

    qemu_send_packet(s->vc, pkt, pkt_len);

}

static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)

{

    SlirpState *s = vc->opaque;

#ifdef DEBUG_SLIRP

    printf("slirp input:\n");

    hex_dump(stdout, buf, size);

#endif

    slirp_input(s->slirp, buf, size);

    return size;

}

static void net_slirp_cleanup(VLANClientState *vc)

{

    SlirpState *s = vc->opaque;

    slirp_cleanup(s->slirp);

    slirp_smb_cleanup(s);

    TAILQ_REMOVE(&slirp_stacks, s, entry);

    qemu_free(s);

}

static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model,

                          const char *name, int restricted,

                          const char *vnetwork, const char *vhost,

                          const char *vhostname, const char *tftp_export,

                          const char *bootfile, const char *vdhcp_start,

                          const char *vnameserver, const char *smb_export,

                          const char *vsmbserver)

{

    /* default settings according to historic slirp */

    struct in_addr net  = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */

    struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */

    struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */

    struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */

    struct in_addr dns  = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */

#ifndef _WIN32

    struct in_addr smbsrv = { .s_addr = 0 };

#endif

    SlirpState *s;

    char buf[20];

    uint32_t addr;

    int shift;

    char *end;

    if (!tftp_export) {

        tftp_export = legacy_tftp_prefix;

    }

    if (!bootfile) {

        bootfile = legacy_bootp_filename;

    }

    if (vnetwork) {

        if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {

            if (!inet_aton(vnetwork, &net)) {

                return -1;

            }

            addr = ntohl(net.s_addr);

            if (!(addr & 0x80000000)) {

                mask.s_addr = htonl(0xff000000); /* class A */

            } else if ((addr & 0xfff00000) == 0xac100000) {

                mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */

            } else if ((addr & 0xc0000000) == 0x80000000) {

                mask.s_addr = htonl(0xffff0000); /* class B */

            } else if ((addr & 0xffff0000) == 0xc0a80000) {

                mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */

            } else if ((addr & 0xffff0000) == 0xc6120000) {

                mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */

            } else if ((addr & 0xe0000000) == 0xe0000000) {

                mask.s_addr = htonl(0xffffff00); /* class C */

            } else {

                mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */

            }

        } else {

            if (!inet_aton(buf, &net)) {

                return -1;

            }

            shift = strtol(vnetwork, &end, 10);

            if (*end != '\0') {

                if (!inet_aton(vnetwork, &mask)) {

                    return -1;

                }

            } else if (shift < 4 || shift > 32) {

                return -1;

            } else {

                mask.s_addr = htonl(0xffffffff << (32 - shift));

            }

        }

        net.s_addr &= mask.s_addr;

        host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);

        dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);

        dns.s_addr  = net.s_addr | (htonl(0x0203) & ~mask.s_addr);

    }

    if (vhost && !inet_aton(vhost, &host)) {

        return -1;

    }

    if ((host.s_addr & mask.s_addr) != net.s_addr) {

        return -1;

    }

    if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {

        return -1;

    }

    if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||

        dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {

        return -1;

    }

    if (vnameserver && !inet_aton(vnameserver, &dns)) {

        return -1;

    }

    if ((dns.s_addr & mask.s_addr) != net.s_addr ||

        dns.s_addr == host.s_addr) {

        return -1;

    }

#ifndef _WIN32

    if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {

        return -1;

    }

#endif

    s = qemu_mallocz(sizeof(SlirpState));

    s->slirp = slirp_init(restricted, net, mask, host, vhostname,

                          tftp_export, bootfile, dhcp, dns, s);

    TAILQ_INSERT_TAIL(&slirp_stacks, s, entry);

    while (slirp_configs) {

        struct slirp_config_str *config = slirp_configs;

        if (config->flags & SLIRP_CFG_HOSTFWD) {

            slirp_hostfwd(s, mon, config->str,

                          config->flags & SLIRP_CFG_LEGACY);

        } else {

            slirp_guestfwd(s, mon, config->str,

                           config->flags & SLIRP_CFG_LEGACY);

        }

        slirp_configs = config->next;

        qemu_free(config);

    }

#ifndef _WIN32

    if (!smb_export) {

        smb_export = legacy_smb_export;

    }

    if (smb_export) {

        slirp_smb(s, mon, smb_export, smbsrv);

    }

#endif

    s->vc = qemu_new_vlan_client(vlan, model, name, NULL, slirp_receive, NULL,

                                 net_slirp_cleanup, s);

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

             "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');

    return 0;

}

static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,

                                const char *stack)

{

    VLANClientState *vc;

    if (vlan) {

        vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);

        if (!vc) {

            return NULL;

        }

        if (strcmp(vc->model, "user")) {