邻居子系统之Netlink接口

最新推荐文章于 2024-03-27 18:09:47 发布
最新推荐文章于 2024-03-27 18:09:47 发布
阅读量1k 收藏 1
点赞数
分类专栏： 邻居子系统 文章标签： linux 邻居子系统 RTM_NEWNEIGH RTM_GETNEIGH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyu_750516366/article/details/121621085
版权

文章目录


在邻居子系统框架的系统初始化函数neigh_init()中，有看到其向RtNetlink注册了几个事件用于配置邻居项，这篇笔记分析下邻居项的配置过程。

数据结构

邻居项Netlink命令消息: ndmsg

struct ndmsg
{
	__u8		ndm_family;
	__u8		ndm_pad1;
	__u16		ndm_pad2;
	__s32		ndm_ifindex; // 网络设备索引
	__u16		ndm_state; // 邻居项状态
	__u8		ndm_flags;
	__u8		ndm_type;
};

可携带的属性如下：

enum
{
	NDA_UNSPEC,
	NDA_DST, // 指定邻居项的key，对于ARP就是IP地址
	NDA_LLADDR, // L2
	NDA_CACHEINFO,
	NDA_PROBES,
	__NDA_MAX
};

命令行

以ip(8)命令为例，邻居项相关的常用命令格式如下。

ip neigh { add | del | change | replace } { ADDR [ lladdr LLADDR ] [ nud STATE ] | proxy ADDR } \
         [ dev DEV ] [ router ] [ extern_learn ]

ip neigh { show | flush } [ proxy ] [ to PREFIX ] [ dev DEV ] [ nud STATE ] [ vrf NAME ]

ip neigh get ADDR dev DEV

STATE := { permanent | noarp | stale | reachable | none | incomplete | delay | probe | failed }

添加邻居项: neigh_add()

static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
	struct net *net = sock_net(skb->sk);
	struct ndmsg *ndm;
	struct nlattr *tb[NDA_MAX+1];
	struct neigh_table *tbl;
	struct net_device *dev = NULL;
	int err;

    // 解析Netlink消息，将属性保存在tb数组中
	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
	if (err < 0)
		goto out;

	err = -EINVAL;
	if (tb[NDA_DST] == NULL) // 必须指定NDA_DST属性
		goto out;

	ndm = nlmsg_data(nlh);
	if (ndm->ndm_ifindex) {
	    // 查找网络设备并校验配置的L2层地址长度
		dev = dev_get_by_index(net, ndm->ndm_ifindex);
		if (dev == NULL) {
			err = -ENODEV;
			goto out;
		}
		if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
			goto out_dev_put;
	}

    // 遍历所有的邻居协议链表，根据协议族找到应该处理该添加命令的邻居协议对象
	read_lock(&neigh_tbl_lock);
	for (tbl = neigh_tables; tbl; tbl = tbl->next) {
		int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
		struct neighbour *neigh;
		void *dst, *lladdr;

		if (tbl->family != ndm->ndm_family) // 比较协议族
			continue;
		read_unlock(&neigh_tbl_lock);
        // 找到了邻居协议，下面执行添加操作
        
        // 校验DST属性，key的长度不足为非法配置参数
		if (nla_len(tb[NDA_DST]) < tbl->key_len)
			goto out_dev_put;
		dst = nla_data(tb[NDA_DST]); // 保存dst信息
		// 解析二层地址
		lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;

		if (ndm->ndm_flags & NTF_PROXY) {
			struct pneigh_entry *pn;

			err = -ENOBUFS;
			pn = pneigh_lookup(tbl, net, dst, dev, 1);
			if (pn) {
				pn->flags = ndm->ndm_flags;
				err = 0;
			}
			goto out_dev_put;
		}
        // 必须指定网络设备
		if (dev == NULL)
			goto out_dev_put;
        // 根据key(dst)和网络设备对象，从邻居表中查找邻居项
		neigh = neigh_lookup(tbl, dst, dev);
		if (neigh == NULL) { // 系统中没有该邻居项，尝试创建它
		    // 新建场景，需要指定CREATE标记
			if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
				err = -ENOENT;
				goto out_dev_put;
			}
            // 该接口会查询邻居项，如果没有会创建一个返回
			neigh = __neigh_lookup_errno(tbl, dst, dev);
			if (IS_ERR(neigh)) {
				err = PTR_ERR(neigh);
				goto out_dev_put;
			}
		} else { // 系统中已有该邻居项，尝试更新它
		    // 更新场景，不能设置EXCL标记
			if (nlh->nlmsg_flags & NLM_F_EXCL) {
				err = -EEXIST;
				neigh_release(neigh);
				goto out_dev_put;
			}
			// 决定了能够覆盖已有邻居项
			if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
				flags &= ~NEIGH_UPDATE_F_OVERRIDE;
		}
        // 更新邻居项
		err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
		neigh_release(neigh);
		goto out_dev_put;
	}

	read_unlock(&neigh_tbl_lock);
	err = -EAFNOSUPPORT;
