netlink套接字监测网络设备

网络设备的状态监测

嵌入式系统层的开发常涉及到设备的网络配置，如何监测设备网络状态的变化通常是一些系统级的服务在实现过程中需要考虑的问题。一种可行的方案是在系统服务里创建一个线程，每隔一段时间（如5秒）获取网络接口的连接状态及信息，并与之前的信息相比较。这种方案的优点是简单、直接；而缺点是响应网络变化不及时，轮询的方式从某种角度看，是不合理的。实事上，现在已有了很多开源的网络配置服务，如openwrt中的netifd，及桌面系统下的NetworkManager(一些嵌入式SDK集成了该网络服务的守护进程)；但当你处于一个没有决策权限的开发团队里，只能从头开发了，不能复用优秀的开源软件。参考开源软件对网络状态的监测的功能实现，可以得知是通过Linux内核提供的netlink套接字被动地接收网络状态信息的变化的，这样就可以避免周期性地读取网络状态信息，提高代码设计的合理性。

Linux内核的netlink套接字

查看网络、配置网络的常用命令ifconfig，不过目前常用的Linux发行版（如ubuntu）默认已不再提供ifconfig命令行工具了，推荐使用iproute2软件包提供的ip命令行工具：

yejq@UNIX:~$ ifconfig
Command 'ifconfig' not found, but can be installed with:
sudo apt install net-tools
yejq@UNIX:~$ ip link show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

通过strace跟踪ip link show的系统调用，可以看到它创建了netlink套接字，并与向内核收发消息，从而获取到系统当前的网络接口的信息：

socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC, NETLINK_ROUTE) = 3
setsockopt(3, SOL_SOCKET, SO_SNDBUF, [32768], 4) = 0
setsockopt(3, SOL_SOCKET, SO_RCVBUF, [1048576], 4) = 0
setsockopt(3, SOL_NETLINK, NETLINK_EXT_ACK, [1], 4) = 0
bind(3, {sa_family=AF_NETLINK, nl_pid=0, nl_groups=00000000}, 12) = 0
getsockname(3, {sa_family=AF_NETLINK, nl_pid=10380, nl_groups=00000000}, [12]) = 0
setsockopt(3, SOL_NETLINK, NETLINK_DUMP_STRICT_CHK, [1], 4) = 0
sendto(3, {{len=32, type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK, seq=0, pid=0}, {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}}, 32, 0, NULL, 0) = 32
recvmsg(3, {msg_name={sa_family=AF_NETLINK, nl_pid=0, nl_groups=00000000}, msg_namelen=12, msg_iov=[{iov_base={{len=52, type=NLMSG_ERROR, flags=0, seq=0, pid=10380}, {error=-EPERM, msg={{len=32, type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK, seq=0, pid=0}, {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}}}}, iov_len=16384}], msg_iovlen=1, msg_controllen=0, msg_flags=0}, 0) = 52

随着ifconfig渐渐被抛弃，基于netlink的网络配置方式使用的越来越多。前者操作网络配置的接口通常是ioctl，通过其在线手册可知其仅能操作IPv4相关的网络配置。Linux内核的netlink套接字常用于应用与内核通信，也可以用于进程间通信(Inter-Process Communication)，与UNIX本地套接字相似，不依赖特定的网络设备，仅用于本机的通信；不同点在于本地套接字通过路径确定套接字的收发地址，而netlink套接字则通过进程PID来确定消息的收发地址。当PID设为0时，内核会处理进程发送的消息，实现配置网络接口的参数等功能。相关的信息可通过man 7 netlink和man 7 rtnetlink查看在线文档。

通过netlink套接字监测网络设备的状态变化

在本文中，笔者希望通过netlink套接字监视网络设备的断开、连接，以及IP地址的删除与配置。实现这些功能，嵌入式设备的网络服务进程就能够比较完全地掌控网络接口的状态。首先，创建netlink套接字，并绑定本地地址：

sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
/* bind to local address, using process pid */
nladdr.nl_family  = AF_NETLINK;
nladdr.nl_pad     = 0;
nladdr.nl_pid     = getpid();
nladdr.nl_groups  = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
ret = bind(sockfd, (const struct sockaddr *) &nladdr, sizeof(nladdr));

