linux内核协议栈 IPv4之接收数据包流程

目录

1 ip报文接收 ip_rcv()

2 路由查询 ip_rcv_finish()

2.1 报文分发 dst_input 

3 数据包发送至本机 ip_local_delivery()

3.1 通过 LOCAL_IN 校验 ip_local_deliver_finish()

4 数据包转发出去 ip_forward()

4.1 通过 FORWARD 校验 ip_forward_finish()

---

1 ip报文接收 ip_rcv()

当设备接口层处理完输入数据包后，如果发现该报文应该由IP协议进一步处理，那么将会调用ip_rcv()函数。该接口完成对网络层数据包的校验和解析，之后通过netfilter模块和路由模块将处理后的数据包或转发或转给本机4层继续解析。核心流程如下：

1. 设备接口层处理完数据包后，调用ip_rcv()将数据包交由IP层继续处理；
2. IP层首先做些简单的校验后，就尝试过 netfilter 的 PREROUTING 点；
3. PREROUTING 点通过后，进行路由查询，决定是将数据包递交给本机，还是转发；
4. 对于递交给本机的数据包，过 LOCAL_IN 点，然后根据 IP 首部的协议字段，查找高层协议处理函数，然后调用该函数，将数据包交给高层协议继续处理；
5. 对于需要转发的数据包，根据转发的需要，修改IP首部内容（TTL），然后过FORWARD点，最后走和本机发送数据包一样的流程将数据包转发出去。

主要涉及如下文件：

源代码路径	说明
net/ipv4/ip_input.c	IP协议输入报文处理过程
net/ipv4/ip_forward.c	IP协议转发报文处理过程

我们知道，设备接口层在最后会在 netif_receive_skb() 函数中，根据 skb- >protocol 字段查表，将skb递交给更高层的协议处理，对于 IPv4 来讲，其注册的接收函数就是 ip_rcv()：这里主要完成对 ip 报文的校验工作，这里强调一下：混杂模式收上来的包会在ip层丢弃（skb->pkt_type == PACKET_OTHERHOST），skb->pkt_type 的由驱动通过调用 eth_type_trans()函数进行设置。

@skb: 数据包
@dev：数据包的当前输入网络设备（层二可能会使用一些聚合技术）
@pt：数据包的类型
@orig_dev: 接收数据包的原始网络设备
int ip_rcv(struct sk_buff *skb, struct net_device *dev,
	struct packet_type *pt, struct net_device *orig_dev)
{
	struct iphdr *iph;
	u32 len;

	if (dev->nd_net != &init_net)
		goto drop;

	/* When the interface is in promisc. mode, drop all the crap
	 * that it receives, do not try to analyse it.
	 */
    // 在混杂模式下，发往其它主机的一些数据包有可能会到达这里，IPv4并不关注这种包，忽略它们
    //skb->pkt_type 在 eth_type_trans()函数中设置。
	if (skb->pkt_type == PACKET_OTHERHOST)
		goto drop;

	IP_INC_STATS_BH(IPSTATS_MIB_INRECEIVES);
	// 因为后面可能会修改SKB描述符的内容，所以如果该SKB描述符是被共享的(其users成员不为1)，
    // 那么复制一个新的，然后返回，后面的接收处理过程都是用该新的SKB
	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
		IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);
		goto out;
	}
	// 确保skb线性区域中至少有IP首部长度个字节的数据
	if (!pskb_may_pull(skb, sizeof(struct iphdr)))
		goto inhdr_error;
	// pskb_may_pull()可能会调整内存，所以iph需要重新指向
	iph = ip_hdr(skb);

	/*
	 *	RFC1122: 3.1.2.2 MUST silently discard any IP frame that fails the checksum.
	 *
	 *	Is the datagram acceptable?
	 *
	 *	1.	Length at least the size of an ip header
	 *	2.	Version of 4
	 *	3.	Checksums correctly. [Speed optimisation for later, skip loopback checksums]
	 *	4.	Doesn't have a bogus length
	 */
	// 1&2：检查首部长度和IP协议版本号
	if (iph->ihl < 5 || iph->version != 4)
		goto inhdr_error;
	// 这里之所以又做一遍，是因为IP首部可能还有选项部分,iph->ihl*4是IP报文的真实首部长度
	if (!pskb_may_pull(skb, iph->ihl*4))
		goto inhdr_error;
	// 同上，SKB内部指针可能已经发生变化，所以iph需要重新指向
	iph = ip_hdr(skb);
	// 检查IP首部的校验和，确保接收数据传输无误
	if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
		goto inhdr_error;
	
    // 校验IP数据包的总长度
	len = ntohs(iph->tot_len);
	if (skb->len < len) {
		IP_INC_STATS_BH(IPSTATS_MIB_INTRUNCATEDPKTS);
		goto drop;
	} else if (len < (iph->ihl*4))
		goto inhdr_error;

	/* Our transport medium may have padded the buffer out. Now we know it
	 * is IP we can trim to the true length of the frame.
	 * Note this now means skb->len holds ntohs(iph->tot_len).
	 */
    // 如注释所述，层二有可能会在IP数据包上打padding，所这里知道了IP数据包的总长度，
    // 需要对SKB的长度字段进行调整并重新计算校验和
	if (pskb_trim_rcsum(skb, len)) {
		IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);
		goto drop;
	}

	// 将IP控制块内容全部清零，后面IP层处理过程中会使用该控制块数据结构
	memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
	// 数据包进入PREROUTING链，如果通过该链，则将数据包传递给ip_rcv_finish()继续处理
	return NF_HOOK(PF_INET, NF_INET_PRE_ROUTING, skb, dev, NULL, ip_rcv_finish);

