网卡驱动10-做一个与外界交互的虚拟网卡6(突发奇想！搞个网络鼠标！)

昨天晚上突然想到这个东西，今天花了一上午实现了！不过具体速度怎么样就不清楚了！

首先是目的！一个系统上的鼠标去控制另一个系统。通过网线连接。

方案！在一个系统上获取鼠标信息网传到另一个系统，接受信息的系统通过input机制上报。

对于网传的接受，你可以在用户层去做，我是在内核层去做的，参考我之前搞的vnic代码。我就不废话了，直接代码：

/*
 */

#include <linux/capability.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/rculist.h>
#include <net/p8022.h>
#include <net/arp.h>
#include <net/ip.h>
#include <linux/rtnetlink.h>
#include <linux/notifier.h>
#include <net/rtnetlink.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <asm/uaccess.h>
#include <linux/etherdevice.h>
#include <linux/ip.h>
#include <linux/usb/input.h>

#include "vnic.h"

#define DRV_VERSION "1.0"

/* End of global variables definitions. */
    
static void vnic_group_free(struct vnic_group *grp)
{
    int i;

    for (i = 0; i < VNIC_GROUP_ARRAY_SPLIT_PARTS; i++)//释放所有已申请的虚拟网卡
        kfree(grp->vnic_devices_arrays[i]);
    kfree(grp);//释放一个vnic_group结构
}

static struct vnic_group *vnic_group_alloc(void)
{
    struct vnic_group *grp;

    grp = kzalloc(sizeof(struct vnic_group), GFP_KERNEL);//申请一个vnic_group结构
    if (!grp)
        return NULL;

    return grp;
}

static int vnic_group_prealloc_vid(struct vnic_group *vg, u16 vnic_id)
{
    struct net_device **array;
    unsigned int size;

    array = vg->vnic_devices_arrays[vnic_id / VNIC_GROUP_ARRAY_PART_LEN];//这样是为了多组设计的，其实我就一组
    if (array != NULL)
        return 0;

    size = sizeof(struct net_device *) * VNIC_GROUP_ARRAY_PART_LEN;//一组有8个
    array = kzalloc(size, GFP_KERNEL);
    if (array == NULL)
        return -ENOBUFS;

    vg->vnic_devices_arrays[vnic_id / VNIC_GROUP_ARRAY_PART_LEN] = array;

    return 0;
}

static struct net_device *real_netdev = NULL;
static struct vnic_group *vnic_grp = NULL;
static struct input_dev *input_dev = NULL;

