【lwip】09-IPv4协议&超全源码实现分析

前言
9.1 IP协议简述
9.2 IP地址分类
9.3 IP数据报
9.4 IP首部数据结构
9.5 网卡路由
9.6 IP层数据流图
9.7 IP层输出
9.8 IP层输入

前言

默认主讲ipv4。

概念性的内容简单过一遍即可，主要还是在源码实现方面。

原文：李柱明博客：https://www.cnblogs.com/lizhuming/p/16859723.html

9.1 IP协议简述

IP 协议（Internet Protocol），又称之为网际协议，IP 协议处于 IP 层工作，它是整个 TCP/IP 协议栈的核心协议，上层协议都要依赖 IP 协议提供的服务，IP 协议负责将数据报从源主机发送到目标主机，通过 IP 地址作为唯一识别码。

IP 协议是一种无连接的不可靠数据报交付协议，协议本身不提供任何的错误检查与恢复机制。

IP地址是协议地址，MAC地址是硬件地址，所处的层级不一样。

常见的广域网路由器就工作在IP层。

在本次笔记lwip源码实现分析内容概述：

IP地址及其分类、特殊IP地址；
子网划分、子网掩码、NAT等概念；
IP层数据包结构一级数据报输入处理；
IP层数据包的发送及分片操作；
IP层分片数据重装过程。

9.2 IP地址分类

A类地址：1.0.0.1—126.155.255.254

B类地址：128.0.0.1—191.255.255.254

C类地址：192.0.0.1—223.255.255.254

D类地址：224.0.0.1—239.255.255.254

E类地址：240.0.0.1—255.255.255.254

具体更加细致的地址作用，自行百度。

9.2.1 私有地址

A类的：10.x.x.x 是私有地址。

B类的：172.16.0.0—172.31.255.255 是私有地址。

C类的：全都是。192.0.0.1—223.255.255.254 是私有地址。

9.2.2 受限广播地址

受限广播地址是网络号与主机号都为 1 的地址：255.255.255.255

为了避免这个广播地址往整个互联网里发送广播包，在任何情况下，路由器都会禁止转发目的地址为 255.255.255.255 的广播数据包，要不然会给整个互联网带来网络性灾难。

9.2.3 直接广播地址

直接广播地址是主机号全为 1 而得到的地址，广播地址代表本网络内的所有主机，使用该地址可以向网络内的所有主机发送数据。

A 类地址的广播地址为：XXX.255.255.255

B 类地址的广播地址为：XXX.XXX.255.255

C 类地址的广播地址为：XXX.XXX.XXX.255

9.2.4 多播地址

多播地址属于分类编址中的 D 类地址，D 类地址只能用作目的地址，而不能作为主机中的源地址。

多播地址用在一对多的通信。

9.2.5 环回地址

127.x.x.x 是保留地址，用作循环测试用（127.0.0.1 为保留地址，一般用于环回地址）

9.2.6 本地链路地址

169.254.x.x 是本地链路地址。

AUTOIP协议使用。

即是如果 IP 地址是自动获取 IP 地址，而在网络上又没有找到可用的 DHCP 服务器，就会得到其中一个 IP。

9.2.7 本网络本主机地址

IP 地址 32bit 全为 0 的地址（0.0.0.0）表示的是本网络本主机，只能做源IP地址。

在当设备启动时但又不知道自己的 IP 地址情况下常见。

9.2.8 子网

子网掩码 & 判断是否在同一子网：

IP 与子网掩码做按位与，就可以得出该 IP 的子网网段。

如：

子网掩码：255.255.255.0
IP-1: 192.168.1.2 & 255.255.255.0 = 192.168.1.0
IP-2: 192.168.1.123 & 255.255.255.0 = 192.168.1.0
IP-3: 192.168.2.123 & 255.255.255.0 = 192.168.2.0
因为 192.168.1.0 = 192.168.1.0，所以IP-1与IP-2处于同一子网。
因为 192.168.1.0 != 192.168.2.0，所以IP-1与IP-3不在同一子网。

在发数据包时，子网的作用：

若源IP和目标IP在同一子网：直接获取目标IP主机的MAC，然后把数据包丢出去。
若源IP和目标IP不在同一子网：获取默认网关的 MAC ，然后把数据包丢给默认网关那边。

9.2.9 NAT 概念

在计算机网络中，网络地址转换(Network Address Translation，缩写为 NAT)，也叫做网络掩蔽或者 IP 掩蔽(IP masquerading)。

当前只需要知道NAT就是网络地址转换的作用即可，详细技术细节自行百度。

9.3 IP数据报

9.3.1 版本号字段

占用4 bit。

这个字段规定了数据报的 IP 协议版本。

如：

IPv4：值为4。
IPv6：值为6。

9.3.2 首部长度字段

占用4 bit。

用于记录 IP 首部的数据的长度。

单位，字。最大可以表示15*4=60字节。

IP首部的长度默认是20 byte，但是如果有选项字段，就不止20 byte了。

9.3.3 服务类型（TOS：type of service）字段

占用8 bit。

该字段用于描述当前IP数据报急需的服务类型，如：

最小延时；
最大吞吐量；
最高可靠性；
最小费用等。

路由器在转发数据报时，可以根据该字段的值来为数据报选择最合理的路由路径。

9.3.4 总长度字段

占用16 bit。

是 IP 数据报的总长度（IP首部+数据区）。

单位，字节。最大能表示65535字节。

数据报很少有超过1500字节的，因为以太网数据帧的数据最大长度为1500字节。

如果一个IP数据报过大时，需要进行分片处理。

9.3.5 标识字段

标识字段、标志字段和13位偏移字段常在IP数据报分片时使用。

占用16 bit。

用于标识IP层发出去的每一份IP数据报，每发送一份，该值+1。

如果IP数据报被分片，该字段在每个分片的IP数据报上是一致的，表示属于同一个IP数据报。

在接收端会根据该字段识别同一个IP数据报进行重装。

9.3.6 标志字段

占用3 bit。

第一个bit保留未用。

第二个bit是不分片标志位：

0：则表示 IP 层在必要的时候可以对其进行分片处理。
1：则表示 IP 数据报在发送的过程中不允许进行分片，如果这个 IP 数据报的大小超过链路层能承载的大小，这个 IP 数据报将被丢弃。

第三个bit是更多分片标志位：

0：后续没有更多分片。即是当前分片的IP数据报是最后一个分片。
1：表示后续还有分片。即是当前分片的IP数据报不是最后一个分片。

9.3.7 分片偏移量字段

占用13 bit。

表示当前分片所携带的数据在整个 IP 数据报中的相对偏移位置。

单位，8字节（2个字）。

目标主机要接收到从0分片偏移量到最高分片偏移量的所有分片才能进行组装出完整的IP数据报。

9.3.8 生存时间（Time-To-Live，TTL）字段

占用8 bit。

该字段用来确保数据报不会永远在网络中循环。

IP数据报没经过一台路由器处理，该值-1。

如果TTL字段下降到0，则路由器会丢弃该数据报，且会返回一个 ICMP 差错报文给源主机。

9.3.9 协议字段

占用8 bit。

表示上层协议类型。即是表示数据区的数据是哪个协议的数据报。如：

6：表示TCP协议。
17：表示UDP协议。
其它值可以自行度娘。

9.3.10 首部校验和字段

占用16 bit。

只针对IP首部做校验，并不关系数据区在传输过程中是否出错，所以对于数据区的校验需要由上层协议负责。

路由器要对每个收到的 IP 数据报计算其首部检验和，如果数据报首部中携带的检验和与计算得到的检验和不一致，则表示出现错误，路由器一般会丢弃检测出错误的 IP 数据报。

需要注意的是，由于IP数据报首部的TTL字段每结果应该路由器都会-1，所以IP数据报首部检验和字段每经过一个路由器都要重新计算赋值。

参考：关于wireshark的Header checksum出问题解决方案：https://www.it610.com/article/1290714377560858624.htm

检验和计算可能由网络网络驱动，协议驱动，甚至是硬件完成。

高层校验通常是由协议执行，并将完成后的包转交给硬件。

比较新的网络硬件可以执行一些高级功能，如IP检验和计算，这被成为checksum offloading。网络驱动不会计算校验和，只是简单将校验和字段留空或填入无效信息，交给硬件计算。

发送数据时，首部校验和计算：二进制反码求和。

把IP数据包的校验和字段置为全0。
将首部中的每 2 个字节当作一个数，依次求和。
把结果取反码。
把得到的结果存入校验和字段中。

接收数据时，首部校验和验证过程：

首部中的每 2 个字节当作一个数，依次进行求和，包括校验和字段。
检查计算出的校验和的结果是否全为1（反码应为16个0）。
如果等于零，说明被整除，校验和正确。否则，校验和就是错误的，协议栈要抛弃这个数据包。

为什么计算出的校验和结果全为1？

因为如果校验依时次求和，不包含校验和字段的话，得出的值就是校验和字段的反码。

校验和的反码和校验和求和，当然是全1啦。

9.3.11 二进制反码求和

IP/ICMP/IGMP/TCP/UDP等协议的校验和算法都是相同的。

二进制反码求和：（求和再反码，结果一致）

对两个二进制数进行加法运算。
加法规则：0+0=0，0+1=1，1+1=10（进位1加到下一bit）。
若最高两位相加仍然有进位，则在最后的结果中+1即可。
对最终结果取反码。

相关源码参考LwIP\core\inet_chksum.c中的lwip_standard_chksum()。

这里提取版本3分析：

前期先确保4字节对齐，如果不是4字节对齐，就补到4字节对齐。
后面采用32 bit累加。溢出后，在低位+1。
- 为什么？：这里读者可能会有个疑问，IP数据包的校验和不是要求16 bit求和的吗？这里为什么能用32 bit求和？
- 答：起始要求是16 bit，但是实际计算时只要大于16 bit即可，因为到最后，可以把高位折叠加到低位。
- 例子：按32bit累加，溢出就在低位+1。其实就是两组两个（高、低）16 bit对应累加，低16 bit累加的进位给高16 bit里加回1了。而高16 bit累加的进位在底16 bit里加回1了（手动）。这样，累加到最后剩下32bit。把高16bit和低16bit进行累加，进位再加1即可快速得到16bit的校验和。
数据后部分可能不是8字节对齐，所以剩余的字节也需要16bit校验和处理。

思路图：

由于目的是16 bit的校验和。其实可以看成两组2个8bit对应相加，低8bit组进位给高8bit组，高8bit组进位给低8bit组。所以相加值是对应高、低8bit相互独立的。

而下面函数就是利用这个特性，如果首字节为奇地址，先单独取出来放到t的高地址，因为后续的统计字节顺序是返的。等待全部统计完毕后，再把两个字节顺序调换即可。

如果是偶地址开始，那符合校验和规则，最后不需要调换字节顺序。

#if (LWIP_CHKSUM_ALGORITHM == 3) /* Alternative version #3 */

/**

 * An optimized checksum routine. Basically, it uses loop-unrolling on

 * the checksum loop, treating the head and tail bytes specially, whereas

 * the inner loop acts on 8 bytes at a time.

 *

 * @arg start of buffer to be checksummed. May be an odd byte address.

 * @len number of bytes in the buffer to be checksummed.

 * @return host order (!) lwip checksum (non-inverted Internet sum)

 *

 * by Curt McDowell, Broadcom Corp. December 8th, 2005

 */

u16_t

lwip_standard_chksum(const void *dataptr, int len)