inhdr_error:
	IP_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
drop:
	kfree_skb(skb);
out:
	return NET_RX_DROP;
}

从上面可以看出，ip_rcv()仅仅是对IP数据包做一些基本的校验（长度检查、检验和等），并没有做任何选项、分段以及路由相关的任何处理。函数最后通过 PREROUTING 点，这里假设防火墙放行了该数据包，调用 ip_rcv_finish() 继续处理。

2 路由查询 ip_rcv_finish()

数据的IP报文安全通过 netfilter 的 PREROUTING 点后，就会调用ip_rcv_finish()函数，该接口主要是查找路由确定报文时分发出去还是传给上层继续解析。

static int ip_rcv_finish(struct sk_buff *skb)
{
	const struct iphdr *iph = ip_hdr(skb);
	struct rtable *rt;

	/*
	 *	Initialise the virtual path cache for the packet. It describes
	 *	how the packet travels inside Linux networking.
	 */
    // 如果数据包还没有目的路由，则通过路由子系统的ip_route_input()查询路由，
    // 进而决定该数据包的去向
	if (skb->dst == NULL) {
		// 路由查询失败，那么会更新统计信息后丢弃数据包
		int err = ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, skb->dev);
		if (unlikely(err)) {
			if (err == -EHOSTUNREACH)
				IP_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
			else if (err == -ENETUNREACH)
				IP_INC_STATS_BH(IPSTATS_MIB_INNOROUTES);
			goto drop;
		}
	}
	// 如果该数据包包含IP选项，则解析这些选项并进行一定的处理
	if (iph->ihl > 5 && ip_rcv_options(skb))
		goto drop;
	// 根据目的路由信息，如果需要，更新多播和广播统计
	rt = (struct rtable*)skb->dst;
	if (rt->rt_type == RTN_MULTICAST)
		IP_INC_STATS_BH(IPSTATS_MIB_INMCASTPKTS);
	else if (rt->rt_type == RTN_BROADCAST)
		IP_INC_STATS_BH(IPSTATS_MIB_INBCASTPKTS);
	// 根据目的路由进行向上分发，或者是转发
	return dst_input(skb);
drop:
	kfree_skb(skb);
	return NET_RX_DROP;
}

2.1 报文分发 dst_input 

该函数做的最重要的事情就是路由查找，通过路由查询，决定数据包是继续交由本机的高层协议处理，还是走转发流程，不同的路由是由 dst_input() 函数决定的：如果数据是输入本机的，input函数为ip_local_delivery()；如果是转发的，input函数为ip_forward()。

/* Input packet from network to transport.  */
static inline int dst_input(struct sk_buff *skb)
{
    // 调用skb中的目的路由信息中的input()继续处理，SKB中的dst信息实际上就是前面的ip_route_input()查询
    // 路由表时设置好的，所以说，查询路由表就是要获取一个dst信息并将其设置到skb中
	return skb_dst(skb)->input(skb);
}

3 数据包发送至本机 ip_local_delivery()

/*
 * 	Deliver IP Packets to the higher protocol layers.
 */
int ip_local_deliver(struct sk_buff *skb)
{
	// 首先检查该IP数据报是否是分片，如果是则要调用ip_defrag()尝试进行组装，组装成功则继续处理，
    // 否则需要先进行缓存等待其它分组的到达
	if (ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)) {
		if (ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER))
			return 0;
	}
	// 进入LOCAL_IN HOOK点,如果通过则调用ip_local_deliver_finish()继续处理
	return NF_HOOK(PF_INET, NF_INET_LOCAL_IN, skb, skb->dev, NULL, ip_local_deliver_finish);
}

3.1 通过 LOCAL_IN 校验 ip_local_deliver_finish()

这里我们假设数据包能够通过LOCAL_IN，继续看 ip_local_deliver_finish() 的处理。

