Archipelago » qemu

    d->rxbuf_min_shift = 1;

    memset(&d->tx, 0, sizeof d->tx);

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

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

    nic_reset(s);

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

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

	eth->ethregs = cpu_register_io_memory(0, eth_read, eth_write, eth);

	cpu_register_physical_memory (base, 0x5c, eth->ethregs);

				       eth_receive, eth_can_receive, eth);

	return dma;

                                       mcf_fec_writefn, s);

    cpu_register_physical_memory(base, 0x400, iomemtype);

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

}

    s->irq = irq;

    s->nd = nd;

    if (nd && nd->vlan) {

    } else {

        s->vc = NULL;

    }

    if (!s)

        return;

    s->irq = irq;

    iomemtype = cpu_register_io_memory(0, mv88w8618_eth_readfn,

                                       mv88w8618_eth_writefn, s);

    cpu_register_physical_memory(base, MP_ETH_SIZE, iomemtype);

    ne2000_reset(s);

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

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

    s->pci_dev = (PCIDevice *)d;

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

    ne2000_reset(s);

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

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

    d->nd = nd;

    if (nd && nd->vlan) {

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

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

    s->pci_dev = (PCIDevice *)d;

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

    rtl8139_reset(s);

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

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

    smc91c111_reset(s);

    /* ??? Save/restore.  */

}

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

    if (nd->vlan)

    stellaris_enet_reset(s);

    register_savevm("stellaris_enet", -1, 1,

    pstrcpy(s->dev.devname, sizeof(s->dev.devname),

                    "QEMU USB Network Interface");

                    usbnet_receive, usbnet_can_receive, s);

    snprintf(s->usbstring_mac, sizeof(s->usbstring_mac),

    n->rx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_rx);

    n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx);

    memcpy(n->mac, nd->macaddr, 6);

    n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);

    n->tx_timer_active = 0;

#endif

VLANClientState *qemu_new_vlan_client(VLANState *vlan,

                                      IOReadHandler *fd_read,

                                      IOCanRWHandler *fd_can_read,

                                      void *opaque)

    vc = qemu_mallocz(sizeof(VLANClientState));

    if (!vc)

        return NULL;

    vc->fd_read = fd_read;

    vc->fd_can_read = fd_can_read;

    vc->opaque = opaque;

    while (*pvc != NULL)

        if (*pvc == vc) {

            *pvc = vc->next;

            free(vc);

            break;

        } else

    slirp_input(buf, size);

}

{

    if (!slirp_inited) {

        slirp_inited = 1;

        slirp_init();

    }

                                    slirp_receive, NULL, NULL);

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

    return 0;

/* fd support */

{

    TAPState *s;

    if (!s)

        return NULL;

    s->fd = fd;

#ifdef HAVE_IOVEC

    s->vc->fd_readv = tap_receive_iov;

#endif

    return 0;

}

                        const char *setup_script, const char *down_script)

{

    TAPState *s;

	if (launch_script(setup_script, ifname, fd))

	    return -1;

    }

    if (!s)

        return -1;

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

    }

}

{

    VDEState *s;

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

        free(s);

        return -1;

    }

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

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

             sock, vde_datafd(s->vde));

typedef struct NetSocketListenState {

    VLANState *vlan;

    int fd;

} NetSocketListenState;

    return -1;

}

{

    struct sockaddr_in saddr;

    int newfd;

        return NULL;

    s->fd = fd;

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

    /* mcast: save bound address as dst */

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

}

{

    NetSocketState *s;

    s = qemu_mallocz(sizeof(NetSocketState));

    if (!s)

        return NULL;

    s->fd = fd;

                                 net_socket_receive, NULL, s);

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

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

    return s;

}

{

    int so_type=-1, optlen=sizeof(so_type);

    }

    switch(so_type) {

    case SOCK_DGRAM:

    case SOCK_STREAM:

    default:

        /* who knows ... this could be a eg. a pty, do warn and continue as stream */

        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);

    }

    return NULL;

}

            break;

        }

    }

    if (!s1) {

        closesocket(fd);

    } else {

    }

}

{

    NetSocketListenState *s;

    int fd, val, ret;

        return -1;

    }

    s->vlan = vlan;

    s->fd = fd;

    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);

    return 0;

}

{

    NetSocketState *s;

    int fd, connected, ret, err;

            break;

        }

    }

    if (!s)

        return -1;

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

    return 0;

}

{

    NetSocketState *s;

    int fd;

    if (fd < 0)

	return -1;

    if (!s)

        return -1;

            pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);

        }

        vlan->nb_host_devs++;

    } else

#endif

#ifdef _WIN32

            return -1;

        }

        vlan->nb_host_devs++;

    } else

#elif defined (_AIX)

#else

            fd = strtol(buf, NULL, 0);

            fcntl(fd, F_SETFL, O_NONBLOCK);

            ret = -1;

                ret = 0;

        } else {

            if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {

            if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {

                pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);

            }

        }

    } else

#endif

            int fd;

            fd = strtol(buf, NULL, 0);

            ret = -1;

                ret = 0;

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

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

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

        } else {

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

            return -1;

	} else {

	    vde_mode = 0700;

	}

    } else

#endif

    {

    void *opaque;

    struct VLANClientState *next;

    struct VLANState *vlan;

    char info_str[256];

};

VLANState *qemu_find_vlan(int id);

VLANClientState *qemu_new_vlan_client(VLANState *vlan,

                                      IOReadHandler *fd_read,

                                      IOCanRWHandler *fd_can_read,

                                      void *opaque);

#endif

/* TAP win32 */

/* SLIRP */

void do_info_slirp(void);

    }

}

{

    TAPState *s;

        return -1;

    }

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

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