{

  const u8_t *pb = (const u8_t *)dataptr; /* 取数据的地址 */

  const u16_t *ps;

  u16_t t = 0;

  const u32_t *pl;

  u32_t sum = 0, tmp;

  int odd = ((mem_ptr_t)pb & 1); /* 判断是否为奇地址 */

  if (odd && len > 0) { /* 如果不是2直接对齐 */

    /* 缓存奇地址上的字节，存于 t 的高位。数据地址偏移为偶，2字节对齐。 */

    /* 存到高位是为了和后面字节序保持一致，方便在最后一次性更正。 */

    ((u8_t *)&t)[1] = *pb++;

    len--; /* 字节数-1 */

  }

  /* 2字节对齐的数据起始地址 */

  ps = (const u16_t *)(const void *)pb;

  if (((mem_ptr_t)ps & 3) && len > 1) {/* 如果不是4字节对齐 */

    /* 把多出来的两字节保存到sum */

    sum += *ps++;

    len -= 2;

  }

  /* 4字节对齐的数据起始地址 */

  pl = (const u32_t *)(const void *)ps;

  while (len > 7)  {

    tmp = sum + *pl++;          /* ping */

    if (tmp < sum) {

      tmp++;                    /* 溢出，手动+1 */

    }

    sum = tmp + *pl++;          /* pong */

    if (sum < tmp) {

      sum++;                    /* 溢出，手动+1 */

    }

    len -= 8;

  }

  /* 折叠高、低16bit */

  sum = FOLD_U32T(sum);

  /* 处理剩余的字节 */

  ps = (const u16_t *)pl;

  /* 2字节处理 */

  while (len > 1) {

    sum += *ps++;

    len -= 2;

  }

  /* 剩余单字节 */

  if (len > 0) {                /* 补到前面t的低位 */

    ((u8_t *)&t)[0] = *(const u8_t *)ps;

  }

  sum += t;                     /* 把t也一起16bit校验和 */

  /* 两次折叠高、低16bit */

  sum = FOLD_U32T(sum);

  sum = FOLD_U32T(sum);

  if (odd) { /* 因为前面是从第二个字节和第三个字节开始进行统计的，字节序反了，这里在结果更正。 */

    sum = SWAP_BYTES_IN_WORD(sum);

  }

  return (u16_t)sum; /* 返回校验和 */

}

#endif

9.3.12 源IP字段

占用32 bit。

为源主机的IP地址。

9.3.13 目标IP字段

占用32 bit。

为目标主机的IP地址。

9.3.14 选项字段

0到40字节。

对于IP数据报首部来说，其大小必须为4字节的整数倍。

如果选项字段长度不为4的倍数，则需要用0进行填充。

在 LwIP 中只识别选项字段，不会处理选项字段的内容。

该字段在IPv6报文中已经被移除了。

9.3.15 数据区字段

IP 数据报的最后的一个字段，装载着当前IP数据报的数据，是上层协议的数据报。

9.3.16 对应wireshark包分析

9.4 IP首部数据结构

注意：网络字节序是大端的。

ipv4的IP首部数据结构：对应IP首部报文图。

/* The IPv4 header */

struct ip_hdr {

  /* version / header length */

  PACK_STRUCT_FLD_8(u8_t _v_hl); /* 版本号字段（4）+首部长度字段（4）单位字 */

  /* type of service */

  PACK_STRUCT_FLD_8(u8_t _tos); /* 服务类型TOS字段（8） */

  /* total length */

  PACK_STRUCT_FIELD(u16_t _len); /* 总长度字段（16）单位字节 */

  /* identification */

  PACK_STRUCT_FIELD(u16_t _id); /* 标识字段字段（16） */

  /* fragment offset field */

  PACK_STRUCT_FIELD(u16_t _offset); /* 标志字段（3）+分片偏移量字段（13）单位两字 */

#define IP_RF 0x8000U        /* 标志字段第一位：字段保留 */

#define IP_DF 0x4000U        /* 标志字段第二位：不发片掩码 */

#define IP_MF 0x2000U        /* 标志字段第三位：更多分片掩码 */

#define IP_OFFMASK 0x1fffU   /* 分片偏移量字段的掩码 */

  /* time to live */

  PACK_STRUCT_FLD_8(u8_t _ttl); /* TTL字段（8） */

  /* protocol*/

  PACK_STRUCT_FLD_8(u8_t _proto); /* 上层协议类型字段（8） */

  /* checksum */

  PACK_STRUCT_FIELD(u16_t _chksum); /* 首部校验和字段（16） */

  /* source and destination IP addresses */

  PACK_STRUCT_FLD_S(ip4_addr_p_t src); /* 源IP字段（32） */

  PACK_STRUCT_FLD_S(ip4_addr_p_t dest); /* 目的IP字段（32） */

} PACK_STRUCT_STRUCT;

由于IP首部部分字段的操作涉及到bit，所以lwip也封装出对应的宏操作。

/* 均为网络字节序 */

/* Macros to get struct ip_hdr fields: */

#define IPH_V(hdr)  ((hdr)->_v_hl >> 4) /* 获取版本号 */

#define IPH_HL(hdr) ((hdr)->_v_hl & 0x0f) /* 获取首部长度字段值 */

#define IPH_HL_BYTES(hdr) ((u8_t)(IPH_HL(hdr) * 4)) /* 获取首部长度，单位字节 */

#define IPH_TOS(hdr) ((hdr)->_tos) /* 获取服务类型TOS */

#define IPH_LEN(hdr) ((hdr)->_len) /* 获取IP数据报总长度 */

#define IPH_ID(hdr) ((hdr)->_id) /* 获取标识字段 */

#define IPH_OFFSET(hdr) ((hdr)->_offset) /* 获取标志字段+分片偏移量字段 */

#define IPH_OFFSET_BYTES(hdr) ((u16_t)((lwip_ntohs(IPH_OFFSET(hdr)) & IP_OFFMASK) * 8U)) /* 获取分片偏移量，单位字节 */

#define IPH_TTL(hdr) ((hdr)->_ttl) /* 获取TTL */

#define IPH_PROTO(hdr) ((hdr)->_proto) /* 获取协议类型 */

#define IPH_CHKSUM(hdr) ((hdr)->_chksum) /* 获取首部校验和字段 */

/* Macros to set struct ip_hdr fields: */

#define IPH_VHL_SET(hdr, v, hl) (hdr)->_v_hl = (u8_t)((((v) << 4) | (hl))) /* 设置版本号 */

#define IPH_TOS_SET(hdr, tos) (hdr)->_tos = (tos) /* 设置服务类型TOS */

#define IPH_LEN_SET(hdr, len) (hdr)->_len = (len) /* 设置总长度字段值 */

#define IPH_ID_SET(hdr, id) (hdr)->_id = (id) /* 设置标识 */

#define IPH_OFFSET_SET(hdr, off) (hdr)->_offset = (off) /* 设置标志字段+分片偏移量字段 */

#define IPH_TTL_SET(hdr, ttl) (hdr)->_ttl = (u8_t)(ttl) /* 设置TTL */

#define IPH_PROTO_SET(hdr, proto) (hdr)->_proto = (u8_t)(proto) /* 设置协议类型 */

#define IPH_CHKSUM_SET(hdr, chksum) (hdr)->_chksum = (chksum) /* 设置首部校验和 */

9.5 网卡路由

9.5.1 路由网卡匹配

从官方源码看，匹配网卡的流程：

ip4_route_src()：

先函数LWIP_HOOK_IP4_ROUTE_SRC()匹配。
然后到ip4_route()基函数匹配。

9.5.2 路由网卡匹配基函数

ip4_route()：

多播IP优先匹配多播专用网卡ip4_default_multicast_netif。
遍历网卡：
- 有效网卡先匹配子网；
- 子网匹配失败就匹配网关，网卡不能有广播能力。
环回IP：如果开启了各个网卡的环回功能，且没有创建环回网卡：
- 说明：因为创建了环回网卡，在遍历链表时，就会把环回IP 127.x.x.x都会匹配到环回网卡。
- 对于环回IP，优先匹配默认网卡netif_default。
- 再遍历网卡，第一个协议栈有效的网卡即可。
钩子匹配：（由用户实现）
- 先LWIP_HOOK_IP4_ROUTE_SRC(src, dest);
- 再LWIP_HOOK_IP4_ROUTE(dest);
以上都没有匹配成功，则使用netif_default，必须条件：
- 默认网卡netif_default存在；
- 默认网卡协议栈有效；
- 默认网卡数据链路有效；
- 默认网卡IP有效。
- 匹配的目的IP不能为环回IP（因为如果是环回IP，前面已经匹配过了，除非没有开启该功能）

/**

 * Finds the appropriate network interface for a given IP address. It

 * searches the list of network interfaces linearly. A match is found

 * if the masked IP address of the network interface equals the masked

 * IP address given to the function.

 *

 * @param dest the destination IP address for which to find the route

 * @return the netif on which to send to reach dest

 */

struct netif *

ip4_route(const ip4_addr_t *dest)

{

#if !LWIP_SINGLE_NETIF

  struct netif *netif;

  /* 确保在tcpip内核锁内 */

  LWIP_ASSERT_CORE_LOCKED();

#if LWIP_MULTICAST_TX_OPTIONS /* 开启了组播TX功能 */

  /* 如果目的IP是一个组播地址，且协议栈内创建了组播专用网卡，则选用组播专用网卡接口 */

  if (ip4_addr_ismulticast(dest) && ip4_default_multicast_netif) {

    return ip4_default_multicast_netif;

  }

#endif /* LWIP_MULTICAST_TX_OPTIONS */

  /* bug #54569: in case LWIP_SINGLE_NETIF=1 and LWIP_DEBUGF() disabled, the following loop is optimized away */

  LWIP_UNUSED_ARG(dest);

  /* 遍历网卡链表 */

  NETIF_FOREACH(netif) {

    /* 网卡协议栈有效，网卡链路层也有效，网卡的IP地址不为全0 */

    if (netif_is_up(netif) && netif_is_link_up(netif) && !ip4_addr_isany_val(*netif_ip4_addr(netif))) {

      /* 匹配传入的目的IP和网卡是否处于同一个子网 */

      if (ip4_addr_net_eq(dest, netif_ip4_addr(netif), netif_ip4_netmask(netif))) {

        /* 匹配成功。返回netif，以转发IP数据包 */

        return netif;

      }

      /* 当前网卡子网匹配不成功 */

      /* 那就匹配下网关，匹配规则：网卡没有广播功能，目的IP和网关IP一致。也算匹配成功，因为上层的目的是到网关。当前网卡能把数据传达到网卡。 */

      if (((netif->flags & NETIF_FLAG_BROADCAST) == 0) && ip4_addr_eq(dest, netif_ip4_gw(netif))) {

        /* 匹配成功。返回netif，以转发IP数据包 */

        return netif;

      }

    }

  }

  /* 到这，遍历网卡，匹配失败 */

/* 开启了环回功能，但是没有创建环回网卡。（因为如果创建了环回网卡，在遍历网卡链表时就已经处理过了，这里不需要再处理） */

#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF

  /* 如果目的IP是一个环回IP地址，则优先返回默认网卡，否则返回网卡链表中第一个协议栈使能了的网卡作为当前环回网卡 */

  if (ip4_addr_isloopback(dest)) { /* 目的IP是一个环回IP */

    if ((netif_default != NULL) && netif_is_up(netif_default)) {

      /* 优先考虑默认网卡。如果有默认网卡，且默认网卡协议栈使能了，则以此网卡作为本次环回网卡 */

      return netif_default;

    }

    /* 默认网卡没有匹配成功，则从网卡链表中找一个协议栈已使能的网卡作为本次环回网卡 */

    NETIF_FOREACH(netif) {

      if (netif_is_up(netif)) {

        return netif;

      }

    }

    return NULL; /* 都没找到，那就匹配失败 */

  }

#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */

#ifdef LWIP_HOOK_IP4_ROUTE_SRC /* 如果开启了匹配网卡的钩子宏函数 */

  netif = LWIP_HOOK_IP4_ROUTE_SRC(NULL, dest); /* 使用宏钩子匹配 */

  if (netif != NULL) {

    return netif;

  }

#elif defined(LWIP_HOOK_IP4_ROUTE) /* 网卡匹配钩子 */

  netif = LWIP_HOOK_IP4_ROUTE(dest); /* 使用宏钩子匹配 */

  if (netif != NULL) {

    return netif;

  }

#endif

#endif /* !LWIP_SINGLE_NETIF */

  /* 上述方案都无法匹配到网卡，就检查网卡网卡是否正常，正常则就返回默认网卡 */

  if ((netif_default == NULL) || !netif_is_up(netif_default) || !netif_is_link_up(netif_default) ||

      ip4_addr_isany_val(*netif_ip4_addr(netif_default)) || ip4_addr_isloopback(dest)) {

    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",

                ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));

    IP_STATS_INC(ip.rterr);

    MIB2_STATS_INC(mib2.ipoutnoroutes);

    return NULL;

  }

  return netif_default; /* 返回默认网络接口 */

}

9.5.3 路由网卡匹配支持源IP和目的IP网卡匹配的接口

匹配网卡，一般是按照目的IP来匹配，但是可以通过LWIP_HOOK_IP4_ROUTE_SRC()钩子宏函数来实现源IP地址和目的IP地址匹配。

ip4_route_src()：

