Netlink实例----用户态内核态全包含

/*
 * netlink_kernel.c
 */

#ifndef __KERNEL__
#define __KERNEL__
#endif
#ifndef MODULE
#define MODULE
#endif
#include <linux/types.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/mutex.h>
#include <linux/netfilter_ipv4.h>
#include <linux/ip.h>
#include <net/netlink.h>
#include <linux/netlink.h>
#include <linux/spinlock.h>
#include <net/sock.h>

#include "netlink.h"

static struct sock  *nl_sock = NULL;
static struct
{
    __u32 pid;
    rwlock_t lock;
}user_proc;
static DEFINE_MUTEX(nl_mutex);
static void netlink_kernel_rcv(struct sk_buff *skb)
{
    struct nlmsghdr *nlh = NULL;
    if(skb->len >= nlmsg_total_size(0)){ //sizeof(struct nlmsghdr)
        nlh = nlmsg_hdr(skb);
        if( (nlh->nlmsg_len >= sizeof(struct nlmsghdr))
            && (skb->len >= nlh->nlmsg_len)){
            if(nlh->nlmsg_type == NETLINK_TEST_U_PID){
                write_lock_bh(&user_proc.lock);
                user_proc.pid = nlh->nlmsg_pid; //record pid
                printk("NETLINK_TEST_U_PID: user_proc.pid = %d\n",user_proc.pid);
                write_unlock_bh(&user_proc.lock);
            }
         }
    }
 }
static int send_to_user(struct packet_info *info)
{
    int size,ret;
    unsigned char *old_tail;
    struct sk_buff *skb;
    struct nlmsghdr *nlh;
    struct packet_info *pk_info;
    size = NLMSG_SPACE(sizeof(*info));
    skb = alloc_skb(size,GFP_ATOMIC);
    if(!skb){
        printk("alloc skb failed\n");
        return -1;
    }
    old_tail = skb->tail;
    nlh = NLMSG_PUT(skb,0,0,NETLINK_TEST_K_MSG,size - sizeof(*nlh));
    pk_info = NLMSG_DATA(nlh);
    memset(pk_info,0,sizeof(struct packet_info));
    pk_info->src = info->src;
    pk_info->dest = info->dest;
    nlh->nlmsg_len = skb->tail - old_tail;
    NETLINK_CB(skb).pid = 0;
    NETLINK_CB(skb).dst_group = 0;
    read_lock_bh(&user_proc.lock);
    ret = netlink_unicast(nl_sock,skb,user_proc.pid,MSG_DONTWAIT);
    read_unlock_bh(&user_proc.lock);
nlmsg_failure:
    return ret;
}
static unsigned int get_icmp_info(unsigned int hook,
                                  struct sk_buff *skb,
                                  const struct net_device *in,
                                  const struct net_device *out,
                                  int (*okfn)(struct sk_buff *))
{
    struct iphdr *iph = ip_hdr(skb);
    struct packet_info info;
    if(iph->protocol == IPPROTO_ICMP)
    {
        read_lock_bh(&user_proc.lock);
        if(user_proc.pid != 0)
        {
            read_unlock_bh(&user_proc.lock);
            info.src = iph->saddr;
            info.dest = iph->daddr;
            send_to_user(&info);
        }
        else
        {
            read_unlock_bh(&user_proc.lock);
        }
    }
    return NF_ACCEPT;
}
static struct nf_hook_ops netlink_test_ops =
{
    .hook = get_icmp_info,
    .owner = THIS_MODULE,
    .pf = PF_INET,
    .hooknum = NF_INET_PRE_ROUTING,
    .priority = NF_IP_PRI_FILTER - 1,
};
static int netlink_kernel_init(void)
{
    rwlock_init(&user_proc.lock);
    nl_sock = netlink_kernel_create(&init_net,NETLINK_TEST,0,netlink_kernel_rcv,&nl_mutex,THIS_MODULE);
    if(!nl_sock){
        printk("create netlink kernel sock error\n");
        return -1;
    }
    printk("netlink_kernel_init()\n");
    return nf_register_hook(&netlink_test_ops);
}
static void netlink_kernel_exit(void)
{
    if(nl_sock){
        sock_release(nl_sock->sk_socket);
    }
    nf_unregister_hook(&netlink_test_ops);
    printk("netlink_kernel_exit()\n");
}
module_init(netlink_kernel_init);
module_exit(netlink_kernel_exit);

MODULE_LICENSE("GPL");

/*
 *      netlink_user.c
 */
#include <unistd.h>
#include <stdio.h>
#include <linux/types.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <asm/types.h>
#include <linux/netlink.h>
#include <signal.h>
#include "netlink.h"
struct msg_to_kernel
{
    struct nlmsghdr hdr;
};
struct u_packet_info
{
    struct nlmsghdr hdr;
    struct packet_info icmp_info;
};
static int sock_fd = -1;
 
int main()
{
    struct sockaddr_nl local; //local {user space}
    struct sockaddr_nl kpeer; //peer {kernel space}
    struct msg_to_kernel message;
    struct u_packet_info info;
    int k_peer_len,rcv_len;
    struct in_addr addr;

    //create netlink socket
    sock_fd = socket(AF_NETLINK,SOCK_RAW,NETLINK_TEST);
    if(!sock_fd)
    {
        perror("create netlink socket error\n");
        return -1;
    }
    memset(&local,0,sizeof(local));
    local.nl_family = AF_NETLINK;
    local.nl_pid = getpid();
    local.nl_groups = 0;
    if(bind(sock_fd,(struct sockaddr *)&local,sizeof(local)) != 0)
    {
        perror("bind error\n");
        return -1;
    }
 
    memset(&kpeer,0,sizeof(kpeer));
    kpeer.nl_family = AF_NETLINK;
    kpeer.nl_pid = 0;
    kpeer.nl_groups = 0; //not in multicast
 
    memset(&message,0,sizeof(message));
    message.hdr.nlmsg_len = NLMSG_LENGTH(0);
    message.hdr.nlmsg_flags = 0;
    message.hdr.nlmsg_type = NETLINK_TEST_U_PID;
    message.hdr.nlmsg_pid = local.nl_pid;
 
    //send to kernel
    sendto(sock_fd,&message,message.hdr.nlmsg_len,0,(struct sockaddr *)  &kpeer,sizeof(kpeer));
    while(1)
    {
        k_peer_len = sizeof(struct sockaddr_nl);
        rcv_len = recvfrom(sock_fd,&info,sizeof(struct u_packet_info),0,(struct sockaddr *)&kpeer,(socklen_t *)&k_peer_len);
        addr.s_addr = info.icmp_info.src;
        printf("src: %s,",inet_ntoa(addr));
        addr.s_addr = info.icmp_info.dest;
        printf("dst: %s\n",inet_ntoa(addr));
    }
    return 0;

}