Linux Minimal Netlink Example

README.md

Commands to build and run:

make
sudo insmod chriz_netlink_kernel.ko
./chriz_netlink_user
sudo rmmod chriz_netlink_kernel

Expected output for userspace program chriz_netlink_user:

Message sent, payload: Hello World!
Message received, payload: Hello World!

Expected output for dmesg -w:

[  295.638657] chriz netlink module init... (chriz_init_module)
[  297.201651] Received pid: 1281, msg: Hello World!, len: 12
[  297.201653] chriz_nl_rcv: returned...
[  299.429938] chriz netlink module exit... Goodbye!

chriz_netlink_kernel.c

#include <linux/module.h>
#include <linux/kernel.h>	/* Needed for KERN_INFO */

#include <net/sock.h>
#include <linux/netlink.h>
#include <linux/skbuff.h>

#define NETLINK_CHRIZ		25

struct sock *nl_sk = NULL;

// ------------------------------------------------------------------

// upon receive, send back the received message
static void chriz_nl_rcv(struct sk_buff *skb)
{
	struct nlmsghdr *nlh;	// Netlink message header
	int pid = 0;

	struct sk_buff *skb_out;
	char *msg = NULL;
	char msg_len = 0;
	int ret = 0;

	// check received socket buffer:
	if (skb == NULL)
	{
		printk(KERN_ERR "%s: socket buffer is empty...\n", __FUNCTION__);
		return;
	}

	// Print received message:
	nlh = (struct nlmsghdr *)skb->data;
	pid = nlh->nlmsg_pid;
	msg_len = strlen(NLMSG_DATA(nlh));
	msg = NLMSG_DATA(nlh);
	printk(KERN_INFO "Received pid: %d, msg: %s, len: %d\n", pid, msg, msg_len);


	// Create a new socket buffer with received message copied:
	skb_out = nlmsg_new(msg_len, 0);
	if (skb_out == NULL)
	{
		printk(KERN_ERR "%s: netlink new socket creation failed...\n", __FUNCTION__);
		return;
	}
	nlh = nlmsg_put(skb_out, 0, 0, 0, msg_len, 0);  // flag 0, pid kernel 0, seq 0, payload msg_len, flags 0
	strncpy(NLMSG_DATA(nlh), msg, msg_len);

	// Send back the message to app:
	ret = nlmsg_unicast(nl_sk, skb_out, pid);
	if (ret < 0)
	{
		printk(KERN_ERR "%s: netlink unicast failed...\n", __FUNCTION__);
		return;
	}

	printk(KERN_INFO "%s: returned...", __FUNCTION__);

}


// ------------------------------------------------------------------

struct netlink_kernel_cfg cfg = {
	.input = chriz_nl_rcv,
};

static int __init chriz_init_module(void)
{
	printk(KERN_INFO "chriz netlink module init... (%s)\n", __FUNCTION__);
	nl_sk = netlink_kernel_create(&init_net, NETLINK_CHRIZ, &cfg);
	if(nl_sk == NULL)
	{
		printk(KERN_INFO "error creating netlink socket...\n");
		return -1;
	}

	return 0;
}

static void __exit chriz_exit_module(void)
{
	netlink_kernel_release(nl_sk);
	printk(KERN_INFO "chriz netlink module exit... Goodbye!\n");
}

module_init(chriz_init_module);
module_exit(chriz_exit_module);

chriz_netlink_user.c

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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>


#define NETLINK_CHRIZ		25
#define PAYLOAD_SIZE		1024

int main()
{

	struct sockaddr_nl src_addr;
	int ret = 0;
	int sock_fd = 0;

	struct nlmsghdr *nlh = NULL;     // The nlmsghdr with payload to send
	struct sockaddr_nl dest_addr;

	// Open Socket:
	sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_CHRIZ);
	if (sock_fd < 0)
	{
		printf("socket creation for NETLINK_CHRIZ failed...\n");
		return -1;
	}

	// Bind Socket:
	memset(&src_addr, 0, sizeof(src_addr));
	src_addr.nl_family = AF_NETLINK;
	src_addr.nl_pid = getpid();
	bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));

	// Construct netlink packet:
	nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(PAYLOAD_SIZE));
	memset(nlh, 0, NLMSG_SPACE(PAYLOAD_SIZE));
	nlh->nlmsg_len = NLMSG_SPACE(PAYLOAD_SIZE);
	nlh->nlmsg_pid = getpid();
	nlh->nlmsg_flags = 0;

	// Edit packet payload:
	strcpy(NLMSG_DATA(nlh), "Hello World!");

	// Configure netlink destination:
	memset(&dest_addr, 0, sizeof(dest_addr));
	dest_addr.nl_family = AF_NETLINK;
	dest_addr.nl_pid = 0;		// Linux Kernel PID
	dest_addr.nl_groups = 0;

	// Set iovector and msg (https://man7.org/linux/man-pages/man2/readv.2.html):
	struct iovec iov = { nlh, nlh->nlmsg_len };
	struct msghdr msg = { &dest_addr, sizeof(dest_addr), &iov, 1, NULL, 0, 0 };

	// Send msg to kernel:
	sendmsg(sock_fd, &msg, 0);
	printf("Message sent, payload: %s\n", (char *)NLMSG_DATA(nlh));

	// Clear netlink packet payload:
	memset(nlh, 0, NLMSG_SPACE(PAYLOAD_SIZE));

	// Receive msg from kernel:
	recvmsg(sock_fd, &msg, 0);
	printf("Message received, payload: %s\n", (char *)NLMSG_DATA(nlh));

	return 0;
}

Makefile

KDIR := /home/chriz/repositories/WSL2-Linux-Kernel/

obj-m += chriz_netlink_kernel.o

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules
	gcc -o chriz_netlink_user chriz_netlink_user.c

clean:
	rm -rf *.o *.ko *.mod.* *.cmd .module* modules* Module* .*.cmd .tmp*
	make -C ${KDIR} M=$(PWD) clean
	rm -f chriz_netlink_user