static int vnic_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype, struct net_device *orig_dev)
{
#if 0
    struct net_device *vnic_dev;
    struct vnic_pcpu_stats *rx_stats;
    u16 vnic_id = skb->data[1];//这部就相当于解析我们自己的头

#if 1
    u16 i;
    for (i = 0; i < skb->mac_len; i++)
    {
        printk("%x ", skb->mac_header[i]);
    }

    printk("\n");
#endif

    vnic_dev = vnic_group_get_device(vnic_grp, vnic_id);
    if (vnic_dev == NULL)
    {
        return -1;
    }

    //检查skb的应用计数是否大于1，大于1意味着内核的其他部分拥有对
    //该缓冲区的引用。如果大于1，会自己建立一份缓冲区副本。
    skb = skb_share_check(skb, GFP_ATOMIC);
    if (unlikely(!skb))
    {
        return false;
    }

    skb->dev = vnic_dev;
    //PACKET_OTHERHOST表示L2目的地址和接收接口的地址不同
    //通常会被丢弃掉。如果网卡进入混杂模式，会接收所以包
    //这里我们就要自己比较一下。
    if (skb->pkt_type == PACKET_OTHERHOST) {
        if (!compare_ether_addr(eth_hdr(skb)->h_dest, vnic_dev->dev_addr))
            skb->pkt_type = PACKET_HOST;
    }

    rx_stats = (struct vnic_pcpu_stats *)this_cpu_ptr(vnic_dev_info(vnic_dev)->vnic_pcpu_stats);
    
    u64_stats_update_begin(&rx_stats->syncp);
    rx_stats->rx_packets++;
    rx_stats->rx_bytes += skb->len;
    if (skb->pkt_type == PACKET_MULTICAST)
        rx_stats->rx_multicast++;
    u64_stats_update_end(&rx_stats->syncp);
#else
    __u16 type;
    __u16 code;
    //__s8 value;

    type = skb->data[0] | (skb->data[1] << 8);
    code = skb->data[2] | (skb->data[3] << 8);

    if (type == 1)
    {
        switch(code)
        {
        case BTN_LEFT:
            input_report_key(input_dev, BTN_LEFT,   skb->data[6]);break;
        case BTN_RIGHT:
            input_report_key(input_dev, BTN_RIGHT,  skb->data[6]);break;
        case BTN_MIDDLE:
            input_report_key(input_dev, BTN_MIDDLE, skb->data[6]);break;
        case BTN_SIDE:
            input_report_key(input_dev, BTN_SIDE,   skb->data[6]);break;
        case BTN_EXTRA:
            input_report_key(input_dev, BTN_EXTRA,  skb->data[6]);break;
        default: break;
        }
    }
    
    if (type == 2)
    {
        switch(code)
        {
        case 0:
            input_report_rel(input_dev, REL_X,     (signed char)skb->data[6]);break;
        case 1:
            input_report_rel(input_dev, REL_Y,     (signed char)skb->data[6]);break;
        case 8:
            input_report_rel(input_dev, REL_WHEEL, (signed char)skb->data[6]);break;
        default: break;
        }
    }

    input_sync(input_dev);

#endif
    return 0;
}

static struct packet_type vnic_pack_type __read_mostly =
{
    .type = cpu_to_be16(ETH_P_VNIC),
    .func = vnic_rcv,
};

void unregister_vnic_dev(void)
{
    struct vnic_dev_info *vnic;
    struct net_device *real_dev;
    struct net_device *tempdev;
    u16 n = vnic_grp->nr_vnics, i;
    LIST_HEAD(list);

    rtnl_lock();
    for (i = 0; i < n; i++)
    {
        tempdev = vnic_group_get_device(vnic_grp, i);
        if (tempdev == NULL)
        {
            goto enodev;
        }
        vnic = vnic_dev_info(tempdev);
        real_dev = vnic->real_dev;

        vnic_grp->nr_vnics--;//已申请虚拟网卡数减一
        vnic_group_set_device(vnic_grp, i, NULL);//根据vnic_id获取对应的虚拟网卡

        //unregister_netdevice_queue(tempdev, &list);
        unregister_netdevice(tempdev);
        /* 减少真实设备的应用应用计数 */
        dev_put(real_dev);
        vnic->real_dev = NULL;
    }
enodev:
    rtnl_unlock();
}
EXPORT_SYMBOL(unregister_vnic_dev);

int register_vnic_dev(struct net_device *dev)
{
    struct vnic_dev_info *vnic = vnic_dev_info(dev);
    struct net_device *real_dev = vnic->real_dev = real_netdev;
    u16 vnic_id = vnic->vnic_id;
    int err;

    if ((vnic_grp == NULL) || (real_netdev == NULL))
    {
        return -ENODEV;
    }
    
    dev->mtu = real_netdev->mtu;


    rtnl_lock();

    err = register_netdevice(dev);//装载网卡
    if (err < 0)
    {
        rtnl_unlock();

        goto out_uninit_applicant;
    }

    /* 增加真实设备的应用应用计数 */
    dev_hold(real_dev);

    //这个函数是根据real_dev的dormat和连接状态来控制dev的连接上报
    //下面的event也是通过它。
    netif_stacked_transfer_operstate(real_dev, dev);
    
    rtnl_unlock();

    /* So, got the sucker initialized, now lets place
     * it into our local structure.
     */
    vnic_group_set_device(vnic_grp, vnic_id, dev);//设置次虚拟网卡的id
    vnic_grp->nr_vnics++;//已申请虚拟网卡数加一

    return 0;

out_uninit_applicant:

    return err;
}
EXPORT_SYMBOL(register_vnic_dev);

