C语言 如何使用 netlink 套接字与内核模块通信？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/3299386/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
How to use netlink socket to communicate with a kernel module?
提问by binW
I am trying to write a linux kernel module that communicates with user process using netlink. I am using netlink because the user program I want to communicate to communicates only using sockets and I cant change that to add ioctl()or anything.
我正在尝试编写一个使用 netlink 与用户进程通信的 linux 内核模块。我正在使用 netlink，因为我想与之通信的用户程序仅使用套接字进行通信，我无法更改它以添加ioctl()或进行任何操作。
Problem is that I cant figure out how to do that. I have googled but all examples I found are for old like this oneand no longer valid for current kernel versions. I have also looked at this SO questionbut the sample here uses libnlfor socket operations but I want to stick to standard socket functions (defined by sys/socket.h). So can some one plz guide me here to some tutorial or guide or some thing that can help me understand the interface and usage of netlink. I would highly appreciate a working example, nothing fancy, just a very basic example of how to establish a connection from a socket in user program to a socket in kernel and then send data from user process to kernel and receive back from kernel.
问题是我不知道如何做到这一点。我用Google搜索，但我发现所有的例子都是老喜欢这一个，不再适用于当前的内核版本。我也看过这个 SO 问题，但这里的示例使用libnl进行套接字操作，但我想坚持使用标准套接字函数（由 定义sys/socket.h）。所以有人可以在这里指导我一些教程或指南或一些可以帮助我理解 netlink 的界面和用法的东西。我非常感谢一个工作示例，没什么特别的，只是一个非常基本的示例，说明如何建立从用户程序中的套接字到内核中的套接字的连接，然后将数据从用户进程发送到内核并从内核接收回。
Also please do not tell me to look at kernel code. I am already doing it but it will take a lot of time and I dont have lot of it left.
另外请不要告诉我看内核代码。我已经在做，但需要很多时间，而且我所剩的不多。
Update:After lot of trial and error I have following code which sends message from user program to kernel but the message from kernel to user program i.e using netlink_unicast()is not working. Its not only not working, the call hangs the systems and then I have to restart the machine. Can some one plz take a look and tell me what wrong I am doing. The netlink_unicast()call is commented in the following code. It should be uncommented for kernel to user program message.
更新：经过大量反复试验后，我有以下代码将消息从用户程序发送到内核，但从内核到用户程序的消息即 usingnetlink_unicast()不起作用。它不仅不工作，呼叫挂起系统，然后我必须重新启动机器。有人可以看看并告诉我我在做什么错。该netlink_unicast()调用在以下代码中进行了注释。内核到用户程序消息应该取消注释。
User Program
用户程序
#include <sys/socket.h>
#include <linux/netlink.h>
#define NETLINK_USER 31
#define MAX_PAYLOAD 1024 /* maximum payload size*/
struct sockaddr_nl src_addr, dest_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
int sock_fd;
struct msghdr msg;
void main()
{
sock_fd=socket(PF_NETLINK, SOCK_RAW, NETLINK_USER);
if(sock_fd<0)
return -1;
memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid(); /* self pid */
/* interested in group 1<<0 */
bind(sock_fd, (struct sockaddr*)&src_addr,
sizeof(src_addr));
memset(&dest_addr, 0, sizeof(dest_addr));
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; /* For Linux Kernel */
dest_addr.nl_groups = 0; /* unicast */
nlh = (struct nlmsghdr *)malloc(
NLMSG_SPACE(MAX_PAYLOAD));
memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
nlh->nlmsg_pid = getpid();
nlh->nlmsg_flags = 0;
strcpy(NLMSG_DATA(nlh), "Hello");
iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;
msg.msg_name = (void *)&dest_addr;
msg.msg_namelen = sizeof(dest_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
printf("Sending message to kernel\n");
sendmsg(sock_fd,&msg,0);
printf("Waiting for message from kernel\n");
/* Read message from kernel */
recvmsg(sock_fd, &msg, 0);
printf(" Received message payload: %s\n",
NLMSG_DATA(nlh));
close(sock_fd);
}
Kernel Code
内核代码
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <net/sock.h>
#include <linux/socket.h>
#include <linux/net.h>
#include <asm/types.h>
#include <linux/netlink.h>
#include <linux/skbuff.h>
#define NETLINK_USER 31
struct sock *nl_sk = NULL;
static void hello_nl_recv_msg(struct sk_buff *skb)
{
struct nlmsghdr *nlh;
int pid;
printk(KERN_INFO "Entering: %s\n", __FUNCTION__);
nlh=(struct nlmsghdr*)skb->data;
printk(KERN_INFO "Netlink received msg payload: %s\n",
(char*)NLMSG_DATA(nlh));
pid = nlh->nlmsg_pid; /*pid of sending process */
NETLINK_CB(skb).dst_group = 0; /* not in mcast group */
NETLINK_CB(skb).pid = 0; /* from kernel */
//NETLINK_CB(skb).groups = 0; /* not in mcast group */
//NETLINK_CB(skb).dst_pid = pid;
printk("About to send msg bak:\n");
//netlink_unicast(nl_sk,skb,pid,MSG_DONTWAIT);
}
static int __init hello_init(void)
{
printk("Entering: %s\n",__FUNCTION__);
nl_sk=netlink_kernel_create(&init_net, NETLINK_USER, 0,
hello_nl_recv_msg, NULL, THIS_MODULE);
if(!nl_sk)
{
printk(KERN_ALERT "Error creating socket.\n");
return -10;
}
return 0;
}
static void __exit hello_exit(void)
{
printk(KERN_INFO "exiting hello module\n");
netlink_kernel_release(nl_sk);
}
module_init(hello_init);
module_exit(hello_exit);
回答by binW
After reading kernel source I finally managed to make netlink sockets work for me. Below is an example of Netlink socket basics i.e opening a netlink socket, reading and writing to it and closing it.
阅读内核源代码后，我终于设法让 netlink 套接字对我来说有效。下面是一个 Netlink 套接字基础的例子，即打开一个 netlink 套接字，读取和写入它，然后关闭它。
Kernel Module
内核模块
#include <linux/module.h>
#include <net/sock.h>
#include <linux/netlink.h>
#include <linux/skbuff.h>
#define NETLINK_USER 31
struct sock *nl_sk = NULL;
static void hello_nl_recv_msg(struct sk_buff *skb)
{
struct nlmsghdr *nlh;
int pid;
struct sk_buff *skb_out;
int msg_size;
char *msg = "Hello from kernel";
int res;
printk(KERN_INFO "Entering: %s\n", __FUNCTION__);
msg_size = strlen(msg);
nlh = (struct nlmsghdr *)skb->data;
printk(KERN_INFO "Netlink received msg payload:%s\n", (char *)nlmsg_data(nlh));
pid = nlh->nlmsg_pid; /*pid of sending process */
skb_out = nlmsg_new(msg_size, 0);
if (!skb_out) {
printk(KERN_ERR "Failed to allocate new skb\n");
return;
}
nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, msg_size, 0);
NETLINK_CB(skb_out).dst_group = 0; /* not in mcast group */
strncpy(nlmsg_data(nlh), msg, msg_size);
res = nlmsg_unicast(nl_sk, skb_out, pid);
if (res < 0)
printk(KERN_INFO "Error while sending bak to user\n");
}
static int __init hello_init(void)
{
printk("Entering: %s\n", __FUNCTION__);
//nl_sk = netlink_kernel_create(&init_net, NETLINK_USER, 0, hello_nl_recv_msg, NULL, THIS_MODULE);
struct netlink_kernel_cfg cfg = {
.input = hello_nl_recv_msg,
};
nl_sk = netlink_kernel_create(&init_net, NETLINK_USER, &cfg);
if (!nl_sk) {
printk(KERN_ALERT "Error creating socket.\n");
return -10;
}
return 0;
}
static void __exit hello_exit(void)
{
printk(KERN_INFO "exiting hello module\n");
netlink_kernel_release(nl_sk);
}
module_init(hello_init); module_exit(hello_exit);
MODULE_LICENSE("GPL");
User Program
用户程序
#include <linux/netlink.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#define NETLINK_USER 31
#define MAX_PAYLOAD 1024 /* maximum payload size*/
struct sockaddr_nl src_addr, dest_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
int sock_fd;
struct msghdr msg;
int main()
{
sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_USER);
if (sock_fd < 0)
return -1;
memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid(); /* self pid */
bind(sock_fd, (struct sockaddr *)&src_addr, sizeof(src_addr));
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; /* For Linux Kernel */
dest_addr.nl_groups = 0; /* unicast */
nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));
memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
nlh->nlmsg_pid = getpid();
nlh->nlmsg_flags = 0;
strcpy(NLMSG_DATA(nlh), "Hello");
iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;
msg.msg_name = (void *)&dest_addr;
msg.msg_namelen = sizeof(dest_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
printf("Sending message to kernel\n");
sendmsg(sock_fd, &msg, 0);
printf("Waiting for message from kernel\n");
/* Read message from kernel */
recvmsg(sock_fd, &msg, 0);
printf("Received message payload: %s\n", NLMSG_DATA(nlh));
close(sock_fd);
}
Related thread about the magic constant NETLINK_USER 31: Can I have more than 32 netlink sockets in kernelspace?
关于魔法常数的相关线程NETLINK_USER 31：内核空间中可以有超过 32 个 netlink 套接字吗？
回答by guoger
Just in case anybody doesn't know how to compile, google "how to compile and load kernel module"
以防万一有人不知道如何编译，谷歌“如何编译和加载内核模块”
refer to http://www.cyberciti.biz/tips/compiling-linux-kernel-module.html
参考http://www.cyberciti.biz/tips/compiling-linux-kernel-module.html
Grab kernel source code to which you'll compile module against http://kernel.org
获取内核源代码，您将针对http://kernel.org编译模块
Or simply update your headers if you are running intended kernel
或者如果您正在运行预期的内核，则只需更新您的标头
# apt-get install kernel-headers-$(uname -r)
Create a makefile, for example
创建一个makefile，例如
obj-m = hello.o
KVERSION = $(shell uname -r)
all:
make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean
Make and you'll get bunch of files. *.ko is the one you'll load into your kernel, run
制作，你会得到一堆文件。*.ko 是您将加载到内核中的那个，运行
# insmod hello.ko
if you us lsmod to check all loaded modules, you'll find yours, most likely you will see:
如果您使用 lsmod 来检查所有加载的模块，您会找到自己的，很可能您会看到：
hello 12575 0
In our case, compile and run user code:
在我们的例子中，编译并运行用户代码：
gcc hello.c -o hello.o
./hello.o
If everything is OK, you'll get following message using binW's code:
如果一切正常，您将使用 binW 的代码收到以下消息：
Sending message to kernel
Waiting for message from kernel
Received message payload: Hello from kernel
Finally, remove the module using:
最后，使用以下命令删除模块：
# rmmod hello
回答by yvo.engr
It works for me with kernel 3.2. For kernel 3.6 & above, it needs a bit of a change at the netlink_kernel_createfunction.
它适用于内核 3.2。对于内核 3.6 及更高版本，它需要对netlink_kernel_create功能进行一些更改。
struct netlink_kernel_cfg cfg = {
.groups = 1,
.input = hello_nl_recv_msg,
};
printk("Entering: %s\n", __FUNCTION__);
nl_sk = netlink_kernel_create(&init_net, NETLINK_USER, &cfg);
回答by Mostafa Dsg
you need include following header file into client_side code:
您需要在客户端代码中包含以下头文件：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
