int netfront_tap_open(char *nodename) {
struct netfront_dev *dev;
dev = init_netfront(nodename, NETIF_SELECT_RX, NULL, NULL);
if (!dev) {
printk("TAP open failed\n");
errno = EIO;
return -1;
}
dev->fd = alloc_fd(FTYPE_TAP);
printk("tap_open(%s) -> %d\n", nodename, dev->fd);
files[dev->fd].tap.dev = dev;
return dev->fd;
}
void start_networking(void)
{
struct ip_addr ipaddr = { htonl(IF_IPADDR) };
struct ip_addr netmask = { htonl(IF_NETMASK) };
struct ip_addr gw = { 0 };
char *ip = NULL;
#ifdef CONFIG_PRINT
tprintk("Waiting for network.\n");
#endif
dev = init_netfront(NULL, NULL, rawmac, &ip);
if (ip) {
ipaddr.addr = inet_addr(ip);
if (IN_CLASSA(ntohl(ipaddr.addr)))
netmask.addr = htonl(IN_CLASSA_NET);
else if (IN_CLASSB(ntohl(ipaddr.addr)))
netmask.addr = htonl(IN_CLASSB_NET);
else if (IN_CLASSC(ntohl(ipaddr.addr)))
netmask.addr = htonl(IN_CLASSC_NET);
else
tprintk("Strange IP %s, leaving netmask to 0.\n", ip);
}
tprintk("IP %x netmask %x gateway %x.\n",
ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr));
#ifdef CONFIG_PRINT
tprintk("TCP/IP bringup begins.\n");
#endif
netif = xmalloc(struct netif);
tcpip_init(tcpip_bringup_finished, netif);
netif_add(netif, &ipaddr, &netmask, &gw, rawmac,
netif_netfront_init, ip_input);
netif_set_default(netif);
netif_set_up(netif);
down(&tcpip_is_up);
#ifdef CONFIG_FRONT
tprintk("Network is ready.\n");
#endif
}
int
minios_probe (struct nic *nic)
{
char *ip;
if (net_dev)
return 1;
/* Clear the ARP table. */
grub_memset ((char *) arptable, 0,
MAX_ARP * sizeof (struct arptable_t));
net_dev = init_netfront(NULL, (void*) -1, nic->node_addr, &ip);
if (!net_dev)
return 0;
return 1;
}
void resume_networking(int cancelled)
{
//struct netif *netif;
struct ip_addr ipaddr = { htonl(IF_IPADDR) };
struct ip_addr netmask = { htonl(IF_NETMASK) };
struct ip_addr gw = { htonl(0xc0a87a01) };
char *ip = NULL;
#ifdef CONFIG_PRINT
tprintk("Waiting for network.\n");
#endif
dev = init_netfront(NULL, NULL, rawmac, &ip);
if(!cancelled){
if (ip) {
ipaddr.addr = inet_addr(ip);
if (IN_CLASSA(ntohl(ipaddr.addr)))
netmask.addr = htonl(IN_CLASSA_NET);
else if (IN_CLASSB(ntohl(ipaddr.addr)))
netmask.addr = htonl(IN_CLASSB_NET);
else if (IN_CLASSC(ntohl(ipaddr.addr)))
netmask.addr = htonl(IN_CLASSC_NET);
else
tprintk("Strange IP %s, leaving netmask to 0.\n", ip);
}
tprintk("IP %x netmask %x gateway %x.\n",
ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr));
netif = xmalloc(struct netif);
netif_add(netif, &ipaddr, &netmask, &gw, rawmac,
netif_netfront_init, ip_input);
netif_set_default(netif);
netif_set_up(netif);
down(&tcpip_is_up);
}
#ifdef CONFIG_SUSPEND
tprintk("TCP/IP bringup begins.\n");
#endif
}
int
VIFHYPER_CREATE(int devnum, struct virtif_sc *vif_sc, uint8_t *enaddr,
struct virtif_user **viup)
{
struct virtif_user *viu = NULL;
int rv, nlocks;
rumpkern_unsched(&nlocks, NULL);
viu = malloc(sizeof(*viu));
if (viu == NULL) {
rv = ENOMEM;
goto out;
}
memset(viu, 0, sizeof(*viu));
viu->viu_vifsc = vif_sc;
viu->viu_dev = init_netfront(NULL, myrecv, enaddr, NULL, viu);
if (!viu->viu_dev) {
rv = EINVAL; /* ? */
free(viu);
goto out;
}
if (create_thread("xenifp", pusher, viu) == NULL) {
printk("fatal thread creation failure\n"); /* XXX */
do_exit();
}
rv = 0;
out:
rumpkern_sched(nlocks, NULL);
*viup = viu;
return rv;
}
static void netfront_thread(void *p)
{
net_dev = init_netfront(NULL, NULL, NULL, NULL);
}
void start_networking(void)
{
struct netfront_dev *dev;
struct netif *_netif;
struct netif *niret;
struct netfrontif *nfi;
struct ip_addr ip;
struct ip_addr mask;
struct ip_addr gw;
char *ifip = NULL;
ASSERT(netif == NULL);
IP4_ADDR(&ip, 192, 168, 1, 128);
IP4_ADDR(&mask, 255, 255, 255, 0);
IP4_ADDR(&gw, 0, 0, 0, 0);
tprintk("Starting networking\n");
/* init netfront */
dev = init_netfront(NULL, NULL, NULL, &ifip);
if (!dev) {
tprintk("Could not init netfront\n");
goto err_out;
}
if (ifip) {
tprintk("Got IP address %s\n", ifip);
ip.addr = inet_addr(ifip);
if (IN_CLASSA(ntohl(ip.addr))) {
tprintk("Use class A netmask (255.0.0.0)\n");
mask.addr = htonl(IN_CLASSA_NET);
} else if (IN_CLASSB(ntohl(ip.addr))) {
mask.addr = htonl(IN_CLASSB_NET);
tprintk("Use class B netmask (255.255.0.0)\n");
} else if (IN_CLASSC(ntohl(ip.addr))) {
mask.addr = htonl(IN_CLASSC_NET);
tprintk("Use class C netmask (255.255.255.0)\n");
} else {
tprintk("Could not auto-detect IP class for %s,"
"use class C netmask (255.255.255.0)\n", ifip);
}
} else {
tprintk("Set IP to 192.168.1.128, use class A netmask (255.0.0.0)\n");
}
/* allocate netif */
_netif = mem_calloc(1, sizeof(*_netif));
if (!_netif) {
tprintk("Could not allocate netif\n");
goto err_shutdown_netfront;
}
/* allocate netif state data */
nfi = mem_calloc(1, sizeof(*nfi));
if (!nfi) {
tprintk("Could not allocate netfrontif\n");
goto err_free_netif;
}
nfi->dev = dev;
/* init lwIP */
#ifdef CONFIG_LWIP_NOTHREADS
lwip_init();
niret = netif_add(_netif, &ip, &mask, &gw, nfi,
netfrontif_init, ethernet_input);
#else
tcpip_init(NULL, NULL);
niret = netif_add(_netif, &ip, &mask, &gw, nfi,
netfrontif_init, tcpip_input);
#endif
if (!niret) {
tprintk("Could not initialize lwIP\n");
goto err_free_nfi;
}
netif_set_default(_netif);
netif_set_up(_netif);
netif = _netif;
tprintk("Networking started\n");
return;
err_free_nfi:
mem_free(nfi);
err_free_netif:
mem_free(_netif);
err_shutdown_netfront:
shutdown_netfront(dev);
err_out:
return;
}
/**
* Initializes and sets up a netfront interface for lwIP.
* This function should be passed as a parameter to netfrontif_add().
*
* @param netif
* the lwip network interface structure for this netfrontif
* @return
* ERR_OK if the interface was successfully initialized;
* An err_t value otherwise
*/
err_t netfrontif_init(struct netif *netif)
{
struct netfrontif *nfi;
static uint8_t netfrontif_id = 0;
LWIP_ASSERT("netif != NULL", (netif != NULL));
if (!(netif->state)) {
nfi = mem_calloc(1, sizeof(*nfi));
if (!nfi) {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: "
"Could not allocate \n"));
goto err_out;
}
netif->state = nfi;
nfi->_state_is_private = 1;
nfi->_dev_is_private = 1;
nfi->_hwaddr_is_private = 1;
} else {
nfi = netif->state;
nfi->_state_is_private = 0;
nfi->_dev_is_private = !(nfi->dev);
nfi->_hwaddr_is_private = eth_addr_cmp(&nfi->hwaddr, ðzero);
}
/* Netfront */
if (nfi->_dev_is_private) {
/* user did not provide an opened netfront, we need to do it here */
if (!nfi->_state_is_private) {
/* use vif_id to open an specific NIC interface */
/* Note: netfront will duplicate the passed nodename */
char nodename[128];
snprintf(nodename, sizeof(nodename), "device/vif/%u", nfi->vif_id);
nfi->dev = init_netfront(nodename, NULL, NULL, NULL);
} else {
/* open the next available net interface */
nfi->dev = init_netfront(NULL, NULL, NULL, NULL);
}
if (!nfi->dev) {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: "
"Could not init netfront\n"));
goto err_free_nfi;
}
}
netfront_set_rx_pbuf_handler(nfi->dev, netfrontif_rx_handler, netif);
/* Interface identifier */
netif->name[0] = NETFRONTIF_NPREFIX;
netif->name[1] = '0' + netfrontif_id;
netfrontif_id++;
/* We directly use etharp_output() here to save a function call.
* Instead, there could be function declared that calls etharp_output()
* only if there is a link is available... */
netif->output = etharp_output;
netif->linkoutput = netfrontif_transmit;
#if LWIP_NETIF_REMOVE_CALLBACK
netif->remove_callback = netfrontif_exit;
#endif /* CONFIG_NETIF_REMOVE_CALLBACK */
/* Hardware address */
if (nfi->_hwaddr_is_private) {
if (!netfront_get_hwaddr(nfi->dev, &nfi->hwaddr)) {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: "
"Could not retrieve hardware address\n",
netif->name[0], netif->name[1]));
goto err_shutdown_netfront;
}
} else {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: "
"Overwriting hardware address\n",
netif->name[0], netif->name[1]));
}
SMEMCPY(&netif->hwaddr, &nfi->hwaddr, ETHARP_HWADDR_LEN);
netif->hwaddr_len = ETHARP_HWADDR_LEN;
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: hardware address: "
"%02x:%02x:%02x:%02x:%02x:%02x\n",
netif->name[0], netif->name[1],
netif->hwaddr[0],
netif->hwaddr[1],
netif->hwaddr[2],
netif->hwaddr[3],
netif->hwaddr[4],
netif->hwaddr[5]));
/* Initialize the snmp variables and counters inside the struct netif.
* The last argument is the link speed, in units of bits per second. */
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, NETFRONTIF_SPEED);
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: Link speed: %llu bps\n",
netif->name[0], netif->name[1], NETFRONTIF_SPEED));
/* Device capabilities */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
/* Maximum transfer unit */
netif->mtu = NETFRONTIF_MTU;
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: MTU: %u\n",
netif->name[0], netif->name[1], netif->mtu));
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
if (!netif->hostname)
netif->hostname = NULL;
#endif /* LWIP_NETIF_HOSTNAME */
#ifndef CONFIG_LWIP_NOTHREADS
nfi->_thread_exit = 0;
nfi->_thread_name[0] = netif->name[0];
nfi->_thread_name[1] = netif->name[1];
nfi->_thread_name[2] = '-';
nfi->_thread_name[3] = 'r';
nfi->_thread_name[4] = 'x';
nfi->_thread_name[5] = '\0';
create_thread(nfi->_thread_name, netfrontif_thread, netif);
#endif /* CONFIG_LWIP_NOTHREADS */
return ERR_OK;
err_shutdown_netfront:
if (nfi->_dev_is_private) {
shutdown_netfront(nfi->dev);
nfi->dev = NULL;
}
err_free_nfi:
if (nfi->_state_is_private) {
mem_free(nfi);
netif->state = NULL;
}
err_out:
return ERR_IF;
}