如果源IP地址不为空，则会先传入LWIP_HOOK_IP4_ROUTE_SRC()钩子函数来匹配网卡。
钩子函数匹配失败或者源IP地址为空，则由ip4_route()只根据目的IP地址匹配。

#ifdef LWIP_HOOK_IP4_ROUTE_SRC

/**

 * Source based IPv4 routing must be fully implemented in

 * LWIP_HOOK_IP4_ROUTE_SRC(). This function only provides the parameters.

 */

struct netif *

ip4_route_src(const ip4_addr_t *src, const ip4_addr_t *dest)

{

  if (src != NULL) {

    /* 当src==NULL时，钩子会从ip4_route(dest)调用 */

    struct netif *netif = LWIP_HOOK_IP4_ROUTE_SRC(src, dest);

    if (netif != NULL) {

      return netif;

    }

  }

  return ip4_route(dest);

}

#endif /* LWIP_HOOK_IP4_ROUTE_SRC */

9.5.4 路由网卡匹配的钩子函数

通过分析前面的基函数和接口函数，可发现其实现是支持宏钩子函数，即是支持用户自己实现网卡匹配的逻辑的。

有两个宏钩子：

LWIP_HOOK_IP4_ROUTE_SRC(src, dest)：钩子入口参数有源IP和目的IP。
LWIP_HOOK_IP4_ROUTE(dest)：钩子入口参数只有目的IP。

9.5.5 收包网卡匹配

当IP层收到一个IP报文时，也要收包网卡匹配。

而且IP包的输入和输出的网卡匹配是不一样的，比如普通的IP单播包，输出时，只需要找到目的IP和网卡处于同一个子网或者是该网卡的网关即可匹配。而输入时，需要明确目的IP就是该网卡IP。

收包的网卡匹配除了ip4_input_accept()这个主要函数外，还有很多独立的匹配条件，具体看IP层输入章节。

这里只分析ip4_input_accept()：

在调用该API前，应该先配置全局IP数据结构成员值：struct ip_globals ip_data;
需要被匹配的网卡必须在协议栈方向使能了，且IP地址为有效地址。
- 单播包，目的地址和网卡地址一致，网卡匹配成功。
- 广播包，IP地址bit全1，必定是广播地址。如果网卡就被广播能力，且IP地址的主机号bit全1，也是子网广播地址。都匹配成功。
- 环回，没有环回网卡，且目的IP地址为环回IP IPADDR_LOOPBACK。匹配成功。

/** Return true if the current input packet should be accepted on this netif */

static int

ip4_input_accept(struct netif *netif)

{

  LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%"X32_F" netif->ip_addr 0x%"X32_F" (0x%"X32_F", 0x%"X32_F", 0x%"X32_F")\n",

                         ip4_addr_get_u32(ip4_current_dest_addr()), ip4_addr_get_u32(netif_ip4_addr(netif)),

                         ip4_addr_get_u32(ip4_current_dest_addr()) & ip4_addr_get_u32(netif_ip4_netmask(netif)),

                         ip4_addr_get_u32(netif_ip4_addr(netif)) & ip4_addr_get_u32(netif_ip4_netmask(netif)),

                         ip4_addr_get_u32(ip4_current_dest_addr()) & ~ip4_addr_get_u32(netif_ip4_netmask(netif))));

  /* 网卡是否在协议栈中使能且网卡地址有效？ */

  if ((netif_is_up(netif)) && (!ip4_addr_isany_val(*netif_ip4_addr(netif)))) {

    /* 是否是单播到这个接口地址? */

    if (ip4_addr_eq(ip4_current_dest_addr(), netif_ip4_addr(netif)) ||

        /* 或者广播这个接口的网络地址? */

        ip4_addr_isbroadcast(ip4_current_dest_addr(), netif)

#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF /* 如果开启环回功能，但是没有创建环回网卡 */

        /* 目的IP是一个环回的IP地址，也就是给当前网卡的，能匹配成功 */

        || (ip4_addr_get_u32(ip4_current_dest_addr()) == PP_HTONL(IPADDR_LOOPBACK))

#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */

       ) {

      LWIP_DEBUGF(IP_DEBUG, ("ip4_input: packet accepted on interface %c%c\n",

                             netif->name[0], netif->name[1]));

      /* accept on this netif */

      return 1;

    }

#if LWIP_AUTOIP

    /* 更改netif地址后，链路本地地址的连接必须保持(RFC3927 ch. 1.9) */

    /* 即是netif网卡地址更新为可路由地址了，原本本地链路地址的连接必须保持，所以数据包能得到当前网卡。匹配成功 */

    if (autoip_accept_packet(netif, ip4_current_dest_addr())) {

      LWIP_DEBUGF(IP_DEBUG, ("ip4_input: LLA packet accepted on interface %c%c\n",

                             netif->name[0], netif->name[1]));

      /* accept on this netif */

      return 1;

    }

#endif /* LWIP_AUTOIP */

  }

  return 0;

}

9.6 IP层数据流图

9.7 IP层输出

ipv4。

当上层需要发送数据时，会先将自己的数据包组装在一个pbuf中。并将payload指针指向对应协议首部。

然后调用ip_output()发送数据，需要给ip_output()函数提供源IP、目的IP、协议类型、TTL等重要信息让其组IP包。

该函数直接或者间接调用ip4_route_src()根据目的IP选出一个匹配的网卡作为本次IP数据包传输网卡。

选出后调用ip4_output_if()进行IP数据包组包，并调用netif->output()发送出去。或者调用netif_loop_output()环回到本网卡。

9.7.1 发送数据报

上层调用ip_output()把数据转交给IP层处理，lwip支持ipv4和ipv6，这里默认分析ipv4，因为ipv6也是一大块，后面有时间再完整分析下。

/**

 * @ingroup ip

 * Output IP packet, netif is selected by source address

 */

#define ip_output(p, src, dest, ttl, tos, proto) \

        (IP_IS_V6(dest) ? \

        ip6_output(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto) : \

        ip4_output(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto))

9.7.2 ip层前期处理：ip4_output()

ipv4发包：

检查pbuf的引用ref是否为1。为1才能说明当前pbuf没有被其它地方引用，因为IP层处理可能会改变这个pbuf的部分指针值，如payload。
调用ip4_route_src()匹配网卡。
调用ip4_output_if()把数据包传入IP层处理。

/**

 * Simple interface to ip_output_if. It finds the outgoing network

 * interface and calls upon ip_output_if to do the actual work.

 *

 * @param p the packet to send (p->payload points to the data, e.g. next

            protocol header; if dest == LWIP_IP_HDRINCL, p already includes an

            IP header and p->payload points to that IP header)

 * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the

 *         IP  address of the netif used to send is used as source address)

 * @param dest the destination IP address to send the packet to

 * @param ttl the TTL value to be set in the IP header

 * @param tos the TOS value to be set in the IP header

 * @param proto the PROTOCOL to be set in the IP header

 *

 * @return ERR_RTE if no route is found

 *         see ip_output_if() for more return values

 */

err_t

ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,

           u8_t ttl, u8_t tos, u8_t proto)

{

  struct netif *netif;

  /* 下传到IP层的pbuf的ref必须为1，即是没有被其它地方引用，因为pbuf下传到IP层后，pbuf的payload指针会被更改。

    如果这个pbuf被其它地方引用了，可能会导致数据混乱。 */

  LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p);

  /* 根据目的IP地址为数据报寻找一个合适的网络接口（匹配网卡） */

  if ((netif = ip4_route_src(src, dest)) == NULL) { /* 没找到，记录信息，返回错误 */

    LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",

                           ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));

    IP_STATS_INC(ip.rterr);

    return ERR_RTE;

  }

  /* 匹配到网卡，传入IP层处理：组包、发送 */

  return ip4_output_if(p, src, dest, ttl, tos, proto, netif);

}

9.7.3 发包前的网卡匹配

IP层收到上层的数据包后，需要匹配到网络接口，才能组IP包发出去。

这里调用ip4_route_src()进行网卡匹配。具体分析参考前面。

9.7.4 组建、发送IP包

注意几个函数的区别：

ip4_output_if()：这个函数封装了底层IP层组包、发送的实现函数。
ip4_output_if_src()：这个函数就是IP层组包、发送的实现函数。不支持IP首部的选项字段。
ip4_output_if_opt()：这也是IP层组包、发送的实现函数，会用选中的网卡IP地址覆盖传入的源IP地址。支持IP首部的选项字段。
ip4_output_if_opt_src()：这也是IP层组包、发送的实现函数，不会用选中的网卡IP地址覆盖传入的源IP地址。支持IP首部的选项字段。

相关宏：

IP_OPTIONS_SEND：

IP首报文首部选项字段宏开关。
如果开启了该宏，则会调用上述带_opt字样的函数，操作IP首部报文的选项字段。

LWIP_IP_HDRINCL：缺省为NULL

如果把这个宏当目的IP地址传入IP层组包、发送的相关函数ip4_output_if()或其底层函数时，表示当前这个pbuf已经组好IP首部了。
一般用于TCP重传。

LWIP_CHECKSUM_CTRL_PER_NETIF：

允许每个网卡配置checksum功能。

9.7.5 IP数据报分片

注意：lwip分片偏移不支持IP首部带选项字段的。

从IP报文首部就可知，有分片概念。

不是每个底层网卡都能承载每个 IP 数据报长度的报文。如：

以太网帧最大能承载 1500 个字节的数据。
某些广域网链路的帧可承载不超过 576 字节的数据。

一个链路层帧能承载的最大数据量叫做最大传送单元（Maximum TransmissionUnit，MTU）。

IP 数据报的分片偏移量是用 8 的整数倍记录的，所以每个数据报中的分片数据大小也必须是 8 的整数倍。

IP数据报分片主要关注IP首部的标识字段、标志字段和分片偏移量字段。具体往前看。

参考图：

相关宏：

LWIP_NETIF_TX_SINGLE_PBUF：分片是否支持新建一整个pbuf处理。
- 1：分片时，直接申请各个IP分片包的pbuf即可（含IP首部+数据区）。
- 0：分片时，申请各个分片的管理区，MEMP_FRAG_PBUF类型。其数据结构为pbuf_custom_ref。该数据结构包含本次IP分片包的原IP报文pbuf地址，释放引用的api，指向分片IP报文数据区的pbuf。然后将这个分片IP首部的pbuf和这个IP报文数据区的pbuf拼接起来即可。组成新的分片IP报文。

9.8 IP层输入

9.8.1 接收数据报

翻看前面网络接口层章节应该知道底层接收数据流，在网卡驱动收到数据，调用netif->input()把对应API和pbuf转发到lwip内核线程执行。

以以太网为例，网卡接收数据线程通过把数据给到netif->input()，该函数内部外包以太网链路层ethernet_input()到lwip内核线程去跑，如果是ARP协议的以太网帧，则传到ARP模块etharp_input()处理。如果是IPv4的以太网帧，则传到ip4_input()处理。

相关宏：

LWIP_HOOK_IP4_INPUT(p, inp)：IPV4接收数据包钩子函数。

接收数据时检查了IP报文的版本为IPV4，就会把这个IP报文传给这个钩子函数。
如果钩子放回true，则表示由钩子处理，外部丢弃。

LWIP_IP_ACCEPT_UDP_PORT(dst_port)：在netif关闭时接受私人广播通信用。

ip4_input()：

IP报文校验。
传入钩子LWIP_HOOK_IP4_INPUT(p, inp)。
匹配目的网卡。就是判断当前IP报文是不是给我的。
- 多播包：
  - 开启了IGMP：当前网卡在当前IP报文目的IP组播内，匹配成功。
  - 没有开启IGMP：当前网卡有效即可匹配成功。
- 广播包和单播包：都调用ip4_input_accept()API匹配。前面有分析。
  - 先匹配收到该IP报文的网卡；
  - 再遍历网卡链表。注意：如果没有环回功能或者有环回网卡，且IP报文目的IP地址是环回字段的IP地址，不能遍历网卡链表。因为环回，需要用环回接口，在前面匹配网卡就应该配上了，不会跑到这里。
- 开启了DHCP，且面前没有匹配上网卡：
  - 通过IP报文可以判断当前IP报文是否是UDP协议。
  - 通过UDP协议解析目的端口是否是DHCP客户端端口LWIP_IANA_PORT_DHCP_CLIENT（68）。
  - 是DHCP报文，直接收到当前网卡。不需要做目的IP校验。