out_dev_put:
	if (dev)
		dev_put(dev);
out:
	return err;
}

删除邻居项: neigh_delete()

static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
	struct net *net = sock_net(skb->sk);
	struct ndmsg *ndm;
	struct nlattr *dst_attr;
	struct neigh_table *tbl;
	struct net_device *dev = NULL;
	int err = -EINVAL;

	if (nlmsg_len(nlh) < sizeof(*ndm))
		goto out;
    // 找到dst，即key
	dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
	if (dst_attr == NULL)
		goto out;

	ndm = nlmsg_data(nlh);
	if (ndm->ndm_ifindex) { // 解析网络设备索引，并找到网络设备对象
		dev = dev_get_by_index(net, ndm->ndm_ifindex);
		if (dev == NULL) {
			err = -ENODEV;
			goto out;
		}
	}
    // 根据key和网络设备对象找到邻居协议
	read_lock(&neigh_tbl_lock);
	for (tbl = neigh_tables; tbl; tbl = tbl->next) {
		struct neighbour *neigh;

		if (tbl->family != ndm->ndm_family)
			continue;
		read_unlock(&neigh_tbl_lock);

		if (nla_len(dst_attr) < tbl->key_len)
			goto out_dev_put;

		if (ndm->ndm_flags & NTF_PROXY) {
			err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
			goto out_dev_put;
		}

		if (dev == NULL)
			goto out_dev_put;
        // 找到要删除的邻居项
		neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
		if (neigh == NULL) {
			err = -ENOENT;
			goto out_dev_put;
		}
        // 删除邻居项
		err = neigh_update(neigh, NULL, NUD_FAILED,
				   NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN);
		neigh_release(neigh);
		goto out_dev_put;
	}
	read_unlock(&neigh_tbl_lock);
	err = -EAFNOSUPPORT;

out_dev_put:
	if (dev)
		dev_put(dev);
out:
	return err;
}

设置邻居协议参数: neightbl_set()

static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
	struct net *net = sock_net(skb->sk);
	struct neigh_table *tbl;
	struct ndtmsg *ndtmsg;
	struct nlattr *tb[NDTA_MAX+1];
	int err;

	err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
			  nl_neightbl_policy);
	if (err < 0)
		goto errout;

	if (tb[NDTA_NAME] == NULL) {
		err = -EINVAL;
		goto errout;
	}

	ndtmsg = nlmsg_data(nlh);
	read_lock(&neigh_tbl_lock);
	for (tbl = neigh_tables; tbl; tbl = tbl->next) {
		if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
			continue;

		if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0)
			break;
	}

	if (tbl == NULL) {
		err = -ENOENT;
		goto errout_locked;
	}

	/*
	 * We acquire tbl->lock to be nice to the periodic timers and
	 * make sure they always see a consistent set of values.
	 */
	write_lock_bh(&tbl->lock);

	if (tb[NDTA_PARMS]) {
		struct nlattr *tbp[NDTPA_MAX+1];
		struct neigh_parms *p;
		int i, ifindex = 0;

		err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
				       nl_ntbl_parm_policy);
		if (err < 0)
			goto errout_tbl_lock;

		if (tbp[NDTPA_IFINDEX])
			ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);

		p = lookup_neigh_params(tbl, net, ifindex);
		if (p == NULL) {
			err = -ENOENT;
			goto errout_tbl_lock;
		}

		for (i = 1; i <= NDTPA_MAX; i++) {
			if (tbp[i] == NULL)
				continue;

			switch (i) {
			case NDTPA_QUEUE_LEN:
				p->queue_len = nla_get_u32(tbp[i]);
				break;
			case NDTPA_PROXY_QLEN:
				p->proxy_qlen = nla_get_u32(tbp[i]);
				break;
			case NDTPA_APP_PROBES:
				p->app_probes = nla_get_u32(tbp[i]);
				break;
			case NDTPA_UCAST_PROBES:
				p->ucast_probes = nla_get_u32(tbp[i]);
				break;
			case NDTPA_MCAST_PROBES:
				p->mcast_probes = nla_get_u32(tbp[i]);
				break;
			case NDTPA_BASE_REACHABLE_TIME:
				p->base_reachable_time = nla_get_msecs(tbp[i]);
				break;
			case NDTPA_GC_STALETIME:
				p->gc_staletime = nla_get_msecs(tbp[i]);
				break;
			case NDTPA_DELAY_PROBE_TIME:
				p->delay_probe_time = nla_get_msecs(tbp[i]);
				break;
			case NDTPA_RETRANS_TIME:
				p->retrans_time = nla_get_msecs(tbp[i]);
				break;
			case NDTPA_ANYCAST_DELAY:
				p->anycast_delay = nla_get_msecs(tbp[i]);
				break;
			case NDTPA_PROXY_DELAY:
				p->proxy_delay = nla_get_msecs(tbp[i]);
				break;
			case NDTPA_LOCKTIME:
				p->locktime = nla_get_msecs(tbp[i]);
				break;
			}
		}
	}

	if (tb[NDTA_THRESH1])
		tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);

	if (tb[NDTA_THRESH2])
		tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);

	if (tb[NDTA_THRESH3])
		tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);

	if (tb[NDTA_GC_INTERVAL])
		tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);

	err = 0;