static int ip_local_deliver_finish(struct sk_buff *skb)
{
	// 在skb中将IP首部删掉
	__skb_pull(skb, ip_hdrlen(skb));
    // 设置skb->transport_header指针使其指向SKB的data开始位置，这样方便更高层协议处理
	skb_reset_transport_header(skb);

	rcu_read_lock();
	{
    	// 取出IP首部的协议字段，根据该字段寻找对应的上层协议
		int protocol = ip_hdr(skb)->protocol;
		int hash, raw;
		struct net_protocol *ipprot;

	resubmit:
    	// 网络层 RAW 套接字处理
		raw = raw_local_deliver(skb, protocol);
		// 计算好哈希值
		hash = protocol & (MAX_INET_PROTOS - 1);
        // 从inet_protos数组中寻找上层协议提供的接收处理回调，在协议族初始化时，
        // 所有的上层协议都会将自己的接收处理接口注册到该数组中
		if ((ipprot = rcu_dereference(inet_protos[hash])) != NULL) {
			int ret;
			// IPSec相关的检查，忽略
			if (!ipprot->no_policy) {
				if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
					kfree_skb(skb);
					goto out;
				}
				nf_reset(skb);
			}
            // 调用传输层接口处理，对于TCP是tcp_v4_rcv()
			ret = ipprot->handler(skb);
            // 如果上层的处理返回错误，这里会将错误码作为协议号，重新执行上述流程，
            // 这一般会匹配到ICMP模块进行处理
			if (ret < 0) {
				protocol = -ret;
				goto resubmit;
			}
			IP_INC_STATS_BH(IPSTATS_MIB_INDELIVERS);
		} else {
			if (!raw) {
				if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
					IP_INC_STATS_BH(IPSTATS_MIB_INUNKNOWNPROTOS);
					icmp_send(skb, ICMP_DEST_UNREACH,
						  ICMP_PROT_UNREACH, 0);
				}
			} else
				IP_INC_STATS_BH(IPSTATS_MIB_INDELIVERS);
            // 没有对应的上层协议时，需要丢弃该数据包
			kfree_skb(skb);
		}
	}
 out:
	rcu_read_unlock();
	return 0;
}

4 数据包转发出去 ip_forward()

int ip_forward(struct sk_buff *skb)
{
	struct iphdr *iph;	/* Our header */
	struct rtable *rt;	/* Route we use */
	struct ip_options * opt	= &(IPCB(skb)->opt);
	// IPSec相关检查，忽略
	if (!xfrm4_policy_check(NULL, XFRM_POLICY_FWD, skb))
		goto drop;
	// 如果有路由告警信息，处理成功后直接返回，不再转发这种数据包
	if (IPCB(skb)->opt.router_alert && ip_call_ra_chain(skb))
		return NET_RX_SUCCESS;

	// 确保该数据包确实是让自己转发的
	if (skb->pkt_type != PACKET_HOST)
		goto drop;
	// 转发会修改IP的首部字段，所以需要把检验和设置为CHECKSUM_NONE
	skb_forward_csum(skb);

	/*
	 *	According to the RFC, we must first decrease the TTL field. If
	 *	that reaches zero, we must reply an ICMP control message telling
	 *	that the packet's lifetime expired.
	 */
    // 如果TTL已经减为1，那么向发送段回复生命周期太短的ICMP报文
	if (ip_hdr(skb)->ttl <= 1)
		goto too_many_hops;
	// IPSec相关，忽略
	if (!xfrm4_route_forward(skb))
		goto drop;

	// 严格源路由选项检查
	rt = (struct rtable*)skb->dst;
	if (opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
		goto sr_failed;
	// IP分片相关处理
	if (unlikely(skb->len > dst_mtu(&rt->u.dst) && !skb_is_gso(skb) &&
		     (ip_hdr(skb)->frag_off & htons(IP_DF))) && !skb->local_df) {
		IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
		icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(dst_mtu(&rt->u.dst)));
		goto drop;
	}

	/* We are about to mangle packet. Copy it! */
	if (skb_cow(skb, LL_RESERVED_SPACE(rt->u.dst.dev)+rt->u.dst.header_len))
		goto drop;
	iph = ip_hdr(skb);

    // 递减TTL
	ip_decrease_ttl(iph);

	/*
	 *	We now generate an ICMP HOST REDIRECT giving the route
	 *	we calculated.
	 */
    // 路由重定向选项处理
	if (rt->rt_flags&RTCF_DOREDIRECT && !opt->srr && !skb->sp)
		ip_rt_send_redirect(skb);

	// 根据TOS字段转换出优先级
	skb->priority = rt_tos2priority(iph->tos);

	// 进入FORWARD链，如果通过调用ip_forward_finish()完成转发过程处理
	return NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, rt->u.dst.dev,
		       ip_forward_finish);

sr_failed:
	/*
	 *	Strict routing permits no gatewaying
	 */
	 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0);
	 goto drop;

too_many_hops:
	/* Tell the sender its packet died... */
	IP_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
	icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0);
drop:
	kfree_skb(skb);
	return NET_RX_DROP;
}

4.1 通过 FORWARD 校验 ip_forward_finish()

假设通过了 FORWARD，继续看 ip_forward_finish() 的处理：

static int ip_forward_finish(struct sk_buff *skb)
{
	struct ip_options * opt	= &(IPCB(skb)->opt);

	IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
	// 处理转发选项
	if (unlikely(opt->optlen))
		ip_forward_options(skb);
	// 直接调用路由输出，指向的应该是ip_output()或者ip_mc_output()
	return dst_output(skb);
}

到 dst_output()，那么就和输出过程吻合了，后续流程和本机的正常发包一样了，这里不再继续展开。