没有匹配到网卡，即是IP报文不是给我们的，但是开启了IP_FORWARD转发功能。如果目的IP不是广播地址，可以调用ip4_forward()进行转发。
匹配到网卡，处理IP报文，如果IP报文被分片了，需要调用ip4_reass()重组。
收到完整的IP报文后，根据IP报文的上层协议类型字段，给到对应的协议模块。lwip支持：
- IP_PROTO_UDP：UDP协议。udp_input(p, inp);
- IP_PROTO_TCP：TCP协议。tcp_input(p, inp);
- IP_PROTO_ICMP：ICMP协议。icmp_input(p, inp);
- IP_PROTO_IGMP：IGMP协议。igmp_input(p, inp, ip4_current_dest_addr());
- LWIP_RAW：原报文上报。

/**

 * This function is called by the network interface device driver when

 * an IP packet is received. The function does the basic checks of the

 * IP header such as packet size being at least larger than the header

 * size etc. If the packet was not destined for us, the packet is

 * forwarded (using ip_forward). The IP checksum is always checked.

 *

 * Finally, the packet is sent to the upper layer protocol input function.

 *

 * @param p the received IP packet (p->payload points to IP header)

 * @param inp the netif on which this packet was received

 * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't

 *         processed, but currently always returns ERR_OK)

 */

err_t

ip4_input(struct pbuf *p, struct netif *inp)

{

  const struct ip_hdr *iphdr;

  struct netif *netif;

  u16_t iphdr_hlen;

  u16_t iphdr_len;

#if IP_ACCEPT_LINK_LAYER_ADDRESSING || LWIP_IGMP

  int check_ip_src = 1;

#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING || LWIP_IGMP */

#if LWIP_RAW

  raw_input_state_t raw_status;

#endif /* LWIP_RAW */

  LWIP_ASSERT_CORE_LOCKED();

  IP_STATS_INC(ip.recv);

  MIB2_STATS_INC(mib2.ipinreceives);

  /* 识别IP头 */

  iphdr = (struct ip_hdr *)p->payload;

  if (IPH_V(iphdr) != 4) { /* 如果IP版本不是ipv4，丢弃该报文 */

    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IP packet dropped due to bad version number %"U16_F"\n", (u16_t)IPH_V(iphdr)));

    ip4_debug_print(p);

    pbuf_free(p);

    IP_STATS_INC(ip.err);

    IP_STATS_INC(ip.drop);

    MIB2_STATS_INC(mib2.ipinhdrerrors);

    return ERR_OK;

  }

#ifdef LWIP_HOOK_IP4_INPUT

  if (LWIP_HOOK_IP4_INPUT(p, inp)) { /* 传入IP接收数据包钩子函数处理 */

    /* IP报文也就被处理了 */

    return ERR_OK;

  }

#endif

  /* 获取IP首部长度(以字节为单位) */

  iphdr_hlen = IPH_HL_BYTES(iphdr);

  /* 获取IP报文长度(以字节为单位) */

  iphdr_len = lwip_ntohs(IPH_LEN(iphdr));

  /* 修剪pbuf。对于小于60字节的数据包尤其需要这样做 */

  if (iphdr_len < p->tot_len) {

    pbuf_realloc(p, iphdr_len);

  }

  /* 报头长度超过第一个pbuf长度，或者IP长度超过总pbuf长度? */

  if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len) || (iphdr_hlen < IP_HLEN)) {

    if (iphdr_hlen < IP_HLEN) {

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,

                  ("ip4_input: short IP header (%"U16_F" bytes) received, IP packet dropped\n", iphdr_hlen));

    }

    if (iphdr_hlen > p->len) {

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,

                  ("IP header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n",

                   iphdr_hlen, p->len));

    }

    if (iphdr_len > p->tot_len) {

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,

                  ("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n",

                   iphdr_len, p->tot_len));

    }

    /* 校验错误，丢弃当前pbuf，并记录相关信息 */

    pbuf_free(p);

    IP_STATS_INC(ip.lenerr);

    IP_STATS_INC(ip.drop);

    MIB2_STATS_INC(mib2.ipindiscards);

    return ERR_OK;

  }

  /* 首部校验和字段校验 */

#if CHECKSUM_CHECK_IP

  IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_IP) {

    if (inet_chksum(iphdr, iphdr_hlen) != 0) {

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,

                  ("Checksum (0x%"X16_F") failed, IP packet dropped.\n", inet_chksum(iphdr, iphdr_hlen)));

      ip4_debug_print(p);

      pbuf_free(p);

      IP_STATS_INC(ip.chkerr);

      IP_STATS_INC(ip.drop);

      MIB2_STATS_INC(mib2.ipinhdrerrors);

      return ERR_OK;

    }

  }

#endif

  /* 拷贝IP地址到对齐的ip_addr_t。ip_data为全局变量 */

  ip_addr_copy_from_ip4(ip_data.current_iphdr_dest, iphdr->dest);

  ip_addr_copy_from_ip4(ip_data.current_iphdr_src, iphdr->src);

  /* 将报文与接口匹配，即这个报文是我们的吗? */

  if (ip4_addr_ismulticast(ip4_current_dest_addr())) { /* 多播包 */

#if LWIP_IGMP /* IGMP处理 */

    if ((inp->flags & NETIF_FLAG_IGMP) && (igmp_lookfor_group(inp, ip4_current_dest_addr()))) { /* 当前网卡在IP报文目的IP的组播组内 */

      /* IGMP snooping交换机需要允许源地址为0.0.0.0 (RFC 4541) */

      ip4_addr_t allsystems;

      IP4_ADDR(&allsystems, 224, 0, 0, 1);

      if (ip4_addr_eq(ip4_current_dest_addr(), &allsystems) &&

          ip4_addr_isany(ip4_current_src_addr())) {

        check_ip_src = 0; /* 标记后面忽略源IP地址 */

      }

      netif = inp; /* 组播匹配成功 */

    } else {

      netif = NULL; /* 组播匹配失败 */

    }

#else /* LWIP_IGMP */

    if ((netif_is_up(inp)) && (!ip4_addr_isany_val(*netif_ip4_addr(inp)))) {

      netif = inp; /* 如果不支持IGMP协议功能，但是当前网卡收到这个组播包，就直接匹配当前网卡即可 */

    } else {

      netif = NULL;

    }

#endif /* LWIP_IGMP */

  } else { /* 单播或广播IP包 */

    /* 优先匹配当前网卡 */

    if (ip4_input_accept(inp)) {

      netif = inp; /* 匹配成功 */

    } else { /* 当前网卡匹配失败，就遍历网卡链表进行匹配 */

      netif = NULL;

#if !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF

      /* 如果网卡没有环回功能，或者已经创建了环回网卡。如果当前IP报文的目的IP是环回类型的，则不会跑到这里，而是在对应网卡的环回数据队列中。 */

      if (!ip4_addr_isloopback(ip4_current_dest_addr())) /* IP报文的目的IP不能是环回类型 */

#endif /* !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF */

      {

#if !LWIP_SINGLE_NETIF

        NETIF_FOREACH(netif) { /* 遍历网卡链表 */

          if (netif == inp) { /* 跳过已经尝试匹配的网卡 */

            /* we checked that before already */

            continue;

          }

          if (ip4_input_accept(netif)) { /* 进行匹配 */

            break;

          }

        }

#endif /* !LWIP_SINGLE_NETIF */

      }

    }

  }

#if IP_ACCEPT_LINK_LAYER_ADDRESSING

  /* 通过DHCP报文时，不考虑目的地址。DHCP流量使用链路层寻址(如以太网MAC)，所以我们不能对IP进行过滤。

   * 参考RFC 1542章节3.1.1，参考RFC 2131)。

   *

   * 如果想在netif关闭时接受私有广播通信，定义LWIP_IP_ACCEPT_UDP_PORT(dst_port)，例如:

   * #define LWIP_IP_ACCEPT_UDP_PORT(dst_port) ((dst_port) == PP_NTOHS(12345))

   */

  if (netif == NULL) {

    /* 远端端口是DHCP服务器? */

    if (IPH_PROTO(iphdr) == IP_PROTO_UDP) { /* UDP协议类型 */

      const struct udp_hdr *udphdr = (const struct udp_hdr *)((const u8_t *)iphdr + iphdr_hlen);

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n",

                                              lwip_ntohs(udphdr->dest)));

      if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) { /* 目的端口是DHCP客户端端口。能通过协议栈IP层 */

        LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n"));

        netif = inp; /* 匹配成功 */

        check_ip_src = 0; /* 标记后面忽略源IP地址 */

      }

    }

  }

#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */

  /* 广播或多播包的源地址?兼容RFC 1122: 3.2.1.3 */

#if LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING

  if (check_ip_src /* 忽略源IP地址的跳过：如IGMP和DHCP */

#if IP_ACCEPT_LINK_LAYER_ADDRESSING

      /* 允许DHCP服务器源地址为0.0.0.0 (RFC 1.1.2.2: 3.2.1.3/a) */

      && !ip4_addr_isany_val(*ip4_current_src_addr())

#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */

     )

#endif /* LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING */

  {

    if ((ip4_addr_isbroadcast(ip4_current_src_addr(), inp)) || /* 广播包 */

        (ip4_addr_ismulticast(ip4_current_src_addr()))) { /* 或者是多播包 */

      /* IP报文无效 */

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("ip4_input: packet source is not valid.\n"));

      /* 释放资源并记录相关信息 */

      pbuf_free(p);

      IP_STATS_INC(ip.drop);

      MIB2_STATS_INC(mib2.ipinaddrerrors);

      MIB2_STATS_INC(mib2.ipindiscards);

      return ERR_OK;

    }

  }

  /* 网卡匹配完毕 */

  if (netif == NULL) { /* 网卡匹配失败 */

    /* 不给我们包，路由或丢弃 */

    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: packet not for us.\n"));

#if IP_FORWARD /* 支持路由转发 */

    if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), inp)) { /* 广播包不能转发 */

      /* 尝试在(其他)接口转发IP报文 */

      ip4_forward(p, (struct ip_hdr *)p->payload, inp);

    } else

#endif /* IP_FORWARD */

    { /* 广播包不支持转发，丢弃 */

      IP_STATS_INC(ip.drop);

      MIB2_STATS_INC(mib2.ipinaddrerrors);

      MIB2_STATS_INC(mib2.ipindiscards);

    }

    pbuf_free(p);

    return ERR_OK;

  }

  /* 网卡匹配成功，数据包是给我们的 */

  /* 数据包由多个分片组成? */

  if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) {

#if IP_REASSEMBLY /* 支持IP分片重组 */

    LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n",

                           lwip_ntohs(IPH_ID(iphdr)), p->tot_len, lwip_ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK) * 8)));

    /* 重新组装包 */

    p = ip4_reass(p);

    if (p == NULL) { /* IP包还没组装好 */

      return ERR_OK;

    }

    /* IP报文重组好了，更新IP首部指针 */

    iphdr = (const struct ip_hdr *)p->payload;

#else /* IP_REASSEMBLY == 0, 不支持分片重组 */

    /* 不支持分片重组，遇到分片IP报文，直接丢弃 */

    pbuf_free(p);

    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n",

                lwip_ntohs(IPH_OFFSET(iphdr))));

    IP_STATS_INC(ip.opterr);

    IP_STATS_INC(ip.drop);

    /* unsupported protocol feature */

    MIB2_STATS_INC(mib2.ipinunknownprotos);

    return ERR_OK;

#endif /* IP_REASSEMBLY */

  }

#if IP_OPTIONS_ALLOWED == 0 /* no support for IP options in the IP header? */

