Netlink : Unicast

In this program, you are going to learn

How to communication between kernel and user space ?

How to use user space APIs ?
- NLMSG_SPACE
- NLMSG_DATA

How to use kernel space APIs ?

Topics in this section,

Netlink

User program : nl_user.c

Kernel program : nl_kernel.c

Makefile

Compile and Load

Summary

Netlink

Netlink is used to transfer information between the kernel and user-space processes.
Netlink is a datagram-oriented service. Both SOCK_RAW and SOCK_DGRAM are valid values for socket_type.

nl_user.c

To create a socket with socket(),

int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TESTFAMILY);

nl_pid field of the sockaddr_nl can be filled with the calling process’ own pid.

nlh->nlmsg_pid = getpid();

Sending a Netlink Message In order to send a netlink message to the kernel or other user-space processes, another struct sockaddr_nl addr needs to be supplied as the destination address, the same as sending a packet with sendmsg(). If the message is destined for the kernel, both nl_pid and nl_groups should be supplied with 0.

addr.nl_pid = 0;
addr.nl_groups = 0;

struct msghdr msg;

msg.msg_name = (void * ) &addr;
msg.msg_namelen = sizeof(addr);

The netlink socket requires its own message header as well. This is for providing a common ground for netlink messages of all protocol types. Because the Linux kernel netlink core assumes the existence of the following header in each netlink message, an application must supply this header in each netlink message it sends:

struct nlmsghdr * nlh = (struct nlmsghdr * ) malloc(NLMSG_SPACE(MAX_PAYLOAD));

nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
nlh->nlmsg_pid = getpid();
nlh->nlmsg_flags = 0;

A netlink message thus consists of nlmsghdr and the message payload. Once a message has been entered, it enters a buffer pointed to by the nlh pointer. We also can send the message to the struct msghdr msg:

struct iovec iov;

iov.iov_base = (void * ) nlh;
iov.iov_len = nlh->nlmsg_len;

msg.msg_iov = &iov;
msg.msg_iovlen = 1;

After the above steps, a call to sendmsg() kicks out the netlink message:

sendmsg(fd, &msg, 0);

recvmsg used for Receiving Netlink Messages,

recvmsg(fd, &msg, 0);

See the full program below,

#include <linux/netlink.h>
#include <sys/socket.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define NETLINK_TESTFAMILY 25
#define MAX_PAYLOAD 1024

int main(int argc, char *argv[])
{
	int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TESTFAMILY);
	struct iovec iov;
	struct msghdr msg;
	struct sockaddr_nl addr;

	if (fd < 0)
		printf("Unable to create socket\n");

	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_pid = 0;  // For Linux kernel
	addr.nl_groups = 0;

	struct nlmsghdr *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((char *) NLMSG_DATA(nlh), "Hello");

	memset(&iov, 0, sizeof(iov));
	iov.iov_base = (void *) nlh;
	iov.iov_len = nlh->nlmsg_len;

	memset(&msg, 0, sizeof(msg));
	msg.msg_name = (void *) &addr;
	msg.msg_namelen = sizeof(addr);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;

	printf("Sending message to kernel\n");
	printf("-------------------------\n");
	sendmsg(fd, &msg, 0);
	printf("Sent message: %s\n\n", (char *)NLMSG_DATA(nlh));

	printf("Receving the message from the kernel\n");
	printf("------------------------------------\n");
	recvmsg(fd, &msg, 0);
	printf("Received message: %s\n", (char *)NLMSG_DATA(nlh));
	return 0;
}

nl_kernel.c

nlmsg_new using this create a netlink message.

struct sk_buff * skb_out;

skb_out = nlmsg_new(message_size, GFP_KERNEL);

nlmsg_put used to populate the message with data.

struct nlmsghdr * nlh = (struct nlmsghdr * ) skb->data;

nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, message_size, 0);

nlmsg_unicast used to send the message to the user space application.

result = nlmsg_unicast(socket, skb_out, pid);

netlink_kernel_create used to create a Netlink socket in the kernel.

socket = netlink_kernel_create(&init_net, NETLINK_TESTFAMILY, &config);

netlink_kernel_release used to release the netlink socket created with netlink_kernel_create.

netlink_kernel_release(socket);

See the full program below,

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netlink.h>
#include <net/netlink.h>
#include <net/net_namespace.h>

#define NETLINK_TESTFAMILY 25
#define NETLINK_MYGROUP 2

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linux_usr");
MODULE_DESCRIPTION("Netlink - Unicast");

struct sock *socket;

static void test_nl_receive_message(struct sk_buff *skb)
{
	struct nlmsghdr *nlh = (struct nlmsghdr *) skb->data;
	pid_t pid = nlh->nlmsg_pid; // pid of the sending process
	int result;
	char *message;
	size_t message_size;
	struct sk_buff *skb_out;

	pr_info("Entering: %s\n", __func__);
	pr_info("Received message: %s\n", (char *) nlmsg_data(nlh));

	message = "Hello from kernel unicast";
	message_size = strlen(message) + 1;
	skb_out = nlmsg_new(message_size, GFP_KERNEL);
	if (!skb_out) {
		pr_err("Failed to allocate a new skb\n");
		return;
	}

	nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, message_size, 0);
	NETLINK_CB(skb_out).dst_group = 0;
	strncpy(nlmsg_data(nlh), message, message_size);

	result = nlmsg_unicast(socket, skb_out, pid);
	pr_info("Sent message: %s\n", (char *)nlmsg_data(nlh));
}

static int __init test_init(void)
{
	struct netlink_kernel_cfg config = {
		.input = test_nl_receive_message,
	};

	socket = netlink_kernel_create(&init_net, NETLINK_TESTFAMILY, &config);
	if (socket == NULL)
		return -1;

	pr_info("Netlink initialized\n");
	return 0;
}

static void __exit test_exit(void)
{
	if (socket)
		netlink_kernel_release(socket);
	pr_info("Netlink released\n");
}

module_init(test_init);
module_exit(test_exit);

Makefile

obj-m += nl_kernel.o
all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

client:
	gcc nl_user.c -o nl_user

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
	rm nl_user

Compile and Load

$ make all

$ sudo insmod ./nl_kernel.ko

$ ./nl_user

$ sudo rmmod nl_kernel

$ dmesg
[168541.257012] Netlink initialized
[168546.697217] Entering: test_nl_receive_message
[168546.697220] Received message: Hello
[168546.697224] Sent message: Hello from kernel unicast
[168567.528336] Netlink released

Summary

User Space API	Learning
socket	To create a socket
sendmsg	To send netlink message
recvmsg	To receive netlink message

Summary

Kernel Space API	Learning
nlmsg_new	To create a netlink message
nlmsg_put	TO populate the message
nlmsg_unicast	To send the message to the user space application
netlink_kernel_create	To create a Netlink socket in the kernel
netlink_kernel_release	To release the netlink socket