Archipelago » qemu

static void gdb_read(void *opaque)

    int i, size;

    uint8_t buf[4096];

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

    if (size < 0)

        return;

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

static void gdb_accept(void *opaque)

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

    gdb_accept (NULL);

    qemu_set_fd_handler(gdbserver_fd, gdb_accept, NULL, NULL);

    VLANClientState *vc;

    uint8_t macaddr[6]; /* init mac address */

    memcpy(s->phys, s->macaddr, 6);

	    qemu_send_packet(s->vc, pkt_buf, temp16);

void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr)

    memcpy(s->macaddr, nd->macaddr, 6);

    s->vc = qemu_new_vlan_client(nd->vlan, lance_receive, s);

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

             "lance macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

             s->macaddr[0],

             s->macaddr[1],

             s->macaddr[2],

             s->macaddr[3],

             s->macaddr[4],

             s->macaddr[5]);

    uint8_t rxcr;

    VLANClientState *vc;

    uint8_t macaddr[6];

    memcpy(s->mem, s->macaddr, 6);

#define POLYNOMIAL 0x04c11db6

/* From FreeBSD */

/* XXX: optimize */

static int compute_mcast_idx(const uint8_t *ep)

{

    uint32_t crc;

    int carry, i, j;

    uint8_t b;

    crc = 0xffffffff;

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

        b = *ep++;

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

            carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);

            crc <<= 1;

            b >>= 1;

            if (carry)

                crc = ((crc ^ POLYNOMIAL) | carry);

        }

    }

    return (crc >> 26);

}

    int total_len, next, avail, len, index, mcast_idx;

    static const uint8_t broadcast_macaddr[6] = 

        { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

    if (!ne2000_can_receive(s))

        return;

    /* XXX: check this */

    if (s->rxcr & 0x10) {

        /* promiscuous: receive all */

    } else {

        if (!memcmp(buf,  broadcast_macaddr, 6)) {

            /* broadcast address */

            if (!(s->rxcr & 0x04))

                return;

        } else if (buf[0] & 0x01) {

            /* multicast */

            if (!(s->rxcr & 0x08))

                return;

            mcast_idx = compute_mcast_idx(buf);

            if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))))

                return;

        } else if (s->mem[0] == buf[0] &&

                   s->mem[2] == buf[1] &&                   

                   s->mem[4] == buf[2] &&            

                   s->mem[6] == buf[3] &&            

                   s->mem[8] == buf[4] &&            

                   s->mem[10] == buf[5]) {

            /* match */

        } else {

            return;

        }

    }

                    qemu_send_packet(s->vc, s->mem + index, s->tcnt);

        case EN0_RXCR:

            s->rxcr = val;

            break;

void isa_ne2000_init(int base, int irq, NICInfo *nd)

    memcpy(s->macaddr, nd->macaddr, 6);

    s->vc = qemu_new_vlan_client(nd->vlan, ne2000_receive, s);

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

             "ne2000 macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

             s->macaddr[0],

             s->macaddr[1],

             s->macaddr[2],

             s->macaddr[3],

             s->macaddr[4],

             s->macaddr[5]);

void pci_ne2000_init(PCIBus *bus, NICInfo *nd)

    memcpy(s->macaddr, nd->macaddr, 6);

    s->vc = qemu_new_vlan_client(nd->vlan, ne2000_receive, s);

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

             "ne2000 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

             s->macaddr[0],

             s->macaddr[1],

             s->macaddr[2],

             s->macaddr[3],

             s->macaddr[4],

             s->macaddr[5]);

#include <netdb.h>

NICInfo nd_table[MAX_NICS];

static VLANState *first_vlan;

    int max_size;

static int fd_chr_read_poll(void *opaque)

{

    CharDriverState *chr = opaque;

    FDCharDriver *s = chr->opaque;

    s->max_size = s->fd_can_read(s->fd_opaque);

    return s->max_size;

}

static void fd_chr_read(void *opaque)

{

    CharDriverState *chr = opaque;

    FDCharDriver *s = chr->opaque;

    int size, len;

    uint8_t buf[1024];

    len = sizeof(buf);

    if (len > s->max_size)

        len = s->max_size;

    if (len == 0)

        return;

    size = read(s->fd_in, buf, len);

    if (size > 0) {

        s->fd_read(s->fd_opaque, buf, size);

    }

}

        s->fd_can_read = fd_can_read;

        s->fd_read = fd_read;

        s->fd_opaque = opaque;

            qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll, 

                                 fd_chr_read, NULL, chr);