上面绑定的地址，nl_groups向内核指定了该套接字感兴趣的网络信息，RTMGRP_LINK指示与网络连接状态相关的信息；RTMGRP_IPV4_IFADDR指示与网络接口IPv4地址变化相关的信息。与TCP/IP及UNIX本地套接字不同，netlink套接字的数据接收通常使用recvmsg系统调用，这便涉及到接收结构体数据的准备。具体的说明请参考相关文档，以下是本例的数据接收代码：

/* clear the netlink socket buffer */
memset(nlbuf, 0, NLBUF_SIZE);
/* setup scattered vector */
vec.iov_base = nlbuf;
vec.iov_len = NLBUF_SIZE;
/* setup netlink message structure */
nlmsg.msg_name           = &nladdr;
nlmsg.msg_namelen        = sizeof(nladdr);
nlmsg.msg_iov            = &vec;
nlmsg.msg_iovlen         = 0x1;
nlmsg.msg_control        = NULL;
nlmsg.msg_controllen     = 0;
nlmsg.msg_flags          = 0;
rl1 = recvmsg(sockfd, &nlmsg, 0);

通常应用会会阻塞在系统调用recvmsg的调用中，可以通过poll、epoll监视套接字，或者使用libev、libuv等异步事件库监视该套接字。recvmsg成功时会返回接收数据的长度，单位为字节；rl1对应数据指针nlbuf中写入的有效的数据长度。之后就需对接收的数据进行解析了，这部分功能比较复杂，可用的文档并不多，但可以参考iproute2源码中对netlink套接字数据的解析方式。数据的起始对应着netlink消息结构体，该结构体由Linux内核的头文件定义：

struct nlmsghdr {
    __u32 nlmsg_len;    /* Length of message including header */
    __u16 nlmsg_type;   /* Type of message content */
    __u16 nlmsg_flags;  /* Additional flags */
    __u32 nlmsg_seq;    /* Sequence number */
    __u32 nlmsg_pid;    /* Sender port ID */
};

nlmsg_len包含了该消息的全部数据长度，根据nlmsg_type及其他信息可以确定具体包含信息的解析方式。其中，笔者关心的四个消息类型为：RTM_NEWLINK/RTM_DELLINK/RTM_NEWADDR/RTM_DELADDR，分别对应着网络设备的创建、删除，IP地址的增加、删除。从消息中可以解析到发生状态变化的网络设备名称、网络的状态（断开或连接）以及IP地址等，这里不再详述，具体请参考相关文档。笔者编写的简单应用能够确析出网络设备变化的基本信息，以下是演示结果：

root@UNIX:~# date ; ip addr flush dev enp1s0
2021年 07月 04日 星期日 20:01:44 CST
-------------------------------------------
Sun Jul  4 20:01:44 2021
Number of route attributes parsed: 6
Network device enp1s0 has been deleted IPv4 address: [10.10.8.100]
-------------------------------------------

root@UNIX:~# date ; ip addr add '192.168.1.192/24' dev enp1s0
2021年 07月 04日 星期日 20:01:55 CST
-------------------------------------------
Sun Jul  4 20:01:55 2021
Number of route attributes parsed: 5
Network device enp1s0 has been assigned IPv4 address: [192.168.1.192]
-------------------------------------------

root@UNIX:~# date ; ip link set dev enp1s0 down
2021年 07月 04日 星期日 20:02:04 CST
-------------------------------------------
Sun Jul  4 20:02:04 2021
Number of route attributes parsed: 26
Network device enp1s0 has been inserted, state: down, stopped
-------------------------------------------

root@UNIX:~# date ; ip link set dev enp1s0 up
2021年 07月 04日 星期日 20:02:12 CST
-------------------------------------------                                                   Sun Jul  4 20:02:13 2021
Number of route attributes parsed: 26
Network device enp1s0 has been inserted, state: up, stopped
------------------------------------------- 

以上修改网络设备状态者是通过软件操作网络参数实现的，不过也能够检测USB网卡的插入和移除（下面的XXXXXXXXXXXXXX代表USB网卡的MAC地址）：