static void vnic_sync_address(struct net_device *dev,
                  struct net_device *vnicdev)//同步mac地址
{
    struct vnic_dev_info *vnic = vnic_dev_info(vnicdev);

    /* May be called without an actual change */
    /*
    下面这个函数很酷，有个判断数组相等的公式：
    ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
    成立就是相等
    */
    if (!compare_ether_addr(vnic->real_dev_addr, dev->dev_addr))//相等退出
        return;

    /* vnic address was different from the old address and is equal to
     * the new address */
    if (compare_ether_addr(vnicdev->dev_addr, vnic->real_dev_addr) &&
        !compare_ether_addr(vnicdev->dev_addr, dev->dev_addr))
        dev_uc_del(dev, vnicdev->dev_addr);//释放单播地址

    /* vnic address was equal to the old address and is different from
     * the new address */
    if (!compare_ether_addr(vnicdev->dev_addr, vnic->real_dev_addr) &&
        compare_ether_addr(vnicdev->dev_addr, dev->dev_addr))
        dev_uc_add(dev, vnicdev->dev_addr);//增加单播地址,这样会启动混杂模式，进行监听
                                           //由于vnic和真实网卡的mac不一样，所以要用混杂模式

    memcpy(vnic->real_dev_addr, dev->dev_addr, ETH_ALEN);//赋值地址
}

//通知链会调用的函数
static int vnic_device_event(struct notifier_block *unused, unsigned long event,
                 void *ptr)
{
    struct net_device *dev = ptr;
    int i, flgs;
    struct net_device *vnicdev;
    struct vnic_dev_info *vnic;

    if (!vnic_grp)
        goto out;

    /* It is OK that we do not hold the group lock right now,
     * as we run under the RTNL lock.
     */

    switch (event) {
    case NETDEV_CHANGE:
        /* Propagate real device state to vnic devices */
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            netif_stacked_transfer_operstate(dev, vnicdev);//链接状态刷新
        }
        break;

    case NETDEV_CHANGEADDR:
        /* Adjust unicast filters on underlying device */
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            flgs = vnicdev->flags;
            if (!(flgs & IFF_UP))
                continue;

            vnic_sync_address(dev, vnicdev);//更新物理地址，上面有。
        }
        break;

    case NETDEV_CHANGEMTU://MTU被更新。
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            if (vnicdev->mtu <= dev->mtu)
                continue;

            dev_set_mtu(vnicdev, dev->mtu);
        }
        break;

    case NETDEV_FEAT_CHANGE://功能发生变化
        /* Propagate device features to underlying device */
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            netdev_update_features(vnicdev);
        }

        break;

    case NETDEV_DOWN://关闭
        /* Put all VNICs for this dev in the down state too.  */
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            flgs = vnicdev->flags;
            if (!(flgs & IFF_UP))
                continue;

            vnic = vnic_dev_info(vnicdev);

            dev_change_flags(vnicdev, flgs & ~IFF_UP);
            netif_stacked_transfer_operstate(dev, vnicdev);
        }
        break;

    case NETDEV_UP://开启
        /* Put all VNICs for this dev in the up state too.  */
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            flgs = vnicdev->flags;
            if (flgs & IFF_UP)
                continue;

            vnic = vnic_dev_info(vnicdev);

            dev_change_flags(vnicdev, flgs | IFF_UP);
            netif_stacked_transfer_operstate(dev, vnicdev);
        }
        break;

    case NETDEV_UNREGISTER://注销
        /* twiddle thumbs on netns device moves */
        if (dev->reg_state != NETREG_UNREGISTERING)
            break;

        //unregister_vnic_dev();
    
        break;

    //下面和bonding有关
    case NETDEV_PRE_TYPE_CHANGE:
        /* Forbid underlaying device to change its type. */
        return NOTIFY_BAD;

    case NETDEV_NOTIFY_PEERS:
    case NETDEV_BONDING_FAILOVER://失败
        /* Propagate to vnic devices */
        for (i = 0; i < VNIC_N_VID; i++) {
            vnicdev = vnic_group_get_device(vnic_grp, i);
            if (!vnicdev)
                continue;

            call_netdevice_notifiers(event, vnicdev);//通过call去传播失败信息
        }
        break;
    }

