• linux网络协议栈源码分析 - 网络层IP网际协议

    1、IP报文

    1.1、IP报文格式 

            更详细的介绍参考《TCP/IP详解卷 1：协议》第3章 IP：网际协议。

    1.2、IP首部结构体

    1. struct iphdr {
    2. #if defined(__LITTLE_ENDIAN_BITFIELD)
    3. 	__u8	ihl:4,
    4. 		version:4;
    5. #elif defined (__BIG_ENDIAN_BITFIELD)
    6. 	__u8	version:4,
    7.   		ihl:4;
    8. #else
    9. #error	"Please fix "
    10. #endif
    11. 	__u8	tos;
    12. 	__be16	tot_len;
    13. 	__be16	id;
    14. 	__be16	frag_off;
    15. 	__u8	ttl;
    16. 	__u8	protocol;
    17. 	__sum16	check;
    18. 	__be32	saddr;
    19. 	__be32	daddr;
    20. 	/*The options start here. */
    21. };

            3位标志位:

    1. /* IP flags. */
    2. #define IP_CE		0x8000		/* Flag: "Congestion"		*/
    3. #define IP_DF		0x4000		/* Flag: "Don't Fragment"	*/
    4. #define IP_MF		0x2000		/* Flag: "More Fragments"	*/
    5. #define IP_OFFSET	0x1FFF		/* "Fragment Offset" part	*/

    2、IP路由缓存查找

            (参考资料《Linux Kernel Networking -  Implementation and Theory》、机械工业出版社《Linux内核源码剖析：TCP/IP实现(上册)》)

    2.1、输出路由缓存查询(ip_route_output_key)

            __ip_route_output_key_hash返回路由rtable，rtable里面包含路由缓存项dst_entry，对于输出路由，主要用到了路由及路由缓存项的输出函数指针output、网卡设备net_device、网关rt_gateway，__ip_route_output_key_hash调用栈:

              dst_output调用路由缓存的输出函数指针output，然后调用ip_output、ip_finish_output、ip_finish_output2，ip_finish_output2找到路由缓的下一跳(网关或者局域网内的其他主机)，然后调用邻居子系统的dst_neigh_output发送报文，ip_finish_output2邻居查找及报文发送代码实现如下:

            ip_finish_output2函数调用栈如下:

    2.2、输入路由缓存查询(ip_route_input/ip_route_input_noref)

          ip_route_input_slow调用skb_dst_set_noref设置skb的路由缓存，路由缓存dst包含一个输入函数指针，最终调用该输入函数处理输入报文:

            ip_route_input_slow调用栈:

             查找到路由缓存之后，调用dst_input函数，dst_input函数调用路由缓存的input函数处理报文，dst_input调用栈: 

    3、IP报文输出

    3.1、IP报文发送(ip_queue_xmit)

            ip_queue_xmit主要检查skb是否已经设置路由，如果没有就查找路由，如果找不到路由就丢弃报文；有路由就设置IP首部(IP首部的16位总长度、16位首部检验和在下一级函数设置)，调用ip_local_out、rt->dst.output输出IP报文。

            ip_queue_xmit代码实现如下:

    1. int ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
    2. {
    3. 	struct inet_sock *inet = inet_sk(sk);
    4. 	struct net *net = sock_net(sk);
    5. 	struct ip_options_rcu *inet_opt;
    6. 	struct flowi4 *fl4;
    7. 	struct rtable *rt;
    8. 	struct iphdr *iph;
    9. 	int res;
    10.  
    11. 	/* Skip all of this if the packet is already routed,
    12. 	 * f.e. by something like SCTP.
    13. 	 */
    14. 	rcu_read_lock();
    15. 	inet_opt = rcu_dereference(inet->inet_opt);
    16. 	fl4 = &fl->u.ip4;
    17. 	rt = skb_rtable(skb); // skb路由项(输出网卡设备、下一跳地址等)
    18. 	if (rt)
    19. 		goto packet_routed; // 如果已经有路由，那么跳转到packet_routed，使用已经设置好的路由
    20.  
    21. 	/* Make sure we can route this packet. */
    22. 	rt = (struct rtable *)__sk_dst_check(sk, 0); // 获取路由项缓存sk_dst_cache
    23. 	if (!rt) {
    24. 		__be32 daddr;
    25.  
    26. 		/* Use correct destination address if we have options. */
    27. 		daddr = inet->inet_daddr;
    28. 		if (inet_opt && inet_opt->opt.srr)
    29. 			daddr = inet_opt->opt.faddr;
    30.  
    31. 		/* If this fails, retransmit mechanism of transport layer will
    32. 		 * keep trying until route appears or the connection times
    33. 		 * itself out.
    34. 		 */
    35. 		rt = ip_route_output_ports(net, fl4, sk,
    36. 					   daddr, inet->inet_saddr,
    37. 					   inet->inet_dport,
    38. 					   inet->inet_sport,
    39. 					   sk->sk_protocol,
    40. 					   RT_CONN_FLAGS(sk),
    41. 					   sk->sk_bound_dev_if); // 调用ip_route_output_ports、ip_route_output_flow查询输出路由缓存；参考机械工业出版社《Linux内核源码剖析：TCP IP实现(下册)》"第20章 路由缓存"
    42. 		if (IS_ERR(rt))
    43. 			goto no_route; // 没有路由则跳转到no_route，丢弃报文
    44. 		sk_setup_caps(sk, &rt->dst);
    45. 	}
    46. 	skb_dst_set_noref(skb, &rt->dst); // 设置skb->_skb_refdst
    47.  
    48. packet_routed:
    49. 	if (inet_opt && inet_opt->opt.is_strictroute && rt->rt_uses_gateway)
    50. 		goto no_route;
    51.  
    52. 	/* OK, we know where to send it, allocate and build IP header. */
    53. 	skb_push(skb, sizeof(struct iphdr) + (inet_opt ? inet_opt->opt.optlen : 0)); // 获取IP首部在skb里面的地址(如果有选项，需要计算选项的长度，否则为0；从传输层数据之前预留的就是IP首部地址空间)
    54. 	skb_reset_network_header(skb);
    55. 	iph = ip_hdr(skb); // 获取IP首部地址
    56. 	*((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff)); // IP首部前16位为: 4位版本号、4位首部长度、8位服务类型(TOS)；(4 << 12)为4位版本号，IPv4，(5 << 8)为4位首部长度，5*4共20字节(此次没加上选项长度), (inet->tos & 0xff)为8位服务类型(TOS)
    57. 	if (ip_dont_fragment(sk, &rt->dst) && !skb->ignore_df)
    58. 		iph->frag_off = htons(IP_DF); // IP不分片(Don’t Fragment)
    59. 	else
    60. 		iph->frag_off = 0;
    61. 	iph->ttl      = ip_select_ttl(inet, &rt->dst); // 8位生存时间(TTL)
    62. 	iph->protocol = sk->sk_protocol; // 8位协议(IPPROTO_TCP/IPPROTO_UDP)
    63. 	ip_copy_addrs(iph, fl4); // 32位源IP地址
    64.  
    65. 	/* Transport layer set skb->h.foo itself. */
    66.  
    67. 	if (inet_opt && inet_opt->opt.optlen) { // 选项(如果有)
    68. 		iph->ihl += inet_opt->opt.optlen >> 2; // 修正4位首部长度
    69. 		ip_options_build(skb, &inet_opt->opt, inet->inet_daddr, rt, 0); // 拷贝选项
    70. 	}
    71.  
    72. 	ip_select_ident_segs(net, skb, sk,
    73. 			     skb_shinfo(skb)->gso_segs ?: 1); // 16位标识(每个IP报文有唯一的标识，通过16位标识区分是否是一个IP报文的分片)
    74.  
    75. 	/* TODO : should we use skb->sk here instead of sk ? */
    76. 	skb->priority = sk->sk_priority;
    77. 	skb->mark = sk->sk_mark;
    78.  
    79. 	res = ip_local_out(net, sk, skb); // 调用ip_local_out发送IP报文(IP首部的16位总长度在函数__ip_local_out里面设置，16位首部检验和在函数ip_send_check设置)
    80. 	rcu_read_unlock();
    81. 	return res;
    82.  
    83. no_route:
    84. 	rcu_read_unlock();
    85. 	IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
    86. 	kfree_skb(skb);
    87. 	return -EHOSTUNREACH;
    88. }

     3.2、ip_queue_xmit调用栈

            ip_queue_xmit调用栈如下:

    4、IP报文输入

    4.1、IP报文输入流程

            ip_packet_type定义ETH_P_IP报文输入函数:

    1. static struct packet_type ip_packet_type __read_mostly = {
    2. 	.type = cpu_to_be16(ETH_P_IP),
    3. 	.func = ip_rcv,
    4. };

            以太网首部:

    1. struct ethhdr {
    2. 	unsigned char	h_dest[ETH_ALEN];	/* destination eth addr	*/
    3. 	unsigned char	h_source[ETH_ALEN];	/* source ether addr	*/
    4. 	__be16		h_proto;		/* packet type ID field	*/
    5. } __attribute__((packed));

            smsc911x_poll调用eth_type_trans读取以太网首部类型字段并设置接收报文类型skb->protocol:

             __netif_receive_skb_core找到ip_packet_type，并调用输入函数ip_rcv处理输入报文:

             ip_rcv函数调用栈:

     4.2、IP报文校验(ip_rcv)

            ip_rcv校验IP首部各字段、校验和、总长度等，校验通过之后调用ip_rcv_finish继续处理IP报文。

            ip_rcv函数代码实现:

    1. int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
    2. {
    3. 	const struct iphdr *iph;
    4. 	struct net *net;
    5. 	u32 len;
    6.  
    7. 	/* When the interface is in promisc. mode, drop all the crap
    8. 	 * that it receives, do not try to analyse it.
    9. 	 */
    10. 	if (skb->pkt_type == PACKET_OTHERHOST) // eth_type_trans比较以太网首部的目的地址是否是输入网卡的地址，如果不是，设置skb->pkt_type为PACKET_OTHERHOST
    11. 		goto drop; // 丢弃发往其他主机的IP报文
    12.  
    13.  
    14. 	net = dev_net(dev);
    15. 	IP_UPD_PO_STATS_BH(net, IPSTATS_MIB_IN, skb->len);
    16.  
    17. 	skb = skb_share_check(skb, GFP_ATOMIC);
    18. 	if (!skb) {
    19. 		IP_INC_STATS_BH(net, IPSTATS_MIB_INDISCARDS);
    20. 		goto out;
    21. 	}
    22.  
    23. 	if (!pskb_may_pull(skb, sizeof(struct iphdr))) // 报文长度检查(IP首部的长度)
    24. 		goto inhdr_error; // 报文的长度小于IP首部的长度(不包含选项)，也就是不完整的IP报文，或者有其他错误，跳转到inhdr_error
    25.  
    26. 	iph = ip_hdr(skb); // 获取IP首部地址
    27.  
    28. 	/*
    29. 	 *	RFC1122: 3.2.1.2 MUST silently discard any IP frame that fails the checksum.
    30. 	 *
    31. 	 *	Is the datagram acceptable?
    32. 	 *
    33. 	 *	1.	Length at least the size of an ip header
    34. 	 *	2.	Version of 4
    35. 	 *	3.	Checksums correctly. [Speed optimisation for later, skip loopback checksums]
    36. 	 *	4.	Doesn't have a bogus length
    37. 	 */
    38.  
    39. 	if (iph->ihl < 5 || iph->version != 4) // 如果IP首部4位首部长度小于5(IP首部不包含选项至少有5*4个字节数据)，那么4位首部长度错误，跳转到inhdr_error；如果IP首部4位版本不是4(不是IPv4)，那么跳转到inhdr_error
    40. 		goto inhdr_error;
    41.  
    42. 	BUILD_BUG_ON(IPSTATS_MIB_ECT1PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_1);
    43. 	BUILD_BUG_ON(IPSTATS_MIB_ECT0PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_0);
    44. 	BUILD_BUG_ON(IPSTATS_MIB_CEPKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_CE);
    45. 	IP_ADD_STATS_BH(net,
    46. 			IPSTATS_MIB_NOECTPKTS + (iph->tos & INET_ECN_MASK),
    47. 			max_t(unsigned short, 1, skb_shinfo(skb)->gso_segs));
    48.  
    49. 	if (!pskb_may_pull(skb, iph->ihl*4)) // 报文长度检查(IP首部长度(包含选项))
    50. 		goto inhdr_error; // 报文长度不够IP首部长度(包含选项)或者其他错误，跳转到inhdr_error
    51.  
    52. 	iph = ip_hdr(skb); // 获取IP首部地址
    53.  
    54. 	if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl))) // 16位首部检验和校验(包含选项)
    55. 		goto csum_error; // 16位首部检验和校验失败，跳转到csum_error
    56.  
    57. 	len = ntohs(iph->tot_len); // 16位总长度(字节数)
    58. 	if (skb->len < len) { // 报文总长度小于16位总长度
    59. 		IP_INC_STATS_BH(net, IPSTATS_MIB_INTRUNCATEDPKTS);
    60. 		goto drop; // 跳转到drop，丢弃报文
    61. 	} else if (len < (iph->ihl*4)) // 报文长度检查(IP首部长度(包含选项))
    62. 		goto inhdr_error; // 报文长度不够IP首部长度(包含选项)或者其他错误，跳转到inhdr_error
    63.  
    64. 	/* Our transport medium may have padded the buffer out. Now we know it
    65. 	 * is IP we can trim to the true length of the frame.
    66. 	 * Note this now means skb->len holds ntohs(iph->tot_len).
    67. 	 */
    68. 	if (pskb_trim_rcsum(skb, len)) { // 删除SKB尾部的数据(len之后的数据)
    69. 		IP_INC_STATS_BH(net, IPSTATS_MIB_INDISCARDS);
    70. 		goto drop;
    71. 	}
    72.  
    73. 	skb->transport_header = skb->network_header + iph->ihl*4; // 获取传输层首部
    74.  
    75. 	/* Remove any debris in the socket control block */
    76. 	memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
    77.  
    78. 	/* Must drop socket now because of tproxy. */
    79. 	skb_orphan(skb);
    80.  
    81. 	return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
    82. 		       net, NULL, skb, dev, NULL,
    83. 		       ip_rcv_finish); // 调用ip_rcv_finish
    84.  
    85. csum_error:
    86. 	IP_INC_STATS_BH(net, IPSTATS_MIB_CSUMERRORS);
    87. inhdr_error:
    88. 	IP_INC_STATS_BH(net, IPSTATS_MIB_INHDRERRORS);
    89. drop:
    90. 	kfree_skb(skb);
    91. out:
    92. 	return NET_RX_DROP;
    93. }

    4.3、输入路由查找(ip_rcv_finish)

            物理层只管物理地址不管IP地址，IP报文校验完整之后还得调用ip_route_input_noref查找输入路由，看看是否有输入路由(发往本地或者转发)，如果没有输入路由则丢弃报文，否则调用dst_input根据路由处理报文(发往本地或者转发)。

            ip_rcv_finish函数实现代码如下:

    1. static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
    2. {
    3. 	const struct iphdr *iph = ip_hdr(skb);
    4. 	struct rtable *rt;
    5.  
    6. 	if (sysctl_ip_early_demux &&
    7. 	    !skb_dst(skb) &&
    8. 	    !skb->sk &&
    9. 	    !ip_is_fragment(iph)) {
    10. 		const struct net_protocol *ipprot;
    11. 		int protocol = iph->protocol;
    12.  
    13. 		ipprot = rcu_dereference(inet_protos[protocol]);
    14. 		if (ipprot && ipprot->early_demux) {
    15. 			ipprot->early_demux(skb);
    16. 			/* must reload iph, skb->head might have changed */
    17. 			iph = ip_hdr(skb);
    18. 		}
    19. 	}
    20.  
    21. 	/*
    22. 	 *	Initialise the virtual path cache for the packet. It describes
    23. 	 *	how the packet travels inside Linux networking.
    24. 	 */
    25. 	if (!skb_valid_dst(skb)) { // 没有输入路由缓存
    26. 		int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
    27. 					       iph->tos, skb->dev); // 查找输入路由
    28. 		if (unlikely(err)) { // 没有输入路由
    29. 			if (err == -EXDEV)
    30. 				NET_INC_STATS_BH(net, LINUX_MIB_IPRPFILTER);
    31. 			goto drop; // 跳转到drop，丢弃报文
    32. 		}
    33. 	}
    34.  
    35. #ifdef CONFIG_IP_ROUTE_CLASSID
    36. 	if (unlikely(skb_dst(skb)->tclassid)) {
    37. 		struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
    38. 		u32 idx = skb_dst(skb)->tclassid;
    39. 		st[idx&0xFF].o_packets++;
    40. 		st[idx&0xFF].o_bytes += skb->len;
    41. 		st[(idx>>16)&0xFF].i_packets++;
    42. 		st[(idx>>16)&0xFF].i_bytes += skb->len;
    43. 	}
    44. #endif
    45.  
    46. 	if (iph->ihl > 5 && ip_rcv_options(skb)) // 4位首部长度大于5(包含选项)，处理选项
    47. 		goto drop; // 选项处理失败，跳转到drop，丢弃报文
    48.  
    49. 	rt = skb_rtable(skb);
    50. 	if (rt->rt_type == RTN_MULTICAST) {
    51. 		IP_UPD_PO_STATS_BH(net, IPSTATS_MIB_INMCAST, skb->len);
    52. 	} else if (rt->rt_type == RTN_BROADCAST)
    53. 		IP_UPD_PO_STATS_BH(net, IPSTATS_MIB_INBCAST, skb->len);
    54.  
    55. 	return dst_input(skb); // 调用dst_input处理输入报文
    56.  
    57. drop:
    58. 	kfree_skb(skb);
    59. 	return NET_RX_DROP;
    60. }

            ip_local_deliver调用栈:

    4.4、报文发送到传输层(ip_local_deliver_finish) 

            对于发送本地的报文，调用ip_local_deliver、ip_local_deliver_finish，ip_local_deliver_finish根据IP首部的8位协议找到传输层对应协议的输入处理函数，调用传输层的处理函数处理传输层报文，对于IPv4的TCP协议就是tcp_v4_rcv。

            ip_local_deliver_finish函数代码实现如下:

    1. static int ip_local_deliver_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
    2. {
    3. 	__skb_pull(skb, skb_network_header_len(skb));
    4.  
    5. 	rcu_read_lock();
    6. 	{
    7. 		int protocol = ip_hdr(skb)->protocol; // 8位协议(IPPROTO_TCP/IPPROTO_UDP/IPPROTO_RAW...)
    8. 		const struct net_protocol *ipprot;
    9. 		int raw;
    10.  
    11. 	resubmit:
    12. 		raw = raw_local_deliver(skb, protocol);
    13.  
    14. 		ipprot = rcu_dereference(inet_protos[protocol]); // 获取传输层的net_protocol(tcp_protocol/udp_protocol...)
    15. 		if (ipprot) {
    16. 			int ret;
    17.  
    18. 			if (!ipprot->no_policy) {
    19. 				if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
    20. 					kfree_skb(skb);
    21. 					goto out;
    22. 				}
    23. 				nf_reset(skb);
    24. 			}
    25. 			ret = ipprot->handler(skb); // 调用传输层的处理函数(tcp_v4_rcv/udp_rcv...)
    26. 			if (ret < 0) {
    27. 				protocol = -ret;
    28. 				goto resubmit;
    29. 			}
    30. 			IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
    31. 		} else {
    32. 			if (!raw) {
    33. 				if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
    34. 					IP_INC_STATS_BH(net, IPSTATS_MIB_INUNKNOWNPROTOS);
    35. 					icmp_send(skb, ICMP_DEST_UNREACH,
    36. 						  ICMP_PROT_UNREACH, 0);
    37. 				}
    38. 				kfree_skb(skb);
    39. 			} else {
    40. 				IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
    41. 				consume_skb(skb);
    42. 			}
    43. 		}
    44. 	}
    45.  out:
    46. 	rcu_read_unlock();
    47.  
    48. 	return 0;
    49. }

            ip_local_deliver_finish调用栈:

     

  • 相关阅读:
    2022年11月21日13:32:00——T5——JS对象与Date日期函数
    13个培训师游戏
    汽车称重软件系统配置（一）
    什么是 SEO 垃圾邮件攻击？
    20221121 秩相同，值域不一定相同
    蓝桥杯中级题目之组合（c++）
    【C/C++笔试练习】常见进制转换、宏的定义和特点、sizeof与strlen、字符串函数、统计回文、连续最大和
    《热题100》字符串、双指针、贪心算法篇
    MySQL锁(乐观锁、悲观锁、多粒度锁)
    C++ map和set的使用
  • 原文地址：https://blog.csdn.net/arm7star/article/details/126130896