static int stdio_read_poll(void *opaque)

static void stdio_read(void *opaque)

    int size;

    uint8_t buf[1];

    size = read(0, buf, 1);

    if (size > 0)

        stdio_received_byte(buf[0]);

            qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, NULL);

/* network device redirectors */

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

    int i;

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

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

        if (i == 5) {

            if (*p != '\0') 

                return -1;

        } else {

            if (*p != ':') 

                return -1;

            p++;

        }

    }

    return 0;

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_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 (isdigit(buf[0])) {

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

                return -1;

        } else {

#ifdef _WIN32

            return -1;

#else

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

                return - 1;

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

#endif

        }

    }

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

    if (r == p)

        return -1;

    saddr->sin_port = htons(port);

    return 0;

}

/* find or alloc a new VLAN */

VLANState *qemu_find_vlan(int id)

    VLANState **pvlan, *vlan;

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

        if (vlan->id == id)

            return vlan;

    }

    vlan = qemu_mallocz(sizeof(VLANState));

    if (!vlan)

        return NULL;

    vlan->id = id;

    vlan->next = NULL;

    pvlan = &first_vlan;

    while (*pvlan != NULL)

        pvlan = &(*pvlan)->next;

    *pvlan = vlan;

    return vlan;

VLANClientState *qemu_new_vlan_client(VLANState *vlan,

                                      IOReadHandler *fd_read, void *opaque)

    VLANClientState *vc, **pvc;

    vc = qemu_mallocz(sizeof(VLANClientState));

    if (!vc)

        return NULL;

    vc->fd_read = fd_read;

    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_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)

    VLANState *vlan = vc1->vlan;

    VLANClientState *vc;

#if 0

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

    hex_dump(stdout, buf, size);

#endif

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

        if (vc != vc1) {

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

        }

    }

static VLANClientState *slirp_vc;

    return 1;

    printf("slirp output:\n");

    qemu_send_packet(slirp_vc, pkt, pkt_len);

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

    printf("slirp input:\n");

static int net_slirp_init(VLANState *vlan)

    slirp_vc = qemu_new_vlan_client(vlan, 

                                    slirp_receive, NULL);

    snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");

typedef struct TAPState {

    VLANClientState *vc;

    int fd;

} TAPState;

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;

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

    if (size > 0) {

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

    }

}

/* fd support */

static TAPState *net_tap_fd_init(VLANState *vlan, int fd)

{

    TAPState *s;

    s = qemu_mallocz(sizeof(TAPState));

    if (!s)

        return NULL;

    s->fd = fd;

    s->vc = qemu_new_vlan_client(vlan, tap_receive, s);

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

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

    return s;

}

static int tap_open(char *ifname, int ifname_size)

static int tap_open(char *ifname, int ifname_size)

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

        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);

    else

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

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

                        const char *setup_script)

{

    TAPState *s;

    int pid, status, fd;

    char *args[3];

    char **parg;

    char ifname[128];

    if (ifname1 != NULL)

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

    else

        ifname[0] = '\0';

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

    if (fd < 0)

        return -1;

    if (!setup_script)

        setup_script = "";

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

        /* try to launch network init script */

        pid = fork();

        if (pid >= 0) {

            if (pid == 0) {

                parg = args;

                *parg++ = (char *)setup_script;

                *parg++ = 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;

            }

        }

    }

    s = net_tap_fd_init(vlan, fd);

    if (!s)

        return -1;

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

             "tap: ifname=%s setup_script=%s", ifname, setup_script);

    return 0;

}

/* network connection */

typedef struct NetSocketState {

    VLANClientState *vc;

    int fd;

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

    int index;

    int packet_len;

    uint8_t buf[4096];

} NetSocketState;

typedef struct NetSocketListenState {

    VLANState *vlan;

    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);

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

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

static void net_socket_send(void *opaque)

    NetSocketState *s = opaque;

    int l, size;

    uint8_t buf1[4096];

    const uint8_t *buf;

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

    if (size < 0) 

        return;

    if (size == 0) {

        /* end of connection */

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

        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;

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

            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_connect(void *opaque)

    NetSocketState *s = opaque;

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

}