Sun Jul  4 20:11:17 2021
Number of route attributes parsed: 26
Network device wlxXXXXXXXXXXXXXX has been removed, state: down, stopped
-------------------------------------------
Sun Jul  4 20:11:21 2021
Number of route attributes parsed: 26
Network device wlan0 has been inserted, state: down, stopped
-------------------------------------------
Sun Jul  4 20:11:22 2021
Number of route attributes parsed: 26
Network device wlxXXXXXXXXXXXXXX has been inserted, state: down, stopped
-------------------------------------------

netlink套接字相关的库

在netlink官方文档中，不建议按照以上的方式来操作netlink套接字，因为其数据相对原始，处理起来比较困难。常用的库有libnl及libnl-tiny（二者的区别可以参考该文档），后者是openwrt中网络服务netifd的依赖包。虽然推荐使用开源库而不应直接使用netlink套接字的底层数据读写，但当在实现的开发过程中因非技术原因，不方便引入第三方开源库的依赖时，重复造轮子就显得是可行的选择方案了。此外，也可通过iproute2提供的ip monitor命令监视网络状态的变化，通过管道读取其输出。了解netlink套接字的底层（非内核中的实现）机制仍有很大的帮助，可以增加我们对Linux系统的了解。以下是笔者编写的简单测试代码的全部内容：

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/if_link.h>
#include <linux/if_addr.h>
#include <linux/rtnetlink.h>
#include <linux/if.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>

#include <time.h>
#include <stdint.h>

#define NLBUF_SIZE        16384 /* 16K */

/* similar function exists in iproute2, `parse_rtattr(...) */
static int process_rtattr(struct rtattr * * attrs,
	int maxtype, struct rtattr * src, int len)
{
	int rval = 0;
	for (;;) {
		int okay, typn;
		okay = RTA_OK(src, len);
		if (okay == 0)
			break;
		typn = src->rta_type;
		if (typn <= maxtype) {
			rval++;
			attrs[typn] = src;
		}
		src = RTA_NEXT(src, len);
	}
	return rval;
}

static int dump_netlink_buffer(unsigned char * buf, uint32_t buflen)
{
	int rval = 0;
	time_t now = 0;
	char timebuf[64];
	uint32_t offset = 0;
	struct nlmsghdr * nlhdr;

	time(&now);
	memset(timebuf, 0, sizeof(timebuf));
	ctime_r(&now, timebuf);

	/* process netlink message header */
	while (buflen >= (offset + sizeof(*nlhdr))) {
		int retval = 0;
		uint32_t msglen;
		struct ifinfomsg * info = NULL;
		struct ifaddrmsg * addr = NULL;
		struct rtattr * rt_attr[IFLA_MAX + 1];

		/* network device name */
		const char * netdev = "unknown";
		nlhdr = (struct nlmsghdr *) (buf + offset);
		msglen = nlhdr->nlmsg_len;

		/* check message length */
		if ((msglen + offset) > buflen) {
			fprintf(stderr, "Error, invalid netlink message length: %u\n", msglen);
			fflush(stderr);
			break;
		}

		/* output time information */
		fputs(timebuf, stdout);
		fflush(stdout);
		/* clear the route information array */
		memset(rt_attr, 0, (IFLA_MAX + 1) * sizeof(struct rtattr *));

		switch (nlhdr->nlmsg_type) {
		case RTM_NEWLINK:
		case RTM_DELLINK: {
			const char * updown = NULL;
			const char * running = NULL;

			rval++;
			info = (struct ifinfomsg *) NLMSG_DATA(nlhdr);
			retval = process_rtattr(rt_attr, IFLA_MAX, IFLA_RTA(info), (int) msglen);
			fprintf(stdout, "Number of route attributes parsed: %d\n", retval);

			if (rt_attr[IFLA_IFNAME] != NULL)
				netdev = (const char *) RTA_DATA(rt_attr[IFLA_IFNAME]);
			updown = (info->ifi_flags & IFF_UP) ? "up" : "down";
			running = (info->ifi_flags & IFF_RUNNING) ? "running" : "stopped";
			fprintf(stdout, "Network device %s has been %s, state: %s, %s\n",
				netdev, nlhdr->nlmsg_type == RTM_NEWLINK ? "inserted" : "removed",
				updown, running);
			break;
		}

		case RTM_NEWADDR:
		case RTM_DELADDR: {
			char newaddr[64];

			rval++;
			addr = (struct ifaddrmsg *) NLMSG_DATA(nlhdr);
			retval = process_rtattr(rt_attr, IFLA_MAX, IFA_RTA(addr), (int) msglen);
			fprintf(stdout, "Number of route attributes parsed: %d\n", retval);
			if (rt_attr[IFLA_IFNAME] != NULL)
				netdev = (const char *) RTA_DATA(rt_attr[IFLA_IFNAME]);

			memset(newaddr, 0, sizeof(newaddr));
			if (rt_attr[IFA_LOCAL] != NULL)
				inet_ntop(AF_INET, RTA_DATA(rt_attr[IFA_LOCAL]),
					newaddr, sizeof(newaddr));
			fprintf(stdout, "Network device %s has been %s IPv4 address: [%s]\n",
				netdev, nlhdr->nlmsg_type == RTM_NEWADDR ? "assigned" : "deleted", newaddr);
			break;
		}

		case RTM_NEWNEIGH:
		case RTM_DELNEIGH:
			rval++;
			fprintf(stdout, "Netlink message %d (%s) ignored\n",
				nlhdr->nlmsg_type, (nlhdr->nlmsg_type == RTM_NEWNEIGH) ?
					"new-neigh" : "del-neigh");
			break;

		default:
			fprintf(stdout, "Unknown type of netlink message: %u\n",
				nlhdr->nlmsg_type);
			break;
		}
		fflush(stdout);
		offset += msglen;
	}
	return rval;
}