out:
    return NOTIFY_DONE;
}

static struct notifier_block vnic_notifier_block __read_mostly = {
    .notifier_call = vnic_device_event,
};

static char name[10] = "net mouse";
static char phys[10] = "/input0";
static int __init vnic_proto_init(void)
{
    int err = 0;

    real_netdev = dev_get_by_name(&init_net, "eth0");
    if (real_netdev == NULL)
    {
        return -ENODEV;
    }

    vnic_grp = vnic_group_alloc();
    if (vnic_grp == NULL)
    {
        err = -ENOBUFS;

        goto error;
    }

    vnic_grp->real_dev = real_netdev;

    input_dev = input_allocate_device();
    if (!input_dev)
    {
        vnic_group_free(vnic_grp);
        goto error;
    }

    input_dev->name = name;
    input_dev->phys = phys;

    input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
    input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
        BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
    input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
    input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
        BIT_MASK(BTN_EXTRA);
    input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);

    err = input_register_device(input_dev);
    if (err)
    {
        input_free_device(input_dev);
        vnic_group_free(vnic_grp);
        goto error;
    }

    err = vnic_group_prealloc_vid(vnic_grp, 0);
    if (err < 0)
    {
        input_unregister_device(input_dev);
        input_free_device(input_dev);
        vnic_group_free(vnic_grp);
        goto error;
    }

    err = register_netdevice_notifier(&vnic_notifier_block);
    if (err < 0)
    {
        input_unregister_device(input_dev);
        input_free_device(input_dev);
        vnic_group_free(vnic_grp);
        goto error;
    }

    dev_add_pack(&vnic_pack_type);

    return 0;

error:

    return err;
}
    
static void __exit vnic_cleanup_module(void)
{
    input_unregister_device(input_dev);
    input_free_device(input_dev);

    if (vnic_grp != NULL)
    {
        vnic_group_free(vnic_grp);
    }

    unregister_netdevice_notifier(&vnic_notifier_block);

    dev_remove_pack(&vnic_pack_type);
}

module_init(vnic_proto_init);
module_exit(vnic_cleanup_module);

MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

主要就是加上了input上报！下面调试：

在接受端搞个测试程序：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>