#if LWIP_IGMP

  /* 在IGMP消息中有一个额外的“路由器警报”选项，我们允许但不监督 */

  /* 如果IP报文带选项字段，lwip只支持IGMP */

  if ((iphdr_hlen > IP_HLEN) &&  (IPH_PROTO(iphdr) != IP_PROTO_IGMP)) {

#else

  if (iphdr_hlen > IP_HLEN) { /* LWIP不支持接收处理带选项字段的IP报文。（IGMP协议除外） */

#endif /* LWIP_IGMP */

    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since there were IP options (while IP_OPTIONS_ALLOWED == 0).\n"));

    pbuf_free(p);

    IP_STATS_INC(ip.opterr);

    IP_STATS_INC(ip.drop);

    /* unsupported protocol feature */

    MIB2_STATS_INC(mib2.ipinunknownprotos);

    return ERR_OK;

  }

#endif /* IP_OPTIONS_ALLOWED == 0 */

  /* 发送到上层 */

  LWIP_DEBUGF(IP_DEBUG, ("ip4_input: \n"));

  ip4_debug_print(p);

  LWIP_DEBUGF(IP_DEBUG, ("ip4_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len));

  /* 更新这个全局IP数据 */

  ip_data.current_netif = netif; /* 上层处理该数据包的网卡 */

  ip_data.current_input_netif = inp; /* 数据链路接收到该数据包的网卡 */

  ip_data.current_ip4_header = iphdr; /* IP报文首部 */

  ip_data.current_ip_header_tot_len = IPH_HL_BYTES(iphdr); /* IP首部长度（单位：字节） */

#if LWIP_RAW /* RAW */

  /* 传到RAW输入 */

  raw_status = raw_input(p, inp);

  if (raw_status != RAW_INPUT_EATEN) /* RAW传入失败，那就传给其它上层协议模块 */

#endif /* LWIP_RAW */

  {

    pbuf_remove_header(p, iphdr_hlen); /* 移到有效载荷，不需要检查 */

    switch (IPH_PROTO(iphdr)) { /* 根据IP报文协议字段传入对应协议模块 */

#if LWIP_UDP

      case IP_PROTO_UDP: /* UDP协议 */

#if LWIP_UDPLITE

      case IP_PROTO_UDPLITE: /* UDP-Lite协议 */

#endif /* LWIP_UDPLITE */

        MIB2_STATS_INC(mib2.ipindelivers);

        udp_input(p, inp); /* 传入UDP协议模块 */

        break;

#endif /* LWIP_UDP */

#if LWIP_TCP

      case IP_PROTO_TCP: /* TCP协议 */

        MIB2_STATS_INC(mib2.ipindelivers);

        tcp_input(p, inp); /* 传入TCP协议模块 */

        break;

#endif /* LWIP_TCP */

#if LWIP_ICMP

      case IP_PROTO_ICMP: /* ICMP协议 */

        MIB2_STATS_INC(mib2.ipindelivers);

        icmp_input(p, inp); /* 传入ICMP协议模块 */

        break;

#endif /* LWIP_ICMP */

#if LWIP_IGMP

      case IP_PROTO_IGMP: /* IGMP协议 */

        igmp_input(p, inp, ip4_current_dest_addr()); /* 传入IGMP协议模块 */

        break;

#endif /* LWIP_IGMP */

      default: /* 其它 */

#if LWIP_RAW

        if (raw_status == RAW_INPUT_DELIVERED) {

          MIB2_STATS_INC(mib2.ipindelivers);

        } else

#endif /* LWIP_RAW */

        {

#if LWIP_ICMP

          /* 不是广播包，也不是多播包，数据链路层给到我们网卡不支持的协议，发送ICMP目的协议不可达 */

          if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) &&

              !ip4_addr_ismulticast(ip4_current_dest_addr())) {

            pbuf_header_force(p, (s16_t)iphdr_hlen); /* 移动到ip头，不需要检查 */

            icmp_dest_unreach(p, ICMP_DUR_PROTO); /* 发送ICMP目的协议不可达 */

          }

#endif /* LWIP_ICMP */

          LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Unsupported transport protocol %"U16_F"\n", (u16_t)IPH_PROTO(iphdr)));

          IP_STATS_INC(ip.proterr);

          IP_STATS_INC(ip.drop);

          MIB2_STATS_INC(mib2.ipinunknownprotos);

        }

        pbuf_free(p); /* 丢弃，释放pbuf */

        break;

    }

  }

  /* @todo: this is not really necessary... */

  ip_data.current_netif = NULL;

  ip_data.current_input_netif = NULL;

  ip_data.current_ip4_header = NULL;

  ip_data.current_ip_header_tot_len = 0;

  ip4_addr_set_any(ip4_current_src_addr());

  ip4_addr_set_any(ip4_current_dest_addr());

  return ERR_OK;

}

9.8.2 IP数据报转发

如果数据包给到我们网卡数据链路层了，但是目的IP不是给我们网卡IP层的，那可能是想通过我们网卡转发该包。

相关宏：

IP_FORWARD_ALLOW_TX_ON_RX_NETIF：
- 允许ip_forward()在接收到数据包的netif上发送数据包。这应该只用于无线网络。
- 为1时，请确保netif驱动程序正确标记传入的链路层广播/组播数据包等使用相应的pbuf标志!

调用ip4_forward()将数据包转发：

先判断IP包是否能转发。主要调用ip4_canforward()判断。
- 钩子函数：LWIP_HOOK_IP4_CANFORWARD(src, dest)。现有用户实现钩子裁定能否转发当前IP包。
- 链路层的广播包。不能转发。
- 链路层的多播包。不能转发。
- 目的IP为255.x.x.x的IP包。不能转发。
- 目的IP为127.x.x.x（环回）的IP包。不能转发。
- 目的IP为169.254.x.x（本地链路IP）的IP包，不能转发。
匹配新网卡。调用ip4_route_src(src, dest)路由匹配网卡，进行转发该IP包。
检查路由匹配成功的网卡。
- 一般情况下，是不能转发回原链路的。
- 如果需要转发回原链路，一般只能用于无线网卡。
IP报文TTL字段值减1。如果TTL值为0，则，丢弃该IP包，并通过ICMP icmp_dest_unreach(struct pbuf *p, enum icmp_dur_type t)告知源端路由不可达。（如果当前报文也是ICMP报文，则不用回复ICMP路由不可达）
TTL字段值更新后，IP报文的首部校验和字段也要更新。
- 技巧：由于IP报文首部只是TTL字段减1，所以首部校验和字段只需要加1即可。
使用新路由匹配的网卡把当前IP包转发出去。
- 需要分片：调用ip4_frag()转发出去。
- 不需要分片：调用网卡IP接口netif->output()转发出去。

ip4_canforward()：

/**

 * Determine whether an IP address is in a reserved set of addresses

 * that may not be forwarded, or whether datagrams to that destination

 * may be forwarded.

 * @param p the packet to forward

 * @return 1: can forward 0: discard

 */

static int

ip4_canforward(struct pbuf *p)

{

  u32_t addr = lwip_htonl(ip4_addr_get_u32(ip4_current_dest_addr()));

#ifdef LWIP_HOOK_IP4_CANFORWARD

  /* 先钩子函数裁定 */

  int ret = LWIP_HOOK_IP4_CANFORWARD(p, addr);

  if (ret >= 0) {

    return ret;

  }

#endif /* LWIP_HOOK_IP4_CANFORWARD */

  if (p->flags & PBUF_FLAG_LLBCAST) {

    /* don't route link-layer broadcasts */

    return 0;

  }

  if ((p->flags & PBUF_FLAG_LLMCAST) || IP_MULTICAST(addr)) {

    /* don't route link-layer multicasts (use LWIP_HOOK_IP4_CANFORWARD instead) */

    return 0;

  }

  if (IP_EXPERIMENTAL(addr)) {

    return 0;

  }

  if (IP_CLASSA(addr)) {

    u32_t net = addr & IP_CLASSA_NET;

    if ((net == 0) || (net == ((u32_t)IP_LOOPBACKNET << IP_CLASSA_NSHIFT))) {

      /* don't route loopback packets */

      return 0;

    }

  }

  return 1;

}

ip4_forward()：

/**

 * Forwards an IP packet. It finds an appropriate route for the

 * packet, decrements the TTL value of the packet, adjusts the

 * checksum and outputs the packet on the appropriate interface.

 *

 * @param p the packet to forward (p->payload points to IP header)

 * @param iphdr the IP header of the input packet

 * @param inp the netif on which this packet was received

 */

static void

ip4_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)

{

  struct netif *netif;

  PERF_START;

  LWIP_UNUSED_ARG(inp);

  if (!ip4_canforward(p)) {

    goto return_noroute;

  }

  /* RFC3927 2.7:不转发链路本地地址 */

  if (ip4_addr_islinklocal(ip4_current_dest_addr())) {

    LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not forwarding LLA %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",

                           ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()),

                           ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr())));

    goto return_noroute;

  }

  /* 路由匹配网卡，找到将此IP包转发到的网卡 */

  netif = ip4_route_src(ip4_current_src_addr(), ip4_current_dest_addr());

  if (netif == NULL) {

    LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: no forwarding route for %"U16_F".%"U16_F".%"U16_F".%"U16_F" found\n",

                           ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()),

                           ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr())));

    /* @todo: send ICMP_DUR_NET? */

    goto return_noroute;

  }

#if !IP_FORWARD_ALLOW_TX_ON_RX_NETIF /* 不允许转发到原链路（无线网卡可以） */

  /* 不要将数据包转发到到达的同一个网络接口上 */

  if (netif == inp) {

    LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not bouncing packets back on incoming interface.\n"));

    goto return_noroute;

  }

#endif /* IP_FORWARD_ALLOW_TX_ON_RX_NETIF */

  /* 已经路由匹配到能转发当前IP包的网卡了 */

  /* TTL减1 */

  IPH_TTL_SET(iphdr, IPH_TTL(iphdr) - 1);

  if (IPH_TTL(iphdr) == 0) { /* TTL值已经到达0了 */

    MIB2_STATS_INC(mib2.ipinhdrerrors);

#if LWIP_ICMP

    /* 不要发送ICMP报文来响应ICMP报文 */

    if (IPH_PROTO(iphdr) != IP_PROTO_ICMP) {

      icmp_time_exceeded(p, ICMP_TE_TTL);

    }

#endif /* LWIP_ICMP */

    return;

  }

  /* 更新IP报文首部校验和。技巧：首部校验和加1即可。注意网络字节序。 */

  if (IPH_CHKSUM(iphdr) >= PP_HTONS(0xffffU - 0x100)) {

    IPH_CHKSUM_SET(iphdr, (u16_t)(IPH_CHKSUM(iphdr) + PP_HTONS(0x100) + 1));

  } else {

    IPH_CHKSUM_SET(iphdr, (u16_t)(IPH_CHKSUM(iphdr) + PP_HTONS(0x100)));

  }

  /* 当我们有多个netifs，其中至少有一个具有校验和卸载功能时，IP转发需要将各个校验和字段设置为0，以防止HW硬件算法计算无效的校验和 */

  /* https://github.com/lwip-tcpip/lwip/commit/61c67fc2295e522c7a12175581d6928c3951c0bf */

  /* http://savannah.nongnu.org/bugs/?func=detailitem&item_id=56288 */

  /* 这里有点没看明白：如果网卡没有硬件校验和卸载功能，lwip协议栈网卡开启CHECKSUM_GEN_IP宏使用软件校验和功能，那在这里转发IP包时，岂不是把数据包校验和字段都清空了？ */

  if (CHECKSUM_GEN_IP || NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_IP)) { /* 如果使用软件生成了校验和，这里需要清空 */

    IPH_CHKSUM_SET(iphdr, 0);

  }

  switch (IPH_PROTO(iphdr)) { /* 上层协议的校验和也清空 */

#if LWIP_UDP

#if LWIP_UDPLITE

  case IP_PROTO_UDPLITE:

#endif

  case IP_PROTO_UDP:

    if (CHECKSUM_GEN_UDP || NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_UDP)) {

      ((struct udp_hdr *)((u8_t *)iphdr + IPH_HL_BYTES(iphdr)))->chksum = 0;

    }

    break;

#endif

#if LWIP_TCP

  case IP_PROTO_TCP:

    if (CHECKSUM_GEN_TCP || NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_TCP)) {

      ((struct tcp_hdr *)((u8_t *)iphdr + IPH_HL_BYTES(iphdr)))->chksum = 0;

    }

    break;

#endif

#if LWIP_ICMP

  case IP_PROTO_ICMP:

    if (CHECKSUM_GEN_ICMP || NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP)) {

      ((struct icmp_hdr *)((u8_t *)iphdr + IPH_HL_BYTES(iphdr)))->chksum = 0;

    }

    break;