int main(int argc, char *argv[])
{
	int rval = 0;
	int sockfd = -1;
	int ret, errn = 0;
	struct msghdr nlmsg;
	struct sockaddr_nl nladdr;
	unsigned char * nlbuf = NULL;

	/* create a netlink socket */
	sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	if (sockfd == -1) {
		errn = errno;
		fprintf(stderr, "Error, failed to create netlink socket: %s\n",
			strerror(errn));
		fflush(stderr);
		return 1;
	}

	/* bind to local address, using process pid */
	nladdr.nl_family  = AF_NETLINK;
	nladdr.nl_pad     = 0;
	nladdr.nl_pid     = getpid();
	nladdr.nl_groups  = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
	ret = bind(sockfd, (const struct sockaddr *) &nladdr, sizeof(nladdr));
	if (ret == -1) {
		errn = errno;
		fprintf(stderr, "Error, failed to bind netlink address: %s\n",
			strerror(errn));
		fflush(stderr);
		rval = 2;
		goto err0;
	}

	/* allocate memory for netlink socket buffer */
	nlbuf = (unsigned char *) malloc(NLBUF_SIZE);
	if (nlbuf == NULL) {
		fputs("Error, system out of memory!\n", stderr);
		fflush(stderr);
		rval = 3;
		goto err0;
	}

	for (;;) {
		ssize_t rl1;
		struct iovec vec;

		/* clear the netlink socket buffer */
		memset(nlbuf, 0, NLBUF_SIZE);
		/* setup scattered vector */
		vec.iov_base = nlbuf;
		vec.iov_len = NLBUF_SIZE;

		/* setup netlink message structure */
		nlmsg.msg_name           = &nladdr;
		nlmsg.msg_namelen        = sizeof(nladdr);
		nlmsg.msg_iov            = &vec;
		nlmsg.msg_iovlen         = 0x1;
		nlmsg.msg_control        = NULL;
		nlmsg.msg_controllen     = 0;
		nlmsg.msg_flags          = 0;

		rl1 = recvmsg(sockfd, &nlmsg, 0);
		if (rl1 < 0) {
			errn = errno;
			fprintf(stderr, "Error, failed to read socket %d: %s\n",
				sockfd, strerror(errn));
			fflush(stderr);
			rval = 4;
			break;
		}

		if (rl1 > 0 && dump_netlink_buffer(nlbuf, (uint32_t) rl1) > 0) {
			fputs("-------------------------------------------\n", stdout);
			fflush(stdout);
		}
	}

err0:
	if (sockfd != -1) {
		close(sockfd);
		sockfd = -1;
	}
	if (nlbuf != NULL) {
		free(nlbuf);
		nlbuf = NULL;
	}
	return rval;
}