linux模块虚拟网络接口

static int e1000_open(struct net_device *netdev)
{
	return 0;
}

static int e1000_close(struct net_device *netdev)
{
	return 0;
}

static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
				    struct net_device *netdev)
{
	if (unlikely(skb->len <= 0)) {
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

	struct ethhdr *ehdr = (struct ethhdr *)skb->data;
	if (!memcmp(ehdr->h_source, ed0_mac, sizeof(ed0_mac)))
	{
		if (NULL != skb)
		{
			dev_kfree_skb_any(skb);

		}
		return NETDEV_TX_OK;
	}

	if (is_broadcast_ether_addr(ehdr->h_dest))
	{

		hlist_for_each_skb_tunnel_data(pdata_tunnel_assemble_fun, skb);
	}
	else
	{
		STA_NODE_T *node = hlist_find_by_stamac(ehdr->h_dest);
		if (NULL != node)
		{
#if 1
			int i;
			for (i = 0; i < 32; i+=8)
			{
				printk("e1000_xmit_frame len %d %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",skb->len,
					skb->data[0+i], skb->data[1+i], skb->data[2+i], skb->data[3+i], 
					skb->data[4+i], skb->data[5+i], skb->data[6+i], skb->data[7+i]);
			}
#endif

#if 0
			skb_push(skb, sizeof(struct ethhdr));
			int i;
			for (i = 0; i < 32; i+=8)
			{
				printk("e1000_xmit_frame len %d %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",skb->len,
					skb->data[0+i], skb->data[1+i], skb->data[2+i], skb->data[3+i], 
					skb->data[4+i], skb->data[5+i], skb->data[6+i], skb->data[7+i]);
			}
#endif
			data_tunnel_protocol_assemble(skb, node);
		}
		else
		{
			printk("wjm_%d\n", __LINE__);
			dev_kfree_skb_any(skb);
		}
	}

	return NETDEV_TX_OK;
}

static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);

	/* only return the current stats */
	return &adapter->net_stats;
}

static void e1000_set_rx_mode(struct net_device *netdev)
{}

static int e1000_set_mac(struct net_device *netdev, void *p)
{
	return 0;
}

static void e1000_tx_timeout(struct net_device *netdev)
{

}

static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
{
	return 0;
}

static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
{
	switch (cmd) {

	}

	return 0;
}

int eth_validate_addr(struct net_device *dev)
{
	return 0;
}

static void e1000_vlan_rx_register(struct net_device *netdev,
				   struct vlan_group *grp)
{
	return;
}

static void e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
{
	return;
}

static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
{
	return;
}
static const struct net_device_ops virtul_netdev_ops = {
	.ndo_open		= e1000_open,
	.ndo_stop		= e1000_close,
	.ndo_start_xmit		= e1000_xmit_frame,
	.ndo_get_stats		= e1000_get_stats,
	.ndo_set_rx_mode	= e1000_set_rx_mode,
	.ndo_set_mac_address	= e1000_set_mac,
	.ndo_tx_timeout 	= e1000_tx_timeout,
	.ndo_change_mtu		= e1000_change_mtu,
	.ndo_do_ioctl		= e1000_ioctl,
	.ndo_validate_addr	= eth_validate_addr,

	.ndo_vlan_rx_register	= e1000_vlan_rx_register,
	.ndo_vlan_rx_add_vid	= e1000_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= e1000_vlan_rx_kill_vid,
};

struct net_device *netdev;
static unsigned int virtul_interface_create(void)
{

	struct e1000_adapter *adapter;
	int ret = 0;
	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
	if (NULL != netdev)
	{
		memset(netdev->dev_addr, 0, sizeof(netdev->dev_addr));
		memcpy(netdev->dev_addr, ed0_mac, sizeof(ed0_mac));

		//netdev->dev_addr[5] = 0x01;
		netdev->netdev_ops = &virtul_netdev_ops;
		netdev->watchdog_timeo = 5 * HZ;

		adapter = netdev_priv(netdev);
		adapter->netdev = netdev;
		strcpy(netdev->name, ED0_NAME);
		ret = register_netdev(netdev);
		if (ret)
		{
			kfree(netdev);
			printk("virtul: device registration failed %d\n", ret);
		}
	}
	else
	{
		printk("alloc_etherdev failed\n");
	}


}