#endif

  default:

    /* there's really nothing to do here other than satisfying 'switch-default' */

    break;

  }

  LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: forwarding packet to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",

                         ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()),

                         ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr())));

  IP_STATS_INC(ip.fw);

  MIB2_STATS_INC(mib2.ipforwdatagrams);

  IP_STATS_INC(ip.xmit);

  PERF_STOP("ip4_forward");

  /* 分片检查&处理 */

  /* mtu为0，表示该网卡不支持分片 */

  if (netif->mtu && (p->tot_len > netif->mtu)) { /* 需要分片 */

    if ((IPH_OFFSET(iphdr) & PP_NTOHS(IP_DF)) == 0) {

#if IP_FRAG

      /* 分片发包 */

      ip4_frag(p, netif, ip4_current_dest_addr());

#else /* IP_FRAG */

      /* @todo: send ICMP Destination Unreachable code 13 "Communication administratively prohibited"? */

#endif /* IP_FRAG */

    } else {

#if LWIP_ICMP

      /* 发送ICMP目的不可达代码4: "Fragmentation Needed and DF Set" */

      icmp_dest_unreach(p, ICMP_DUR_FRAG);

#endif /* LWIP_ICMP */

    }

    return;

  }

  /* 不需要分片就直接发出IP层 */

  netif->output(netif, p, ip4_current_dest_addr());

  return;

return_noroute:

  MIB2_STATS_INC(mib2.ipoutnoroutes);

}

9.8.3 IP数据报重组

如果IP层收到一个IP报文，目的IP是给我们网卡IP层的，且检查当前IP包的首部是是一个分片包，则需要IP报文重组。

重组IP报文的源码实现比较复杂，所以需要耐心分析。

重装IP报文比分片IP报文要难，就是因为，重装IP报文的每个IP包到达的时间不是按顺序的，会出现后发的IP分片包比先发的IP分片包早到达（网络路由问题），这需要我们按序重组好。

注意：lwip当前不支持IP首部带选项字段的IP报文进行分片和重组。

9.8.3.1 相关数据结构

代码的数据结构是非常重要的，通过对数据结构的逻辑处理能封装出各种功能的API。

一个完整IP报文由多个IP分片包组成。

这个IP报文用struct ip_reassdata数据结构管理；

而每个IP分片包用struct ip_reass_helper数据结构管理。

为了节省空间，这个数据结构和IP包pbuf的空间共用。把收到的分片pbuf的IP包首部重置为这个数据结构。因为最终的IP报文只需要一个IP首部即可，每个分片的IP首部空间可以利用起来。

lwip协议栈用全局变量struct ip_reassdata *reassdatagrams;管理整个协议栈的各个在重组中的IP报文，为单向链表。

重组中的IP报文数据结构struct ip_reassdata：

/** IP reassembly helper struct.

 * This is exported because memp needs to know the size.

 */

struct ip_reassdata {

  struct ip_reassdata *next; /* 单向链表节点 */

  struct pbuf *p; /* pbuf链表。是当前IP分片包的pbuf，各个分片的链，是由struct ip_reass_helper数据结构管理。 */

  struct ip_hdr iphdr; /* 当前IP报文的IP首部 */

  u16_t datagram_len; /* 已经收到的IP报长度或IP报文总长度。如果收到最后一个分片，则当前值为IP报文总长度。 */

  u8_t flags; /* 是否收到最后一个分片 */

  u8_t timer; /* 设置超时间隔 */

};

各个IP分片包的数据结构struct ip_reass_helper：

struct ip_reass_helper {

  PACK_STRUCT_FIELD(struct pbuf *next_pbuf); /* 下一个IP分片 */

  PACK_STRUCT_FIELD(u16_t start); /* 分片中数据在IP报文的起始位置 */

  PACK_STRUCT_FIELD(u16_t end); /* 分片中数据在IP报文的结束位置 */

} PACK_STRUCT_STRUCT;

9.8.3.2 相关宏

IP_REASS_MAXAGE：默认15。为每个重组IP报文有效期。超时还没重组好就需要删除重组IP报文。

IP_REASS_MAX_PBUFS：系统重组IP报文所有pbuf节点上限值。

IP_REASS_FREE_OLDEST：若开启，遇到系统重组IP报文所有pbuf节点达到系统上限值IP_REASS_MAX_PBUFS后，允许释放旧的重组IP报文所有IP分片。

9.8.3.3 相关函数

ip4_reass(struct pbuf *p)：

IPv4分片报文重组函数。
供给lwip内核接收IP包时使用的API。
不支持待选项字段的IP报文进行重组。

ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen)：新建一个重组IP报文条目并插入reassdatagrams链表中。

ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)：释放一个重组IP报文条目。

ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)：释放一个重组IP报文条目及其所有pbuf。

ip_reass_remove_oldest_datagram(struct ip_hdr *fraghdr, int pbufs_needed)：删除老的重组IP报文。

ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p, int is_last)：插入IP分片到对应重组IP报文。

9.8.3.4 ip4_reass()

源码参考：ip4_frag.c

IP报文重组调用ip4_reass()先分析该函数的总体框架，后面再分析各个函数的细节：

检查IP分片包。
- 收到一个IP分片后，检查IP分片的合法性。IP首部长度是否符合要求。目前LWIP不支持带选项的IP包分片和重组。
- IP首部长度不能大于IP包长度。
- 确保重组中的IP报文所有pbuf节点不能超过系统上限值IP_REASS_MAX_PBUFS。如果预判超出了，需要调用ip_reass_remove_oldest_datagram()删除最老的重组中的IP报文，直至够空间记录当前IP分片包的pbuf节点数为止。
记录IP分片包到reassdatagrams链表中对应IP报文。
- 找到当前IP分片的重组IP报文：检索reassdatagrams链表，是否有当前IP分片的IP报文。如果没有，需要调用ip_reass_enqueue_new_datagram()创建一个新的重组IP报文数据结构，并插入到reassdatagrams链表中。如果有，还需要检查当前IP分片是否是IP报文中的第一个IP分片包，如果是，需要把这个IP分片包的IP首部更新到重组IP报文数据结构的IP报文首部字段ip_reassdata->iphdr。
  - 匹配重组IP报文条件：源IP、目的IP、IP标识这三个字段一致即可。
- 预判IP报文是否溢出：如果当前IP分片包是最后一个，可以通过IP分片偏移量加上当前IP分片包的长度可以计算出完整的IP报文长度，如果这个长度溢出IP报文的长度字段，则丢弃，并删除重组中的IP报文。
- 当前IP分片插入重组IP报文的IP分片链表中。调用ip_reass_chain_frag_into_datagram_and_validate()将其插入。返回值由以下三个：
  - IP_REASS_VALIDATE_TELEGRAM_FINISHED：所有IP分片已经接收完毕，可以完成IP报文重组工作。
  - IP_REASS_VALIDATE_PBUF_QUEUED：当前IP分片正常插入，但是当前IP报文还没有接收完所有IP分片。
  - IP_REASS_VALIDATE_PBUF_DROPPED：当前IP分片插入失败，即是丢弃当前IP分片。
- 更新reassdatagrams链表中所有pbuf节点的数量值ip_reass_pbufcount（全局）。因为系统设置有上限IP_REASS_MAX_PBUFS，所以要动态记录。
当前IP分片是否为最后一个分片。
- 如果是最后一个分片，则更新重组IP报文数据结构中的长度值为总长度值ip_reassdata->datagram_len，标记重组IP报文收到最后一个IP分片ip_reassdata->flags |= IP_REASS_FLAG_LASTFRAG。
IP报文的所有IP分片包是否已经接收完毕。
- 如果所有IP分片都收到了，则可进行重组。
重组完整IP报文。遍历所有IP分片，并合并。节省空间。
- 统计IP报文的总长度。首部+数据=IP_HLEN+ip_reassdata->datagram_len。
- 把重组IP报文数据结构中的IP首部字段拷贝到第一个分片的IP首部作为完整IP报文的首部。
- 遍历重组IP报文中所有IP分片，将其合并，除了首个IP分片的IP首部作为完整IP报文的首部外，其它IP分片的IP首部都移除。
- 至此，完整的IP报文pbuf重组完成。

/**

 * Reassembles incoming IP fragments into an IP datagram.

 *

 * @param p points to a pbuf chain of the fragment

 * @return NULL if reassembly is incomplete, ? otherwise

 */

struct pbuf *

ip4_reass(struct pbuf *p)

{

  struct pbuf *r; /* pbuf指针 */

  struct ip_hdr *fraghdr; /* IP首部指针 */

  struct ip_reassdata *ipr; /* 重组IP报文指针 */

  struct ip_reass_helper *iprh; /* IP分片节点管理数据结构指针 */

  u16_t offset, len, clen; /* 分片偏移量，分片长度，分片pbuf节点数 */

  u8_t hlen; /* IP分片首部长度 */

  int valid; /* 插入IP分片后的结果 */

  int is_last; /* 最后一个分片标志 */

  IPFRAG_STATS_INC(ip_frag.recv);

  MIB2_STATS_INC(mib2.ipreasmreqds);

  fraghdr = (struct ip_hdr *)p->payload; /* 获取IP分片首部 */

  if (IPH_HL_BYTES(fraghdr) != IP_HLEN) { /* 不支持带选项字段的IP报文重组 */

    LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: IP options currently not supported!\n"));

    IPFRAG_STATS_INC(ip_frag.err);

    goto nullreturn;

  }

  offset = IPH_OFFSET_BYTES(fraghdr); /* 获取分片偏移量 */

  len = lwip_ntohs(IPH_LEN(fraghdr)); /* 获取分片包长度 */

  hlen = IPH_HL_BYTES(fraghdr); /* 获取分片首部长度 */

  if (hlen > len) { /* 校验 */

    /* invalid datagram */

    goto nullreturn;

  }

  len = (u16_t)(len - hlen); /* 获取IP分片数据字段长度 */

  /* 检查是否允许我们排队更多的数据报 */

  clen = pbuf_clen(p); /* 获取当前IP分片包含多少个pbuf节点 */

  /* 预测当前分片插入重组IP报文后，整个系统的重组IP报文的所有pbuf节点是否超过系统上限值IP_REASS_MAX_PBUFS。

     若超过，需要释放老的重组IP报文来腾出空间 */

  if ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) { /* 预测的结果超过系统上限值 */

#if IP_REASS_FREE_OLDEST /* 允许释放老的重组IP报文 */

    if (!ip_reass_remove_oldest_datagram(fraghdr, clen) || /* 释放失败 */

        ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS)) /* 或者尽可能释放了，但是还是不能满足当前IP分片的插入 */