int main (void)
{
    int fd,i,count;
    struct input_event ev_mouse[2];

    fd = open ("/dev/event0",O_RDWR);

    if (fd < 0) {
        printf ("fd open failed\n");

        return -1;

    }

    printf ("\nmouse opened, fd=%d\n",fd);

    while(1)
    {
        count=read(fd, ev_mouse, sizeof(struct input_event));

        for(i=0;i<(int)count/sizeof(struct input_event);i++)
        {
            if(EV_REL==ev_mouse[i].type)
            {
                printf("%d %d %d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
            }

            if(EV_KEY==ev_mouse[i].type)
            {
                printf("%d %d %d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
            }
        }
    }

    close (fd);

    return 0;
}

编译运行起来：

然后再搞个发送程序：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/socket.h>  
#include <linux/if_packet.h>  
#include <netdb.h>  
#include <errno.h>  
#include <arpa/inet.h>  
#include <sys/ioctl.h>  
#include <pthread.h>    
#include <net/ethernet.h>  
#include <netinet/ether.h>  
#include <net/if.h>  
#include <netinet/ip.h>  
#include <netinet/tcp.h>
#include <fcntl.h>
#include <linux/input.h>

static int sockfd;   
static struct sockaddr_ll peer_addr;   

static unsigned char vnic_num = 0;//选择哪个网卡

#define X86_TEST //pc上运行定义它

#ifdef X86_TEST
#define ETH_P_VNIC    0x8877

static unsigned char src_mac[6] = {0x00, 0x0c, 0x29, 0x15, 0xd9, 0xc5}; //发送端地址
static unsigned char dst_mac[6] = {0xba, 0x06, 0xdb, 0xe5, 0x7f, 0x0d};  //接收端地址
#else
static unsigned char src_mac[6] = {0xc0, 0x6f, 0x65, 0xaa, 0xdf, 0x61}; //发送端地址
static unsigned char dst_mac[6] = {0x00, 0x0c, 0x29, 0x15, 0xd9, 0xc5};  //接收端地址
#endif
struct arp_packet 
{  
    struct ether_header  eh;  
    __u16 type;
    __u16 code;
    __s32 value;
};  
 
static void send_pkt(void) 
{  

    struct arp_packet frame; 
    int fd,i,count;
    struct input_event ev_mouse[2];

    memset(&frame, 0, sizeof(struct arp_packet));
    memcpy(frame.eh.ether_dhost, dst_mac, 6);  
    memcpy(frame.eh.ether_shost, src_mac, 6);  
#ifdef X86_TEST//pc上只能在应用层去加
    frame.eh.ether_type = htons(ETH_P_VNIC);  
    //frame.data = htons(('w' << 8) | vnic_num);
#endif

    fd = open ("/dev/input/event1",O_RDWR);

    if (fd < 0) {

        printf ("fd open failed\n");

        return;

    }

    printf ("\nmouse opened, fd=%d\n",fd);
    
    while(1)
    {
        count=read(fd, ev_mouse, sizeof(struct input_event));
        for(i=0;i<(int)count/sizeof(struct input_event);i++)
        {
            if(EV_REL==ev_mouse[i].type)
            {

                frame.type = ev_mouse[i].type;
                frame.code = ev_mouse[i].code;
                frame.value = ev_mouse[i].value;
                sendto(sockfd, &frame, sizeof(frame), 0, (struct sockaddr*)&peer_addr, sizeof(peer_addr)); 
                printf("%d %d %d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
            }

            if(EV_KEY==ev_mouse[i].type)

            {
                frame.type = ev_mouse[i].type;
                frame.code = ev_mouse[i].code;
                frame.value = ev_mouse[i].value;
                sendto(sockfd, &frame, sizeof(frame), 0, (struct sockaddr*)&peer_addr, sizeof(peer_addr)); 
                printf("%d %d %d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
            }
        }

    }


    

    close (fd);
}  

 

int main(int argc, char **argv) 
{   
    struct ifreq req;

    if (argc <= 2)
    {
        return -1;
    }

    sockfd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_VNIC));  
    if(sockfd == -1)
    {
        perror("socket()");
    }

    memset(&peer_addr, 0, sizeof(peer_addr));  
    peer_addr.sll_family = AF_PACKET;  
  
    strcpy(req.ifr_name, argv[1]);  
    vnic_num = (*argv[2] - '0');

    if(ioctl(sockfd, SIOCGIFINDEX, &req) != 0)
    {
        perror("ioctl()");
    }

    peer_addr.sll_ifindex = req.ifr_ifindex;  
    peer_addr.sll_protocol = htons(ETH_P_ARP);  

    send_pkt();
        
    close(sockfd);

    return 0;  
}  

发送在pc上运行，检测的arm上，同时运行，看效果：

pc:

arm:

这些都是动动鼠标的结果！