linux内核调用用户空间程序

  //内核发送端----------->
　1 #include <linux/netlink.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <net/sock.h>

#include <linux/init.h>        
#include <linux/timer.h>   
#include <linux/time.h>    

#define NETLINK_TEST 17  
#define MAX_MSGSIZE 1024  
struct sock *nl_sk = NULL;

static int ForkBroadprocess(void);
static int netlink_init(void);
// Send message by netlink  
static void sendnlmsg(char *message);
static void netlink_exit(void);
static int stringlength(char *s);


/*
*    开启发送二层广播进程
*/
static int ForkBroadprocess(void)
{
    netlink_init();
    //netlink_exit();
    /*
    static char * argv_init[] = { "/usr/sbin/sendBroadcast", NULL};
    char * envp_init[] = {"HOME=/", "TERM=linux", "PATH=/sbin:/bin:/usr/sbin:/usr/bin", NULL};
    kernel_execve(argv_init[0], argv_init, envp_init);    
    printk("===============kernel_execve=================
");
    */
    return 0;
}

static int netlink_init(void)  
{  
    if(nl_sk == NULL)
    {
        nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, 1,NULL, NULL, THIS_MODULE);  
    }
    if(!nl_sk){  
        printk(KERN_ERR "my_net_link: create netlink socket error.
");  
        return 1;  
    }  
  
    printk("my_net_link: create netlink socket ok.
");  
    sendnlmsg("sendBroadcast");  
  
    return 0;  
}  

static int stringlength(char *s)  
{  
    int slen = 0;  
  
    for(; *s; s++){  
        slen++;  
    }  
  
    return slen;  
}  

// Send message by netlink  
static void sendnlmsg(char *message)    
{  
    struct sk_buff *skb = NULL;  
    struct nlmsghdr *nlh = NULL; 
    char szMessage[32] = {0};    
    int len = NLMSG_SPACE(MAX_MSGSIZE);  
    int slen = 0;  
      
    if(!message || !nl_sk){  
        return;  
    }  
  
    // Allocate a new sk_buffer  
    skb = alloc_skb(len, GFP_KERNEL);  
    if(!skb){  
        printk(KERN_ERR "my_net_link: alloc_skb Error.
");  
        return;  
    }  
  
    slen = stringlength(message);  
    printk("my_net_link: send message slen '%d'.
", slen);  
    //Initialize the header of netlink message  
    nlh = nlmsg_put(skb, 0, 0, 0, MAX_MSGSIZE, 0);  
    NETLINK_CB(skb).pid = 0; // from kernel  
    NETLINK_CB(skb).dst_group = 1; // multi cast  
    //message[slen] = '/0';  
    
    memset(szMessage, 0x0, 32);
    memcpy(szMessage, message, slen);
    memcpy(NLMSG_DATA(nlh), szMessage, slen + 1);  
    printk("my_net_link: send message '%s'.
", (char *)NLMSG_DATA(nlh));  
  
    //send message by multi cast  
    netlink_broadcast(nl_sk, skb, 0, 1, GFP_KERNEL);   
    return;  
}  
  
static void netlink_exit(void)     
{     
    if(nl_sk != NULL){  
        sock_release(nl_sk->sk_socket);  
    }  
  
    printk("my_net_link: self module exited/n");     
}  

 //用户空间接收端

#include <sys/stat.h>  
#include <unistd.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <sys/socket.h>  
#include <sys/types.h>  
#include <string.h>  
#include <asm/types.h>  
#include <linux/netlink.h>  
#include <linux/socket.h>  
#include <errno.h>  
#include <sys/time.h>

#define NETLINK_TEST 17  
#define MAX_PAYLOAD 1024  // maximum payload size  
  
static int OperateFun();

int main(int argc, char* argv[])  
{  
    struct sockaddr_nl src_addr, dest_addr;  
    struct nlmsghdr *nlh = NULL;  
    struct iovec iov;  
    struct msghdr msg;  
    int sock_fd, retval;  
      
    // Create a socket  
    sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_TEST);  
    if(sock_fd == -1){  
        printf("error getting socket: %s", strerror(errno));  
        return -1;  
    }  
    printf(" getting socket: %d
", sock_fd);    
    // To prepare binding  
    memset(&src_addr, 0, sizeof(src_addr));  
    src_addr.nl_family = AF_NETLINK;   
    src_addr.nl_pid = getpid();  // self pid   
    src_addr.nl_groups = 1; // multi cast  
    printf(" src_addr.nl_pid: %d
", src_addr.nl_pid);    
    retval = bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));  
    if(retval < 0){  
        printf("bind failed: %s", strerror(errno));  
        close(sock_fd);  
        return -1;  
    }  
     //printf(" ====================0000
");     
    // To prepare recvmsg  
    nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));  
    if(!nlh){  
        printf("malloc nlmsghdr error!/n");  
        close(sock_fd);  
        return -1;  
    }  
  //printf(" ====================11111
");   
    memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));  
    iov.iov_base = (void *)nlh;  
    iov.iov_len = NLMSG_SPACE(MAX_PAYLOAD);  
  //printf(" ====================22222
");   
    memset(&msg, 0, sizeof(msg));  
    memset(&dest_addr, 0, sizeof(dest_addr));  
    msg.msg_name = (void *)&dest_addr;  
    msg.msg_namelen = sizeof(dest_addr);  
    msg.msg_iov = &iov;  
    msg.msg_iovlen = 1;  
  //printf(" ====================33333
");   
    // Read message from kernel  

    int nSelectRet = 0;
    fd_set fdReadSet;
    struct timeval stTimeOut = {0};

    for(;;)
    {
        //wait for a message
        //printf(" ====================4444444
");   
        FD_ZERO(&fdReadSet);
        FD_SET(sock_fd, &fdReadSet);
        //printf(" ====================55555555
");  
        stTimeOut.tv_sec = 2;
        stTimeOut.tv_usec = 0;
        nSelectRet = select(sock_fd + 1, &fdReadSet, NULL, NULL, &stTimeOut);
    

        if(0 > nSelectRet)
        {
            printf( "select error !");
        }
        else if(0 == nSelectRet)
        {
            printf( "select time out !
");

        }
        else
        {
            if(FD_ISSET(sock_fd, &fdReadSet))
            {
                recvmsg(sock_fd, &msg, 0);  
                printf("Received message: %s
", NLMSG_DATA(nlh));  
                OperateFun();
            }
        }
    }
    close(sock_fd);  
  
    return 0;  
}