#endif /* IP_REASS_FREE_OLDEST */

    { /* 需要丢弃当前IP分片 */

      /* 没有数据报被释放，仍然有太多的pbuf进入队列 */

      LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: Overflow condition: pbufct=%d, clen=%d, MAX=%d\n",

                                   ip_reass_pbufcount, clen, IP_REASS_MAX_PBUFS));

      IPFRAG_STATS_INC(ip_frag.memerr);

      /* @todo: 发送ICMP时间超过这里? */

      /* 丢弃当前IP分片 */

      goto nullreturn;

    }

  }

  /* 在当前数据报队列中查找分片所属的重组IP报文，记住队列中的前一个，以便以后退出队列 */

  for (ipr = reassdatagrams; ipr != NULL; ipr = ipr->next) {

    /* 检查传入的片段是否与当前出现在重组缓冲区中的片段相匹配。如果是这样，我们继续将这个片段复制到缓冲区中 */

    if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) { /* 匹配成功。根据源IP、目的IP和IP标识这三个字段进行匹配。 */

      LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n",

                                   lwip_ntohs(IPH_ID(fraghdr))));

      IPFRAG_STATS_INC(ip_frag.cachehit);

      break; /* 跳出 */

    }

  }

  if (ipr == NULL) { /* 还没有当前IP分片的重组IP报文呢，需要新建 */

    /* 创建新的重组IP报文，并插入到全局链表reassdatagrams */

    ipr = ip_reass_enqueue_new_datagram(fraghdr, clen);

    if (ipr == NULL) { /* 创建或插入失败，丢弃当前IP分片 */

      goto nullreturn;

    }

  } else { /* 已经存在 */

    if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && /* IP报文的第一个IP分片 */

        ((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) { /* 还没有记录过第一个分片的IP首部 */

      /* 最先收到的IP分片不一定是IP报文的第一个IP分片。这里需要第一个IP分片的首部是因为对于超过ICMP时间和之后，为了复制所有选项 */

      SMEMCPY(&ipr->iphdr, fraghdr, IP_HLEN); /* IP报文的第一个IP分片的IP首部作为整个IP报文首部的基础 */

    }

  }

  /* 此时，我们已经创建了一个新重组IP报文，或者指向一个现有重组IP报文 */

  /* 检查整个IP报文的长度字段是否合法 */

  /* 可以通过最后一个IP分片的偏移量和分片数据区长度可以计算出完整的IP报文的数据区总长度 */

  is_last = (IPH_OFFSET(fraghdr) & PP_NTOHS(IP_MF)) == 0;

  if (is_last) {

    u16_t datagram_len = (u16_t)(offset + len);

    if ((datagram_len < offset) || (datagram_len > (0xFFFF - IP_HLEN))) {

      /* u16_t 溢出，无法处理此操作 */

      goto nullreturn_ipr;

    }

  }

  /* 找到插入这个pbuf的正确位置 */

  /* @todo: 如果片段重叠，则修剪pbufs */

  valid = ip_reass_chain_frag_into_datagram_and_validate(ipr, p, is_last);

  if (valid == IP_REASS_VALIDATE_PBUF_DROPPED) { /* 插入失败，丢弃当前IP分片 */

    goto nullreturn_ipr;

  }

  /* 如果我们来到这里，pbuf已经被加入队列 */

  /* 更新重组IP报文数据结构相关字段 */

  ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount + clen); /* 更新全局当前所有重组IP报文的pbuf节点数，用于判断是否踩上限线 */

  if (is_last) { /* 如果是最后一个分片，则可以知道整个IP报文的长度 */

    u16_t datagram_len = (u16_t)(offset + len); /* 偏移量+当前分片IP包数据区长度就是IP报文数据区总长度 */

    ipr->datagram_len = datagram_len; /* 转为记录IP报文数据区总长度 */

    ipr->flags |= IP_REASS_FLAG_LASTFRAG; /* 标记已经收到最后一个IP分片，且上面长度值改为记录IP报文数据区总长度 */

    LWIP_DEBUGF(IP_REASS_DEBUG,

                ("ip4_reass: last fragment seen, total len %"S16_F"\n",

                 ipr->datagram_len));

  }

  if (valid == IP_REASS_VALIDATE_TELEGRAM_FINISHED) { /* 全部IP分片接收完毕，可以进行重组 */

    struct ip_reassdata *ipr_prev;

    u16_t datagram_len = (u16_t)(ipr->datagram_len + IP_HLEN); /* IP报文总长度 */

    r = ((struct ip_reass_helper *)ipr->p->payload)->next_pbuf; /* r指向第二个分片 */

    /* 将原始IP头复制回第一个pbuf，作为完整IP报文的IP首部 */

    fraghdr = (struct ip_hdr *)(ipr->p->payload);

    SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN);

    IPH_LEN_SET(fraghdr, lwip_htons(datagram_len));

    IPH_OFFSET_SET(fraghdr, 0); /* 清空偏移量和标志字段 */

    IPH_CHKSUM_SET(fraghdr, 0); /* 清空首部校验和 */

    /* @todo: do we need to set/calculate the correct checksum? */

#if CHECKSUM_GEN_IP

    IF__NETIF_CHECKSUM_ENABLED(ip_current_input_netif(), NETIF_CHECKSUM_GEN_IP) {

      IPH_CHKSUM_SET(fraghdr, inet_chksum(fraghdr, IP_HLEN)); /* 重置IP首部校验和 */

    }

#endif /* CHECKSUM_GEN_IP */

    p = ipr->p; /* p指向第一个分片 */

    /* 遍历所有分片将其合并到第一个分片的pbuf中 */

    while (r != NULL) {

      iprh = (struct ip_reass_helper *)r->payload; /* 获取IP分片管理区 */

      pbuf_remove_header(r, IP_HLEN); /* 隐藏每个后续片段的IP头 */

      pbuf_cat(p, r); /* 合并分片 */

      r = iprh->next_pbuf; /* 指向下一个分片。遍历 */

    }

    /* 重组完毕，需要移除重组IP报文相关资源 */

    if (ipr == reassdatagrams) { /* reassdatagrams链表是一个没有哨兵的单向非循环链表。如果移除的是首节点，则不需要记录前一个节点 */

      ipr_prev = NULL;

    } else { /* 如果不是首个节点，则需要知道这个节点的前一个节点，才能把当前节点从单向链表中正常删除 */

      for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) {

        if (ipr_prev->next == ipr) {

          break; /* 找到了 */

        }

      }

    }

    /* 释放重组IP报文的节点 */

    ip_reass_dequeue_datagram(ipr, ipr_prev);

    /* 并调整当前排队等待重组的pbuf的数量 */

    clen = pbuf_clen(p);

    LWIP_ASSERT("ip_reass_pbufcount >= clen", ip_reass_pbufcount >= clen);

    ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - clen);

    MIB2_STATS_INC(mib2.ipreasmoks);

    /* 返回重组后的IP报文pbuf */

    return p;

  }

  /* 还没收到所有IP分片 */

  LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_pbufcount: %d out\n", ip_reass_pbufcount));

  return NULL;

nullreturn_ipr: /* 丢弃当前IP分片 */

  LWIP_ASSERT("ipr != NULL", ipr != NULL);

  if (ipr->p == NULL) {

    /* 在创建新的数据报条目后删除pbuf:也删除该条目 */

    LWIP_ASSERT("not firstalthough just enqueued", ipr == reassdatagrams);

    ip_reass_dequeue_datagram(ipr, NULL);

  }

nullreturn:

  LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: nullreturn\n"));

  IPFRAG_STATS_INC(ip_frag.drop);

  pbuf_free(p); /* 丢弃当前IP分片，释放pbuf资源 */

  return NULL;

}

9.8.3.5 ip_reass_enqueue_new_datagram()

ip_reass_enqueue_new_datagram()：

申请重组IP报文节点ip_reassdata数据结构的空间。
如果MEMP_REASSDATA内存池空间不足，则可以释放老的重组IP报文节点。
初始化该结构体。
有效期配置为IP_REASS_MAXAGE。
插入reassdatagrams链表。
保存IP分片包首部。

/**

 * Enqueues a new fragment into the fragment queue

 * @param fraghdr points to the new fragments IP hdr

 * @param clen number of pbufs needed to enqueue (used for freeing other datagrams if not enough space)

 * @return A pointer to the queue location into which the fragment was enqueued

 */

static struct ip_reassdata *

ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen)

{

  struct ip_reassdata *ipr;

#if ! IP_REASS_FREE_OLDEST

  LWIP_UNUSED_ARG(clen);

#endif

  /* 申请一个新的reassdata结构体 */

  ipr = (struct ip_reassdata *)memp_malloc(MEMP_REASSDATA);

  if (ipr == NULL) {

#if IP_REASS_FREE_OLDEST

    /* 空间不足就释放老的重组IP报文条目 */

    if (ip_reass_remove_oldest_datagram(fraghdr, clen) >= clen) {

      ipr = (struct ip_reassdata *)memp_malloc(MEMP_REASSDATA);

    }

    if (ipr == NULL)

#endif /* IP_REASS_FREE_OLDEST */

    {

      IPFRAG_STATS_INC(ip_frag.memerr);

      LWIP_DEBUGF(IP_REASS_DEBUG, ("Failed to alloc reassdata struct\n"));

      return NULL; /* 申请资源失败 */

    }

  }

  memset(ipr, 0, sizeof(struct ip_reassdata));

  ipr->timer = IP_REASS_MAXAGE;/* 有效期赋值 */

  /* 插入单向链表头 */

  ipr->next = reassdatagrams;

  reassdatagrams = ipr;

  /* 复制IP头，以便稍后进行测试和输入 */

  /* @todo: no ip options supported? */

  SMEMCPY(&(ipr->iphdr), fraghdr, IP_HLEN);

  return ipr;

}

9.8.3.6 ip_reass_dequeue_datagram()

ip_reass_dequeue_datagram()：

释放重组IP报文条目资源。
在过期还没重组好，或者已经重组好，或者需要为新的重组IP报文腾空间，都需要把不需要的重组IP报文删除，并从链表中移除。
ipr：需要删除的重组IP报文节点。
prev：被删除节点的前一个节点。由调用者提供。“奇怪的设计”

/**

 * Dequeues a datagram from the datagram queue. Doesn't deallocate the pbufs.

 * @param ipr points to the queue entry to dequeue

 */

static void

ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)

{

  if (reassdatagrams == ipr) { /* 如果删除的是链表头，需要更新链表头 */

    /* 更新链表头 */

    reassdatagrams = ipr->next;

  } else {

    /* 它不是第一个，所以它必须有一个有效的'prev' */

    LWIP_ASSERT("sanity check linked list", prev != NULL);

    prev->next = ipr->next; /* 从链表中移除当前重组IP报文条目 */

  }

  /* 释放资源 */

  memp_free(MEMP_REASSDATA, ipr);

}

9.8.3.7 ip_reass_free_complete_datagram()

ip_reass_free_complete_datagram()：

释放重组IP报文节点及其所有pbuf。
ICMP：如果收到了第一个IP分片，在重组删除时，需要返回一个ICMP超时。
释放重组IP报文的所有pbuf。
释放重组IP报文。

/**

 * Free a datagram (struct ip_reassdata) and all its pbufs.

 * Updates the total count of enqueued pbufs (ip_reass_pbufcount),

 * SNMP counters and sends an ICMP time exceeded packet.

 *

 * @param ipr datagram to free

 * @param prev the previous datagram in the linked list

 * @return the number of pbufs freed

 */

static int

ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)

{

  u16_t pbufs_freed = 0;

  u16_t clen;

  struct pbuf *p;

  struct ip_reass_helper *iprh;

  LWIP_ASSERT("prev != ipr", prev != ipr);

  if (prev != NULL) {

    LWIP_ASSERT("prev->next == ipr", prev->next == ipr);

  }

  MIB2_STATS_INC(mib2.ipreasmfails);

#if LWIP_ICMP

  iprh = (struct ip_reass_helper *)ipr->p->payload;

  if (iprh->start == 0) {

    /* 收到了第一个分片报文，发送ICMP超时 */

    /* 首先，从r->p中取出第一个pbuf. */

    p = ipr->p;

    ipr->p = iprh->next_pbuf;

    /* 然后，将原始头部复制过去 */

    SMEMCPY(p->payload, &ipr->iphdr, IP_HLEN);

    icmp_time_exceeded(p, ICMP_TE_FRAG);

    clen = pbuf_clen(p);

    LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff);

    pbufs_freed = (u16_t)(pbufs_freed + clen);

    pbuf_free(p); /* 释放pbuf */

  }

#endif /* LWIP_ICMP */

  /* 首先，free接收的所有pbufs。需要分别释放各个pbuf，因为它们还没有被链接 */

  p = ipr->p;

  while (p != NULL) {

    struct pbuf *pcur;

    iprh = (struct ip_reass_helper *)p->payload;

    pcur = p;

    /* 在释放之前获取下一个指针 */

    p = iprh->next_pbuf;

    clen = pbuf_clen(pcur);

    LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff);

    pbufs_freed = (u16_t)(pbufs_freed + clen);

    pbuf_free(pcur);

  }

  /* 然后，从列表中解耦结构ip_reassdata并释放它 */

  ip_reass_dequeue_datagram(ipr, prev);

  LWIP_ASSERT("ip_reass_pbufcount >= pbufs_freed", ip_reass_pbufcount >= pbufs_freed);

  ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - pbufs_freed);

  return pbufs_freed;

}

9.8.3.8 ip_reass_remove_oldest_datagram()

ip_reass_remove_oldest_datagram()：

删除老的重组IP报文。
受IP_REASS_FREE_OLDEST宏控制。
fraghdr：当前IP分片。传入该参数是因为防止在遍历链表删除老的IP重组IP报文时，跳过这个重组IP报文，因为我们的目的就是为这个重组IP报文新来的IP分片腾空间。
pbufs_needed：需要腾出的pbuf数。
逻辑简单：遍历、找到最老的非当前重组IP报文的重组IP报文节点、删除。一直遍历删除到够空闲pbuf数或者没有其它重组IP报文节点为止。

#if IP_REASS_FREE_OLDEST

/**

 * Free the oldest datagram to make room for enqueueing new fragments.

 * The datagram 'fraghdr' belongs to is not freed!

 *

 * @param fraghdr IP header of the current fragment

 * @param pbufs_needed number of pbufs needed to enqueue

 *        (used for freeing other datagrams if not enough space)

 * @return the number of pbufs freed

 */

static int

ip_reass_remove_oldest_datagram(struct ip_hdr *fraghdr, int pbufs_needed)

