Linux中处理需要传输的IP报文流程

本文主要讲解了Linux中处理需要传输的IP报文流程，使用的内核的版本是2.6.32.27

为了方便理解，本文采用整体流程图加伪代码的方式对Linux中处理需要传输的IP报文流程进行了讲解，希望可以对大家有所帮助。阅读本文章假设大家对C语言有了一定的了解

首先从IP的更高层传输层看看是如何管理的

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

/*四层协议的注册，都注册为net_protocol结构，并hash到inet_protos表中进行统一管理*/
#ifdef CONFIG_IP_MULTICAST
static const struct net_protocol igmp_protocol = {
	.handler =	igmp_rcv,
	.netns_ok =	1,
};
#endif

static const struct net_protocol tcp_protocol = {
	.handler =	tcp_v4_rcv,
	.err_handler =	tcp_v4_err,
	.gso_send_check = tcp_v4_gso_send_check,
	.gso_segment =	tcp_tso_segment,
	.gro_receive =	tcp4_gro_receive,
	.gro_complete =	tcp4_gro_complete,
	.no_policy =	1,
	.netns_ok =	1,
};

static const struct net_protocol udp_protocol = {
	.handler =	udp_rcv,
	.err_handler =	udp_err,
	.gso_send_check = udp4_ufo_send_check,
	.gso_segment = udp4_ufo_fragment,
	.no_policy =	1,
	.netns_ok =	1,
};

static const struct net_protocol icmp_protocol = {
	.handler =	icmp_rcv,
	.no_policy =	1,
	.netns_ok =	1,
};

static int __init inet_init(void)
{
	/*
	 *	Add all the base protocols.
	 */
	if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
		printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
	if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
		printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
	if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
		printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
#ifdef CONFIG_IP_MULTICAST
	if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
		printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n");
#endif
}

在4层处理完成之后，4层会调用IP层的接口ip_qeueu_xmit进行
报文发送

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

/*ipv4.c中注册的让上层协议使用的接口*/
static const struct inet_connection_sock_af_ops dccp_ipv4_af_ops = {
	.queue_xmit	   = ip_queue_xmit,
};

/*将dccp_ipv4_af_ops注册到协议中*/
static int dccp_v4_init_sock(struct sock *sk)
{
	inet_csk(sk)->icsk_af_ops = &dccp_ipv4_af_ops;
}

/*TCP数据报文发送函数*/
static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,   gfp_t gfp_mask)
{
	const struct inet_connection_sock *icsk = inet_csk(sk);

	/*使用ip_queue_xmit发送数据报文*/
	err = icsk->icsk_af_ops->queue_xmit(skb, 0);

}

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

int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
{
	struct sock *sk = skb->sk;
	struct inet_sock *inet = inet_sk(sk);
	struct ip_options *opt = inet->opt;
	struct rtable *rt;
	struct iphdr *iph;

	/*检查套接字结构中sk->dst中是否有一个指针指向路由缓存中的某个入口项
	 *如果有，再检查这个指针是否有效，由于套接字的所有包都去往同一个目标
	 *地址，因此路由就存放在skb->_skb_dst中，内容为dst_entry结构
	 */

	rt = skb_rtable(skb);
	if (rt != NULL)
		goto packet_routed;

	rt = (struct rtable *)__sk_dst_check(sk, 0);
	{
		if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL)
		{
			sk->sk_dst_cache = NULL;
			dst_release(dst);
			return NULL;
		}
	}

	/*如果尚未设置路由，那么使用ip_route_output_flow进行路由选路*/
	if (rt == NULL)
	{
		//......
			if (ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 0))
				goto no_route;
	}

	//......
packet_routed:
	/*填充IP报头*/
	//.....
	iph->ttl      = ip_select_ttl(inet, &rt->u.dst);
	iph->protocol = sk->sk_protocol;
	iph->saddr    = rt->rt_src;
	iph->daddr    = rt->rt_dst;

	/*填充IP选项*/
	if (opt && opt->optlen) {
		iph->ihl += opt->optlen >> 2;
		ip_options_build(skb, opt, inet->daddr, rt, 0);
	}

	//......
	return ip_local_out(skb);