static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd, 

                                          int is_connected)

{

    NetSocketState *s;

    s = qemu_mallocz(sizeof(NetSocketState));

    if (!s)

        return NULL;

    s->fd = fd;

    s->vc = qemu_new_vlan_client(vlan, 

                                 net_socket_receive, s);

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

             "socket: fd=%d", fd);

    if (is_connected) {

        net_socket_connect(s);

    } else {

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

    }

    return s;

}

static void net_socket_accept(void *opaque)

{

    NetSocketListenState *s = opaque;    

    NetSocketState *s1;

    struct sockaddr_in saddr;

    socklen_t len;

    int fd;

    for(;;) {

        len = sizeof(saddr);

        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);

        if (fd < 0 && errno != EINTR) {

            return;

        } else if (fd >= 0) {

            break;

    s1 = net_socket_fd_init(s->vlan, fd, 1); 

    if (!s1) {

        close(fd);

    } else {

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

                 "socket: connection from %s:%d", 

                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));

    }

}

static int net_socket_listen_init(VLANState *vlan, const char *host_str)

{

    NetSocketListenState *s;

    int fd, val, ret;

    struct sockaddr_in saddr;

    if (parse_host_port(&saddr, host_str) < 0)

        return -1;

    s = qemu_mallocz(sizeof(NetSocketListenState));

    if (!s)

        return -1;

    fd = socket(PF_INET, SOCK_STREAM, 0);

    if (fd < 0) {

        perror("socket");

        return -1;

    }

    fcntl(fd, F_SETFL, O_NONBLOCK);

    /* allow fast reuse */

    val = 1;

    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));

    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));

    if (ret < 0) {

        perror("bind");

        return -1;

    }

    ret = listen(fd, 0);

    if (ret < 0) {

        perror("listen");

        return -1;

    }

    s->vlan = vlan;

    s->fd = fd;

    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);

static int net_socket_connect_init(VLANState *vlan, const char *host_str)

    NetSocketState *s;

    int fd, connected, ret;

    struct sockaddr_in saddr;

    if (parse_host_port(&saddr, host_str) < 0)

        return -1;

    fd = socket(PF_INET, SOCK_STREAM, 0);

    if (fd < 0) {

        perror("socket");

        return -1;

    }

    fcntl(fd, F_SETFL, O_NONBLOCK);

    connected = 0;

    for(;;) {

        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));

        if (ret < 0) {

            if (errno == EINTR || errno == EAGAIN) {

            } else if (errno == EINPROGRESS) {

                break;

            } else {

                perror("connect");

                close(fd);

                return -1;

            }

        } else {

            connected = 1;

            break;

        }

    }

    s = net_socket_fd_init(vlan, fd, connected);

    if (!s)

        return -1;

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

             "socket: connect to %s:%d", 

             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));

static int get_param_value(char *buf, int buf_size,

                           const char *tag, const char *str)

{

    const char *p;

    char *q;

    char option[128];

    p = str;

    for(;;) {

        q = option;

        while (*p != '\0' && *p != '=') {

            if ((q - option) < sizeof(option) - 1)

                *q++ = *p;

            p++;

        }

        *q = '\0';

        if (*p != '=')

            break;

        p++;

        if (!strcmp(tag, option)) {

            q = buf;

            while (*p != '\0' && *p != ',') {

                if ((q - buf) < buf_size - 1)

                    *q++ = *p;

                p++;

            }

            *q = '\0';

            return q - buf;

        } else {

            while (*p != '\0' && *p != ',') {

                p++;

            }

        }

        if (*p != ',')

            break;

        p++;

    }

    return 0;

}

int net_client_init(const char *str)