{

  /* @todo Can't we simply remove the last datagram in the linked list behind reassdatagrams? */

  struct ip_reassdata *r, *oldest, *prev, *oldest_prev;

  int pbufs_freed = 0, pbufs_freed_current;

  int other_datagrams;

  /* 释放数据报，直到允许进入'pbufs_needed' pbufs队列，但不要释放'fraghdr'所属的数据报! */

  do { /* 外循环：每次循环最多释放一个重组IP报文，但是不一定释放够pbuf节点数。 */

    oldest = NULL;

    prev = NULL;

    oldest_prev = NULL; /* 被删除的节点的前一个节点。单向链表删除节点的逻辑需要。 */

    other_datagrams = 0;

    r = reassdatagrams;

    while (r != NULL) { /* 内循环：遍历reassdatagrams，找出其它最老的重组IP报文 */

      if (!IP_ADDRESSES_AND_ID_MATCH(&r->iphdr, fraghdr)) { /* 和fraghdr不是同一个数据报，都需要被检索 */

        /* 记录和fraghdr不是同一个数据报个数 */

        other_datagrams++;

        if (oldest == NULL) {

          oldest = r;

          oldest_prev = prev;

        } else if (r->timer <= oldest->timer) {

          /* 比之前最老的还要老 */

          oldest = r;

          oldest_prev = prev;

        }

      }

      if (r->next != NULL) {

        prev = r;

      }

      r = r->next;

    }

    if (oldest != NULL) {

      /* 释放资源 */

      pbufs_freed_current = ip_reass_free_complete_datagram(oldest, oldest_prev);

      pbufs_freed += pbufs_freed_current; /* 记录已经释放了多少个pbuf节点 */

    }

  } while ((pbufs_freed < pbufs_needed) && (other_datagrams > 1)); /* 如果释放的pbuf节点满足要求，或者没有其它pbuf节点可以释放了，就退出循环 */

  return pbufs_freed; /* 返回释放pbuf节点的个数 */

}

#endif /* IP_REASS_FREE_OLDEST */

9.8.3.9 ip_reass_chain_frag_into_datagram_and_validate()

ip_reass_chain_frag_into_datagram_and_validate()：

检查和插入一个分片到重组数据报中。
ipr：重组IP数据报。
new_p：新的分片。
is_last：是否是最后一个分片。
返回：
- IP_REASS_VALIDATE_TELEGRAM_FINISHED：当前重组IP数据报已经收到所有分片。
- IP_REASS_VALIDATE_PBUF_QUEUED：分片成功插入重组IP数据报中，但是该重组IP数据报还没有接收到所有IP分片。
- IP_REASS_VALIDATE_PBUF_DROPPED：插入分片失败。
获取分片IP首部信息统计到重组IP数据报管理中。
插入分片到重组IP数据报的分片链表中。
如果最后一个IP分片收到了，就检查下所有分片是否都收到。

/**

 * Chain a new pbuf into the pbuf list that composes the datagram.  The pbuf list

 * will grow over time as  new pbufs are rx.

 * Also checks that the datagram passes basic continuity checks (if the last

 * fragment was received at least once).

 * @param ipr points to the reassembly state

 * @param new_p points to the pbuf for the current fragment

 * @param is_last is 1 if this pbuf has MF==0 (ipr->flags not updated yet)

 * @return see IP_REASS_VALIDATE_* defines

 */

static int

ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p, int is_last)

{

  struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev = NULL;

  struct pbuf *q;

  u16_t offset, len;

  u8_t hlen;

  struct ip_hdr *fraghdr;

  int valid = 1;

  /* 从当前分片中提取IP长度和IP分片偏移量 */

  fraghdr = (struct ip_hdr *)new_p->payload;

  len = lwip_ntohs(IPH_LEN(fraghdr));

  hlen = IPH_HL_BYTES(fraghdr);

  if (hlen > len) {

    /* 无效的数据报 */

    return IP_REASS_VALIDATE_PBUF_DROPPED;

  }

  len = (u16_t)(len - hlen); /* 获取IP分片数据区长度 */

  offset = IPH_OFFSET_BYTES(fraghdr); /* 获取偏移量 */

  /* IP分片的首部有用的信息已经统计到重组IP报文节点首部了，

     即是IP分片的首部中的数据可以丢弃，该空间可以利用起来，

     当前用于分片连接节点，指向下一个分片。

     即是把IP分片的首部部分空间重置为struct ip_reass_helper数据结构。 */

  LWIP_ASSERT("sizeof(struct ip_reass_helper) <= IP_HLEN",

              sizeof(struct ip_reass_helper) <= IP_HLEN);

  iprh = (struct ip_reass_helper *)new_p->payload; /* 提前分片IP首部重置为struct ip_reass_helper */

  iprh->next_pbuf = NULL;

  iprh->start = offset; /* 偏移量起始 */

  iprh->end = (u16_t)(offset + len);  /* 偏移量尾部 */

  if (iprh->end < offset) {

    /* u16_t 溢出，无法处理此操作 */

    return IP_REASS_VALIDATE_PBUF_DROPPED;

  }

  /* 插入分片链表。按分片偏移量升序插入 */

  for (q = ipr->p; q != NULL;) { /* 遍历分片链表 */

    iprh_tmp = (struct ip_reass_helper *)q->payload; /* 分片节点 */

    if (iprh->start < iprh_tmp->start) { /* 找到位置 */

      iprh->next_pbuf = q; /* 插入操作（链表） */

      if (iprh_prev != NULL) { /* 插入位置前面也有IP分片 */

        /* 而不是具有最低偏移量的分片 */

#if IP_REASS_CHECK_OVERLAP

        if ((iprh->start < iprh_prev->end) || (iprh->end > iprh_tmp->start)) {

          /* 插入分片与前一分片或后一分片重叠，丢弃 */

          return IP_REASS_VALIDATE_PBUF_DROPPED;

        }

#endif /* IP_REASS_CHECK_OVERLAP */

        iprh_prev->next_pbuf = new_p; /* 插入操作（链表） */

        if (iprh_prev->end != iprh->start) {

          /* 前一个分片与当前分片不连续，中间还缺数据，所以可以标记还没有接收到所有IP分片 */

          valid = 0;

        }

      } else { /* 当前分片插入的位置在接收到的所有分片之前 */

#if IP_REASS_CHECK_OVERLAP

        if (iprh->end > iprh_tmp->start) {

          /* 分片与下一个分片重叠，丢弃 */

          return IP_REASS_VALIDATE_PBUF_DROPPED;

        }

#endif /* IP_REASS_CHECK_OVERLAP */

        /* 更新链表头 */

        ipr->p = new_p;

      }

      break;

    } else if (iprh->start == iprh_tmp->start) { /* 收到重叠IP分片，丢弃 */

      return IP_REASS_VALIDATE_PBUF_DROPPED;

#if IP_REASS_CHECK_OVERLAP

    } else if (iprh->start < iprh_tmp->end) { /* 重叠:直接丢弃，不需要保留新数据报 */

      return IP_REASS_VALIDATE_PBUF_DROPPED;

#endif /* IP_REASS_CHECK_OVERLAP */

    } else { /* 插入分片偏移量比所有分片都要大，即是要插到链表最后 */

      /* 检查到目前为止收到的碎片是否没有洞 */

      if (iprh_prev != NULL) {

        if (iprh_prev->end != iprh_tmp->start) {

          /* 数据不连续，当前分片和前一个分片之间缺少分片，标记下未接收完所有IP分片 */

          valid = 0;

        }

      }

    }

    q = iprh_tmp->next_pbuf; /* 遍历下一个分片 */

    iprh_prev = iprh_tmp; /* 保存前一个分片 */

  }

  /* 如果q为空，即是到达链表尾了 */

  if (q == NULL) {

    if (iprh_prev != NULL) { /* 如果 */

      /* 这是(目前)，偏移量最大的分片:插入链表尾 */

#if IP_REASS_CHECK_OVERLAP

      LWIP_ASSERT("check fragments don't overlap", iprh_prev->end <= iprh->start);

#endif /* IP_REASS_CHECK_OVERLAP */

      iprh_prev->next_pbuf = new_p; /* 插入 */

      if (iprh_prev->end != iprh->start) { /* 还缺少IP分片 */

        valid = 0; /* 标记还没接收到所有IP分片 */

      }

    } else { /* 当前重组IP报文中还没有IP分片 */

#if IP_REASS_CHECK_OVERLAP

      LWIP_ASSERT("no previous fragment, this must be the first fragment!",

                  ipr->p == NULL);

#endif /* IP_REASS_CHECK_OVERLAP */

      /* 这是我们收到的这个IP数据报的第一个分片 */

      ipr->p = new_p;

    }

  }

  /* 至此，插入完毕，检查是否已经收到所有IP分片 */

  /* 如果我们已经收到了最后一个碎片 */

  if (is_last || ((ipr->flags & IP_REASS_FLAG_LASTFRAG) != 0)) { /* 最后一个分片收到了 */

    if (valid) { /* 前面遍历插入分片前面的所有分片时也没有发现有数据不连续 */

      /* 继续检查后面没有被遍历过的IP分片 */

      if ((ipr->p == NULL) || (((struct ip_reass_helper *)ipr->p->payload)->start != 0)) { /* 还没收到第一个分片 */

        valid = 0; /* 标记还没接收到所有IP分片 */

      } else { /* 首尾IP分片都收到了，需要遍历剩余的 */

        /* 并且检查这个数据报之后是否没有漏洞 */

        iprh_prev = iprh;

        q = iprh->next_pbuf;

        while (q != NULL) { /* 遍历 */

          iprh = (struct ip_reass_helper *)q->payload;

          if (iprh_prev->end != iprh->start) { /* 发现漏洞 */

            valid = 0; /* 标记还没有接收到所有IP分片 */

            break; /* 退出遍历 */

          }

          iprh_prev = iprh;

          q = iprh->next_pbuf;

        }

        if (valid) { /* 至此，说明当前IP报文的所有IP分片已到达，打个log庆祝下 */

          LWIP_ASSERT("sanity check", ipr->p != NULL);

          LWIP_ASSERT("sanity check",

                      ((struct ip_reass_helper *)ipr->p->payload) != iprh);

          LWIP_ASSERT("validate_datagram:next_pbuf!=NULL",

                      iprh->next_pbuf == NULL);

        }

      }

    }

    /* 按需返回 */

    return valid ? IP_REASS_VALIDATE_TELEGRAM_FINISHED : IP_REASS_VALIDATE_PBUF_QUEUED;

  }

  /* 至此，IP分片插入正常，但是还没有收到所有IP分片 */

  return IP_REASS_VALIDATE_PBUF_QUEUED;

}

9.8.3.10 重组IP数据报的超时机制

每个重组的IP数据报都有生命周期，超时都还没接收完所有IP分片包，则需要放弃等待剩余分片，并释放该重组IP数据报所有资源。

决定删除重组的IP数据报时，需要返回ICMP超时到网络中告知对端放弃本次IP报文接收。

节拍由IP_TMR_INTERVAL决定，默认1000，即是1秒跑一次。

每个重组IP报文最大时间为IP_REASS_MAXAGE，默认15。即是系统收到第一个得到的分片IP开始计时，在15秒内没有接收完所有IP报文，便要放弃本次重组。

ip_reass_tmr()：

概述的目的就是遍历重组IP报文链表，检查每个正在重组的IP报文有效期，过期的删除，未过期的减少有效期。

/**

 * Reassembly timer base function

 * for both NO_SYS == 0 and 1 (!).

 *

 * Should be called every 1000 msec (defined by IP_TMR_INTERVAL).

 */

void

ip_reass_tmr(void)

{

  struct ip_reassdata *r, *prev = NULL;

  r = reassdatagrams;

  while (r != NULL) {

    /* 减量计时器，一旦它达到0，清理不完整的分片 */

    if (r->timer > 0) {

      r->timer--; /* 有效期减少 */

      LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer dec %"U16_F"\n", (u16_t)r->timer));

      prev = r;

      r = r->next; /* 遍历下一个 */

    } else { /* 当前重组IP条目已经过期了 */

      struct ip_reassdata *tmp; /* 过渡变量 */

      LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer timed out\n"));

      tmp = r;

      /* 在释放之前获取下一个重组IP报文指针 */

      r = r->next;

      /* 删除过期的重组IP报文：删除重组IP报文节点资源及其所有的IP分片pbuf */

      ip_reass_free_complete_datagram(tmp, prev);

    }

  }

}