no_route:
	//.....
}

int ip_local_out(struct sk_buff *skb)
{
	int err;

	err = __ip_local_out(skb);
	if (likely(err == 1))
		err = dst_output(skb);

	return err;
}

int __ip_local_out(struct sk_buff *skb)
{
	struct iphdr *iph = ip_hdr(skb);

	iph->tot_len = htons(skb->len);
	ip_send_check(iph);

	/*进入 NF_INET_LOCAL_OUT 的序列钩子进行处理，处理之后放入dst_output中处理*/
	return nf_hook(PF_INET, NF_INET_LOCAL_OUT, skb, NULL, skb_dst(skb)->dev,
		       dst_output);
}

static inline int dst_output(struct sk_buff *skb)
{
	/*调用dst_entry中注册的output函数，IP单播也就是ip_output函数*/
	return skb_dst(skb)->output(skb);
}

/*在__mkroute_output中曾经对output和input进行过注册*/
static int __mkroute_output(struct rtable **result,
			    struct fib_result *res,
			    const struct flowi *fl,
			    const struct flowi *oldflp,
			    struct net_device *dev_out,
			    unsigned flags)
{
	struct rtable *rth;
	rth->u.dst.output=ip_output;

	if (flags & RTCF_LOCAL) {
		rth->u.dst.input = ip_local_deliver;
	}

	if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
		if (flags & RTCF_LOCAL &&   !(dev_out->flags & IFF_LOOPBACK))
		{
			rth->u.dst.output = ip_mc_output;
		}
		if (res->type == RTN_MULTICAST)
		{
			rth->u.dst.input = ip_mr_input;
			rth->u.dst.output = ip_mc_output;
		}
	}
}

/*IPV4单播*/
int ip_output(struct sk_buff *skb)
{
	struct net_device *dev = skb_dst(skb)->dev;

	skb->dev = dev;
	skb->protocol = htons(ETH_P_IP);

	/*经过 NF_INET_POST_ROUTING 处理链后，进入ip_finish_output处理*/
	return NF_HOOK_COND(PF_INET, NF_INET_POST_ROUTING, skb, NULL, dev,
			    ip_finish_output,
			    !(IPCB(skb)->flags & IPSKB_REROUTED));
}

static int ip_finish_output(struct sk_buff *skb)
{
	/*IP分片后，进入ip_finish_output2处理*/
	if (skb->len > ip_skb_dst_mtu(skb) && !skb_is_gso(skb))
		return ip_fragment(skb, ip_finish_output2);
	else
		return ip_finish_output2(skb);
}

static inline int ip_finish_output2(struct sk_buff *skb)
{
	/*如果没有二层头，启用ARP处理*/
	if (dst->hh)
		return neigh_hh_output(dst->hh, skb);
	/*如果有二层头进行处理，侧使用dst->neighbour->output也就是 dev_queue_xmit*/
	else if (dst->neighbour)
		return dst->neighbour->output(skb);
}

/*dev_queue_xmit在ARP中的注册过程如下*/
static const struct neigh_ops arp_hh_ops = {
	.family =		AF_INET,
	.output =		neigh_resolve_output,
	.hh_output =	dev_queue_xmit,
};

static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,   __be16 protocol)
{
	struct hh_cache	*hh;

	//......

	if (n->nud_state & NUD_CONNECTED)
		hh->hh_output = n->ops->hh_output; /*也就是dev_queue_xmit*/
	else
		hh->hh_output = n->ops->output;

	//......
}

最终一路从ip_queue_xmit进行发送调用到二层发送的入口点dev_queue_xmit

关于处理流程的整体架构图，请参见我的上一篇博客

<<Linux内核IP层的报文处理流程--从网卡接收的报文处理流程>>

关于二层是如何继续处理报文并发送的，请参考博客

<<Linux内核数据包的发送传输>>

希望大家批评指正