{

    const char *p;

    char *q;

    char device[64];

    char buf[1024];

    int vlan_id, ret;

    VLANState *vlan;

    p = str;

    q = device;

    while (*p != '\0' && *p != ',') {

        if ((q - device) < sizeof(device) - 1)

            *q++ = *p;

        p++;

    }

    *q = '\0';

    if (*p == ',')

        p++;

    vlan_id = 0;

    if (get_param_value(buf, sizeof(buf), "vlan", p)) {

        vlan_id = strtol(buf, NULL, 0);

    }

    vlan = qemu_find_vlan(vlan_id);

    if (!vlan) {

        fprintf(stderr, "Could not create vlan %d\n", vlan_id);

        return -1;

    }

    if (!strcmp(device, "nic")) {

        NICInfo *nd;

        uint8_t *macaddr;

        if (nb_nics >= MAX_NICS) {

            fprintf(stderr, "Too Many NICs\n");

            return -1;

        }

        nd = &nd_table[nb_nics];

        macaddr = nd->macaddr;

        macaddr[0] = 0x52;

        macaddr[1] = 0x54;

        macaddr[2] = 0x00;

        macaddr[3] = 0x12;

        macaddr[4] = 0x34;

        macaddr[5] = 0x56 + nb_nics;

        if (get_param_value(buf, sizeof(buf), "macaddr", p)) {

            if (parse_macaddr(macaddr, buf) < 0) {

                fprintf(stderr, "invalid syntax for ethernet address\n");

                return -1;

            }

        }

        nd->vlan = vlan;

        nb_nics++;

        ret = 0;

    } else

    if (!strcmp(device, "none")) {

        /* does nothing. It is needed to signal that no network cards

           are wanted */

        ret = 0;

    } else

#ifdef CONFIG_SLIRP

    if (!strcmp(device, "user")) {

        ret = net_slirp_init(vlan);

    } else

#endif

#ifndef _WIN32

    if (!strcmp(device, "tap")) {

        char ifname[64];

        char setup_script[1024];

        int fd;

        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {

            fd = strtol(buf, NULL, 0);

            ret = -1;

            if (net_tap_fd_init(vlan, fd))

                ret = 0;

        } else {

            get_param_value(ifname, sizeof(ifname), "ifname", p);

            if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {

                pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);

            }

            ret = net_tap_init(vlan, ifname, setup_script);

        }

    } else

    if (!strcmp(device, "socket")) {

        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {

            int fd;

            fd = strtol(buf, NULL, 0);

            ret = -1;

            if (net_socket_fd_init(vlan, fd, 1))

                ret = 0;

        } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {

            ret = net_socket_listen_init(vlan, buf);

        } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {

            ret = net_socket_connect_init(vlan, buf);

        } else {

            fprintf(stderr, "Unknown socket options: %s\n", p);

            return -1;

        }

    } else

#endif

    {

        fprintf(stderr, "Unknown network device: %s\n", device);

        return -1;

    }

    if (ret < 0) {

        fprintf(stderr, "Could not initialize device '%s'\n", device);

    }

    return ret;

}

void do_info_network(void)

{

    VLANState *vlan;

    VLANClientState *vc;

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

        term_printf("VLAN %d devices:\n", vlan->id);

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

            term_printf("  %s\n", vc->info_str);

    }

}

    IOCanRWHandler *fd_read_poll;

    IOHandler *fd_read;

    IOHandler *fd_write;

/* XXX: fd_read_poll should be suppressed, but an API change is

   necessary in the character devices to suppress fd_can_read(). */

int qemu_set_fd_handler2(int fd, 

                         IOCanRWHandler *fd_read_poll, 

                         IOHandler *fd_read, 

                         IOHandler *fd_write, 

                         void *opaque)

    IOHandlerRecord **pioh, *ioh;

    if (!fd_read && !fd_write) {

        pioh = &first_io_handler;

        for(;;) {

            ioh = *pioh;

            if (ioh == NULL)

                break;

            if (ioh->fd == fd) {

                *pioh = ioh->next;

                break;

            }

            pioh = &ioh->next;

        }

    } else {

        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {

            if (ioh->fd == fd)

                goto found;

        }

        ioh = qemu_mallocz(sizeof(IOHandlerRecord));

        if (!ioh)

            return -1;

        ioh->next = first_io_handler;

        first_io_handler = ioh;

    found:

        ioh->fd = fd;

        ioh->fd_read_poll = fd_read_poll;

        ioh->fd_read = fd_read;

        ioh->fd_write = fd_write;

        ioh->opaque = opaque;

    }

int qemu_set_fd_handler(int fd, 

                        IOHandler *fd_read, 

                        IOHandler *fd_write, 

                        void *opaque)

    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);

            pf->events = 0;

            pf->fd = ioh->fd;

            if (ioh->fd_read &&

                (!ioh->fd_read_poll ||

                 ioh->fd_read_poll(ioh->opaque) != 0)) {

                pf->events |= POLLIN;

            }

            if (ioh->fd_write) {

                pf->events |= POLLOUT;