errout_tbl_lock:
	write_unlock_bh(&tbl->lock);
errout_locked:
	read_unlock(&neigh_tbl_lock);
errout:
	return err;
}
fanxiaoyu321
关注
专栏目录
WiFi底层通信接口@Netlink
无线互联&网络介绍
07-12 484
WiFi 学习资料整理->Android WiFi Netlink介绍 底层通信入口 Netlink和Wext区别
Android SELinux——Class权限集介绍（七）
最新发布
小旭的专栏
10-14 367
上一篇文章我们介绍了使用 common 关键字定义的一些常用权限集，这里我们来看一下使用 class 关键字对具体的权限集的定义，很多 class 权限集是继承自 common 权限集的。源码位置：/system/sepolicy/private/access_vectors。
linux的netlink接口详解（中）
coder
06-23 2480
本文介绍了linux内核中netlink模块的实现原理，主要包括整体架构和初始化相关
netlink接口
chylovecsd的博客
05-31 728
1、netlink及相关接口说明 说到驱动和应用层进行数据通信，很多人就会想到使用传统的ioctl，诚然，很多时候应用层调用驱动进行参数配置和参数获取使用的也正是ioctl的方式，但这种方式有一种局限性，那就是只适合于数据量较小且操作不频繁的情况。否则，频繁操作io将大大影响设备的性能，甚至造成设备宕机。 最近在做一个关于wifi诊断需求时，需要记录wifi连接过程中的控制帧和管理帧，以及STA断开及断开原因。由于wifi驱动不断在进行数据帧和控制帧的交互，如果直接在驱动...
流量控制Netlink接口
九天小哥的专栏
11-08 893
netlink消息接口注册 显然，netlink接口应该支持流量控制中三个组件的增加、删除和查询操作。对排队规则、类的接口注册在pktsched_init()中完成；对过滤器的接口的注册在tc_filter_init()中完成。 static int __init pktsched_init(void) { // 注册pfifo和bfifo两种排队规则 register_qdisc(&...
Netlink
瑜伽山神的博客
02-16 1882
Netlink套接字家族（英语：Netlink socket family）是一組Linux核心介面（Linux kernel interfaces），可用於行程間通訊，Linux内核与用户空间的进程间、用户进程间的通讯。然而它并不像网络套接字可以用于主机间通讯，Netlink只能用于同一主机上进程通讯，并通过PID来标识它们。 Netlink被设计为在Linux内核与用户空间进程传送各种网络信
linux 内核中Netlink
06-06 3889
netlink内核中实现
linux netlink详解
白日梦想家霍华特的博客
04-29 569
netlink从用户态到内核态原理解析
netlink socket programming
02-24
### Netlink Socket编程详解 #### 一、简介 网络配置在Linux系统中，以及更广泛的Unix实现中，历来都是从程序员的角度来看待的一个事后考虑。...掌握Netlink套接字的使用对于深入理解Linux网络子系统的运作至关重要。
Netlink系列1概述
cjchina的专栏
10-13 1240
netlink用于实现内核间双向通信、用户空间与内核空间的双向通信，是比较优秀的方式之一，例如比ioctl方式要好很多，而且功能更加强大。通俗的讲，Netlink获取\设置：网络接口配置、地址、路由、邻居发现、防火墙、ARP消息、netfilter等众多功能。直到目前,Netli
Netlink与RTNetlink的简单使用
wjj970802的博客
03-27 1428
它是 Linux 系统中管理网络路由的标准接口，通过 RTNetlink，用户空间程序可以实现动态地添加、删除、修改路由表中的路由条目，以及监听路由表的变化。4）nlmsg_seq：消息序列号，用以将消息排队，有些类似TCP协议中的序号（不完全一样），但是netlink的这个字段是可选的，不强制使用；这些消息含有一个ifaddrmsg类型的结构，紧跟在后面的是一系列的rtattr结构。，表示的是路由项是如何产生的，可取的值如下，其中常见的是RTPROT_KERNEL和RTPROT_STAIC。
netlink实现与使用方法详解（用户态/内核态）
weixin_42238049的博客
08-20 1万+
一、什么是netlink Netlink套接字是用以实现用户进程与内核进程通信的一种特殊的进程间通信(IPC) ,也是网络应用程序与内核通信的最常用的接口。 在Linux 内核中，使用netlink 进行应用与内核通信的应用有很多，如 路由 daemon（NETLINK_ROUTE） 用户态 socket 协议（NETLINK_USERSOCK） 防火墙（NETLINK_FIREWALL） netfilter 子系统（NETLINK_NETFILTER） 内核事件向用户态通知（NETLINK_KOBJECT
精通linux内核网络———第二章Netlink套接字之NETLINK_ROUTE消息
youngauthor的博客
06-13 4492
NETLINK_ROUTE消息： renetlink(NETLINK_ROUTE)消息包括众多其他类型的renetlink消息。 NETLINK_ROUTE消息分为很多个消息簇： LINK（网络接口） ADDR(网络地址消息) ROUTE（路由选择消息） NEIGH（邻接子系统消息） RULE（策略路由规则） QDISC（排队准则） TCLASS（流量类别） ACTION（数据包操作API，参见net/sched/act_api.c） NEIGHTBL（邻接表） ADDRLABEL（地址标记） 每个消息簇都
netlink分析介绍
乐于分享
04-20 1246
netlink socket是一种用于用户态进程和内核态进程之间的通信机制。它通过为内核模块提供一组特殊的API，并为用户程序提供了一组标准的socket接口的方式，实现了全双工的通讯连接。 特点： 双向传输，异步通信 用户空间中使用标准socket API 内核空间中使用专门的API 支持多播 可由内核端发起通信 支持32种协议类型 netlink仅支持32种协议类型，这在实际应用中可能并不足够，因此产生了generic netlink（以下简称为genl）， generic netlin.
Linux 网络之netlink 简介
小立仔
11-03 8797
Linux 网络之netlink 简介以及一个简单使用demo
netlink（2）- rtnetlink
gege_hxg的博客
09-24 3490
netlink（2）- rtnetlink： rtnetlink 介绍： 当创建socket时， 协议类型参数选择的是NETLINK_ROUTE, 得到的socket是rtnetlink_socket, 需要使用到rtnetlink. ​ 所有rtnetlink 消息都包含一个netlink消息头和附加属性，rtnetlink 中定义的一组宏就是用于操作这些属性所用。 ​ rtnetlink 除了标准的netlink消息外还包含其它消息类型(如RTM_NEWLINK）, 不同的消息对应的附加属性会有差异，后
ipv6 nd
lizhihong_的博客
12-05 393
return;struct {} request;} else {return 0;
rtnetlink 中文描述
热门推荐
技术随笔
12-16 1万+
Rtnetlink描述 针对路由控制的netlink接口，Linux IPv4 routing sockets Rtnetlink基于netlink，允许对内核的路由表进行读写。主要用来进行内核与用户空间的通信以及内核中子系统间的通信。Rtnetlink是Linux2.2及其以后的版本中的一个新的特征。 Rtnetlink消息在初始头后可以有一些属性。结构： struct {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值