IP是TCP/IP协议族中最为核心的协议，TCP、UDP、ICMP及IGMP数据都以IP数据报格式传输。IP主要功能是寻址与路由和分片与重组。
对于主机来说，IP路由选择是非常简单的。如果目的主机与源主机直接相连或都在一个共享网络上，那么IP数据报就直接送到目的主机上。否则，主机把数据报发往一默认的路由器上，由路由器来转发该数据报。大多数的主机都是采用这种简单机制，IP是不可靠的数据报传送服务，不能保证IP数据报能成功地到达目的地。
当路由器从一个大MTU值的网络上接收数据，并将数据报转发到具有较小MTU值的网络上时，就需要对数据报进行分片处理，并在最终的目的地进行重组。IP是无连接的数据报传送服务，每个数据报的处理都是相互独立的，IP数据报可以不按发送顺序接收。
IP首部格式
/* IP头部长度 */
#define IP_HLEN 20
/* 协议类型 */
#define IP_PROTO_ICMP 1
#define IP_PROTO_UDP 17
#define IP_PROTO_UDPLITE 136
#define IP_PROTO_TCP 6
struct ip_hdr {
PACK_STRUCT_FIELD(u16_t _v_hl_tos); //版本号+首部长度+服务类型
PACK_STRUCT_FIELD(u16_t _len); //总长度(IP首部+数据区)
PACK_STRUCT_FIELD(u16_t _id); //数据包标识(编号)
PACK_STRUCT_FIELD(u16_t _offset); //标志+片偏移
/* IP首部标志定义 */
#define IP_RF 0x8000 //保留
#define IP_DF 0x4000 //是否允许分片
#define IP_MF 0x2000 //后续是否还有更多分片
#define IP_OFFMASK 0x1fff //片偏移域掩码
PACK_STRUCT_FIELD(u16_t _ttl_proto); //生存时间(最大转发次数)+协议类型(IGMP:1、UDP:17、TCP:6)
PACK_STRUCT_FIELD(u16_t _chksum); //校验和(IP首部)
PACK_STRUCT_FIELD(struct ip_addr src); //源IP地址
PACK_STRUCT_FIELD(struct ip_addr dest); //目的IP地址
} PACK_STRUCT_STRUCT;先看IP数据报输出
/* 发送IP数据包 */
err_t ip_output(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest, u8_t ttl, u8_t tos, u8_t proto)
{
struct netif *netif;
/* 根据IP地址选择一个合适(和目的主机处于同一子网)的网络接口 */
if ((netif = ip_route(dest)) == NULL) {
return ERR_RTE;
}
/* 指定网络接口发送IP数据包 */
return ip_output_if(p, src, dest, ttl, tos, proto, netif);
}
/* 指定网络接口发送IP数据包 */
err_t ip_output_if(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest, u8_t ttl, u8_t tos, u8_t proto, struct netif *netif)
{
struct ip_hdr *iphdr;
static u16_t ip_id = 0;
snmp_inc_ipoutrequests();
/* 生成IP头部 */
if (dest != IP_HDRINCL) {
u16_t ip_hlen = IP_HLEN;
/* 向前调整出IP头部空间 */
if (pbuf_header(p, IP_HLEN)) {
return ERR_BUF;
}
/* IP头部指针 */
iphdr = p->payload;
/* 设置生存时间(最大转发次数) */
IPH_TTL_SET(iphdr, ttl);
/* 设置协议类型(IGMP:1、UDP:17、TCP:6) */
IPH_PROTO_SET(iphdr, proto);
/* 设置目的IP地址 */
ip_addr_set(&(iphdr->dest), dest);
/* 设置版本号+首部长度+服务类型 */
IPH_VHLTOS_SET(iphdr, 4, ip_hlen / 4, tos);
/* 设置总长度(IP首部+数据区) */
IPH_LEN_SET(iphdr, htons(p->tot_len));
/* 设置标志+片偏移 */
IPH_OFFSET_SET(iphdr, 0);
/* 设置数据包标识(编号) */
IPH_ID_SET(iphdr, htons(ip_id));
/* 每发送一个数据包，编号加一 */
++ip_id;
/* 没有指定源IP地址 */
if (ip_addr_isany(src)) {
/* 将当前网络接口IP地址设置为源IP地址 */
ip_addr_set(&(iphdr->src), &(netif->ip_addr));
}
/* 设置源IP地址 */
else {
ip_addr_set(&(iphdr->src), src);
}
/* 设置校验和 */
IPH_CHKSUM_SET(iphdr, 0);
IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, ip_hlen));
}
/* IP头部已经包含在pbuf中 */
else {
iphdr = p->payload;
dest = &(iphdr->dest);
}
/* 如果数据包总长度大于MTU，则分片发送 */
if (netif->mtu && (p->tot_len > netif->mtu)) {
return ip_frag(p,netif,dest);
}
/* 如果数据包总长度不大于MTU，则直接发送 */
return netif->output(netif, p, dest);
}在上述函数中，ip_route函数用于IP选路，ip_frag函数用于IP分片
先看ip_route
/* 根据IP地址选择一个合适(和目的主机处于同一子网)的网络接口 */
struct netif *ip_route(struct ip_addr *dest)
{
struct netif *netif;
/* 遍历网络接口链表 */
for(netif = netif_list; netif != NULL; netif = netif->next) {
/* 网络接口已经启动 */
if (netif_is_up(netif)) {
/* 该网络接口和目的主机处于同一子网 */
if (ip_addr_netcmp(dest, &(netif->ip_addr), &(netif->netmask))) {
return netif;
}
}
}
/* 没有设置默认网络接口或默认网络接口没有启动，直接返回错误 */
if ((netif_default == NULL) || (!netif_is_up(netif_default))) {
return NULL;
}
/* 找不到合适的网络接口，返回默认网络接口 */
return netif_default;
}再看ip_frag，每个数据分片包含一个IP首部，该首部基本复制了原始的数据报IP首部（仅改变 标志+片偏移量），首部后面是数据分片携带的数据，每个分片的总长度应该小于底层网络的MTU值。
如下图，显示了一个原始数据报被分片后的场景
/* IP分片pbuf的有效数据缓冲区 */
static u8_t buf[LWIP_MEM_ALIGN_SIZE(IP_FRAG_MAX_MTU + MEM_ALIGNMENT - 1)];
/* IP数据报分片发送 */
err_t ip_frag(struct pbuf *p, struct netif *netif, struct ip_addr *dest)
{
struct pbuf *rambuf;
struct pbuf *header;
struct ip_hdr *iphdr;
u16_t nfb;
u16_t left, cop;
u16_t mtu = netif->mtu;
u16_t ofo, omf;
u16_t last;
u16_t poff = IP_HLEN;
u16_t tmp;
/* 为IP数据报分片申请pbuf */
rambuf = pbuf_alloc(PBUF_LINK, 0, PBUF_REF);
if (rambuf == NULL) {
return ERR_MEM;
}
/* 初始化分片的len和tot_len为该网络接口的mtu值 */
rambuf->tot_len = rambuf->len = mtu;
/* 将分片的有效数据缓冲区指向静态数据缓冲区buf */
rambuf->payload = LWIP_MEM_ALIGN((void *)buf);
/* 分片的IP头部指针 */
iphdr = rambuf->payload;
/* 将IP头部从原pbuf中拷贝到分片pbuf中 */
SMEMCPY(iphdr, p->payload, IP_HLEN);
/* 原数据报中的标志和片偏移 */
tmp = ntohs(IPH_OFFSET(iphdr));
ofo = tmp & IP_OFFMASK;
omf = tmp & IP_MF;
/* 原IP数据报中数据总长度 */
left = p->tot_len - IP_HLEN;
/* 分片中可以存放的最大数据量(8字节为单位) */
nfb = (mtu - IP_HLEN) / 8;
/* 将原数据报循环分片发送 */
while (left) {
/* 检查当前分片是不是最后一片 */
last = (left <= mtu - IP_HLEN);
/* 重新合成当前分片标志+片偏移字段 */
tmp = omf | (IP_OFFMASK & (ofo));
if (!last) //最后一个分片
tmp = tmp | IP_MF;
/* 计算当前分片数据总长度 */
cop = last ? left : nfb * 8;
/* 从原始数据报中将分片数据拷贝出来 */
poff += pbuf_copy_partial(p, (u8_t *)iphdr + IP_HLEN, cop, poff);
/* 更新分片标志+片偏移字段 */
IPH_OFFSET_SET(iphdr, htons(tmp));
/* 更新分片总长度(IP首部+数据区) */
IPH_LEN_SET(iphdr, htons(cop + IP_HLEN));
/* 更新分片检验和 */
IPH_CHKSUM_SET(iphdr, 0);
IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
/* 最后一个分片，调整数据长度(len和tot_len) */
if (last)
pbuf_realloc(rambuf, left + IP_HLEN);
/* 为当前的分片申请以太网首部空间 */
header = pbuf_alloc(PBUF_LINK, 0, PBUF_RAM);
if (header != NULL) {
/* 将以太网首部和当前IP分片拼接起来 */
pbuf_chain(header, rambuf);
/* 调用函数(etharp_output)将当前分片数据报(以太网首部+IP分片)发送 */
netif->output(netif, header, dest);
/* 发送完成将以太网首部+IP分片释放 */
pbuf_free(header);
}
/* 申请失败 */
else {
/* 释放当前IP分片 */
pbuf_free(rambuf);
return ERR_MEM;
}
/* 计算剩余数据总长度 */
left -= cop;
/* 计算片偏移量 */
ofo += nfb;
}
/* 释放分片pbuf结构体 */
pbuf_free(rambuf);
return ERR_OK;
}IP数据报输入
/* 当前接收数据包的网络接口指针 */
struct netif *current_netif;
/* 当前接收数据包的IP头部指针 */
const struct ip_hdr *current_header;
/* IP数据包输入处理 */
err_t ip_input(struct pbuf *p, struct netif *inp)
{
struct ip_hdr *iphdr;
struct netif *netif;
u16_t iphdr_hlen;
u16_t iphdr_len;
/* IP头部指针 */
iphdr = p->payload;
/* IP版本不是IPv4 */
if (IPH_V(iphdr) != 4) {
/* 释放数据包，不做任何处理 */
pbuf_free(p);
return ERR_OK;
}
/* IP首部字节数 */
iphdr_hlen = IPH_HL(iphdr);
iphdr_hlen *= 4;
/* IP数据包总长度(IP首部+数据区) */
iphdr_len = ntohs(IPH_LEN(iphdr));
/* IP首部长度大于第一个pbuf数据长度，或IP数据包总长度大于pbuf链表数据总长度 */
if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len)) {
/* 释放数据包，不做任何处理 */
pbuf_free(p);
return ERR_OK;
}
/* 检查校验和出错 */
if (inet_chksum(iphdr, iphdr_hlen) != 0) {
/* 释放数据包，不做任何处理 */
pbuf_free(p);
return ERR_OK;
}
/* 收缩pbuf数据区，剥离IP头部 */
pbuf_realloc(p, iphdr_len);
{
int first = 1;
/* 遍历所有网络接口，判断该数据包是不是发送给自己 */
netif = inp; //首先判断是不是接收数据包的网络接口，这个概率较大
do {
/* 网络接口已启动且已经配置IP */
if ((netif_is_up(netif)) && (!ip_addr_isany(&(netif->ip_addr)))) {
/* IP数据包目的IP和该网络接口IP相同，或该IP数据包为广播包 */
if (ip_addr_cmp(&(iphdr->dest), &(netif->ip_addr)) || ip_addr_isbroadcast(&(iphdr->dest), netif)) {
/* 退出循环 */
break;
}
}
/* 如果不是接收到数据包的网络接口，就挨个遍历链表 */
if (first) {
first = 0;
netif = netif_list;
} else {
netif = netif->next;
}
if (netif == inp) {
netif = netif->next;
}
} while(netif != NULL);
}
/* 如果该数据包源IP地址是广播地址或组播地址 */
if ((ip_addr_isbroadcast(&(iphdr->src), inp)) || (ip_addr_ismulticast(&(iphdr->src)))) {
/* 释放数据包，不做任何处理 */
pbuf_free(p);
return ERR_OK;
}
/* 数据包不是发送给自己 */
if (netif == NULL) {
/* 释放数据包，不做任何处理 */
pbuf_free(p);
return ERR_OK;
}
/* 数据包是发送给自己的 */
/* 片偏移量不为0或不是最后一个分片(即该数据包分片发送) */
if ((IPH_OFFSET(iphdr) & htons(IP_OFFMASK | IP_MF)) != 0) {
/* IP数据包重组 */
p = ip_reass(p);
if (p == NULL) {
return ERR_OK;
}
iphdr = p->payload;
}
/* 记录当前接收数据包的网络接口指针 */
current_netif = inp;
/* 记录当前接收数据包的IP头部指针 */
current_header = iphdr;
/* 为用户预留的原始IP数据包输入处理接口 */
if (raw_input(p, inp) == 0)
{
/* 判断协议类型 */
switch (IPH_PROTO(iphdr)) {
/* UDP协议 */
case IP_PROTO_UDP:
/* UDP数据包输入处理 */
udp_input(p, inp);
break;
/* TCP协议 */
case IP_PROTO_TCP:
/* TCP数据包输入处理 */
tcp_input(p, inp);
break;
/* ICMP协议 */
case IP_PROTO_ICMP:
/* ICMP数据包输入处理 */
icmp_input(p, inp);
break;
/* 不支持的协议 */
default:
/* 目的IP不是广播地址且不是组播地址 */
if (!ip_addr_isbroadcast(&(iphdr->dest), inp) && !ip_addr_ismulticast(&(iphdr->dest))) {
p->payload = iphdr;
/* 发送ICMP目的不可达报文 */
icmp_dest_unreach(p, ICMP_DUR_PROTO);
}
/* 释放数据包 */
pbuf_free(p);
}
}
/* 数据包处理完成，清空当前接收数据包的网络接口指针 */
current_netif = NULL;
/* 数据包处理完成，清空当前接收数据包的IP头部指针 */
current_header = NULL;
return ERR_OK;
}其中，ip_reass函数用于重组IP分片，先看一个重装结构体
/* 重组IP数据报结构体 */
struct ip_reassdata {
struct ip_reassdata *next; //用于将重组IP数据报结构体连接成链表
struct pbuf *p; //该IP数据报的所有数据
struct ip_hdr iphdr; //该数据报的IP头部
u16_t datagram_len; //该数据报的数据总长度
u8_t flags; //是否收到最后一个分片
u8_t timer; //重装数据报剩余生存时间
};
/* 重组IP数据报链表 */
static struct ip_reassdata *reassdatagrams;最终，所有的重装结构体，会通过next字段连接成一个链表，如下图所示
上图中，每一个pbuf链都表示一个IP分片。LwIP把分片IP首部的前八个字节重新组织起来，替换成分片的相关信息。最终，如上图所示，通过next_pbuf字段将所有的分片按照片偏移从小到大的顺序连接起来。
/* IP分片结构体 */
struct ip_reass_helper {
PACK_STRUCT_FIELD(struct pbuf *next_pbuf); //用于将IP分片连接成链表(重组IP数据报)
PACK_STRUCT_FIELD(u16_t start); //分片中数据的起始位置
PACK_STRUCT_FIELD(u16_t end); //分片中数据的结束位置
} PACK_STRUCT_STRUCT;/* IP数据报重组 */
struct pbuf *ip_reass(struct pbuf *p)
{
struct pbuf *r;
struct ip_hdr *fraghdr;
struct ip_reassdata *ipr;
struct ip_reass_helper *iprh;
u16_t offset, len;
u8_t clen;
struct ip_reassdata *ipr_prev = NULL;
/* 分片数据报IP头部 */
fraghdr = (struct ip_hdr*)p->payload;
/* 对IP头部长度进行检验，不支持选项字段 */
if ((IPH_HL(fraghdr) * 4) != IP_HLEN) {
goto nullreturn;
}
/* 计算片偏移(字节为单位) */
offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;
/* 计算分片中的数据长度 */
len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;
/* 分片中的pbuf个数 */
clen = pbuf_clen(p);
/* 所有IP分片pbuf总个数超过上限 */
if ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) {
goto nullreturn;
}
/* 遍历所有重组IP数据报链表 */
for (ipr = reassdatagrams; ipr != NULL; ipr = ipr->next) {
/* 检查该分片是否属于该重组IP数据报(源地址+目的地址+数据报标识(编号)) */
if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) {
break;
}
ipr_prev = ipr;
}
/* 没有匹配到重组IP数据报，说明是一个新的重组IP数据报 */
if (ipr == NULL) {
/* 新建一个重组IP数据报，并插入链表 */
ipr = ip_reass_enqueue_new_datagram(fraghdr, clen);
if(ipr == NULL) {
goto nullreturn;
}
}
/* 匹配到重组IP数据报 */
else {
/* 收到第一个分片 */
if (((ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && ((ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) {
/* 设置重组IP数据报的IP头部 */
SMEMCPY(&ipr->iphdr, fraghdr, IP_HLEN);
}
}
/* 更新所有IP分片重组pbuf总个数 */
ip_reass_pbufcount += clen;
/* 收到最后一个分片 */
if ((ntohs(IPH_OFFSET(fraghdr)) & IP_MF) == 0) {
/* 设置重组IP数据的标志位为已收到最后一个分片 */
ipr->flags |= IP_REASS_FLAG_LASTFRAG;
/* 设置重组IP数据的数据总长度 */
ipr->datagram_len = offset + len;
}
/* 将IP分片插入合适的重组IP数据报，判断所有分片都已经收到 */
if (ip_reass_chain_frag_into_datagram_and_validate(ipr, p)) {
/* 分片接收完成，数据总长度更新为IP首部长度+数据长度 */
ipr->datagram_len += IP_HLEN;
/* 第二个分片指针 */
r = ((struct ip_reass_helper *)ipr->p->payload)->next_pbuf;
/* 将第一个IP分片结构还原成IP首部结构体 */
fraghdr = (struct ip_hdr *)(ipr->p->payload);
SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN);
IPH_LEN_SET(fraghdr, htons(ipr->datagram_len));
IPH_OFFSET_SET(fraghdr, 0);
IPH_CHKSUM_SET(fraghdr, 0);
IPH_CHKSUM_SET(fraghdr, inet_chksum(fraghdr, IP_HLEN));
/* 遍历所有IP分片 */
p = ipr->p;
while(r != NULL) {
iprh = (struct ip_reass_helper*)r->payload;
/* 向后剥掉各个分片的IP头部 */
pbuf_header(r, -IP_HLEN);
/* 将各个分片拼接起来 */
pbuf_cat(p, r);
r = iprh->next_pbuf;
}
/* 将该IP重组数据报从链表中移除 */
ip_reass_dequeue_datagram(ipr, ipr_prev);
/* 更新IP分片重组pbuf总个数 */
ip_reass_pbufcount -= pbuf_clen(p);
/* 返回重组后的IP数据报pbuf链表 */
return p;
}
return NULL;
nullreturn:
/* 释放该分片空间 */
pbuf_free(p);
return NULL;
}
/* 新建一个重组IP数据报，并插入链表 */
static struct ip_reassdata *ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen)
{
struct ip_reassdata* ipr;
/* 为重组IP数据报结构体分配空间 */
ipr = memp_malloc(MEMP_REASSDATA);
/* 分配失败 */
if (ipr == NULL) {
return NULL;
}
/* 清空重组IP数据报结构体 */
memset(ipr, 0, sizeof(struct ip_reassdata));
/* 重组IP数据报最大生存时间 */
ipr->timer = IP_REASS_MAXAGE;
/* 将重组IP数据报结构体插入链表 */
ipr->next = reassdatagrams;
reassdatagrams = ipr;
/* 设置重组IP数据报的IP头部数据 */
SMEMCPY(&(ipr->iphdr), fraghdr, IP_HLEN);
return ipr;
}
/* 将IP重组数据报从链表中移除 */
static void ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)
{
if (reassdatagrams == ipr) {
reassdatagrams = ipr->next;
} else {
prev->next = ipr->next;
}
/* 释放该重IP数据报结构体 */
memp_free(MEMP_REASSDATA, ipr);
}
/* 将IP分片插入合适的重组IP数据报，并判断是否所有分片都已经收到 */
static int ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p)
{
struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev=NULL;
struct pbuf *q;
u16_t offset, len;
struct ip_hdr *fraghdr;
int valid = 1;
/* IP分片的IP头部指针 */
fraghdr = (struct ip_hdr*)new_p->payload;
/* IP分片的数据长度 */
len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;
/* IP分片的片偏移(字节为单位) */
offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;
/* IP分片结构体指针 */
iprh = (struct ip_reass_helper *)new_p->payload;
/* 下一个分片指针 */
iprh->next_pbuf = NULL;
/* 分片中数据的起始位置和结束位置 */
iprh->start = offset;
iprh->end = offset + len;
/* 按照片偏移从小到大将IP分片插入重组IP数据报 */
for (q = ipr->p; q != NULL;) {
iprh_tmp = (struct ip_reass_helper *)q->payload;
/* iprh片偏移小于iprh_tmp */
if (iprh->start < iprh_tmp->start) {
/* 将iprh插到iprh_tmp前面 */
iprh->next_pbuf = q;
/* iprh不是片偏移最小的分片 */
if (iprh_prev != NULL) {
/* 将iprh插到iprh_prev后面 */
iprh_prev->next_pbuf = new_p;
}
/* iprh是片偏移最小的分片 */
else {
/* 将iprh插到头部 */
ipr->p = new_p;
}
break;
}
/* 收到重复分片，不做处理，直接删除 */
else if(iprh->start == iprh_tmp->start) {
goto freepbuf;
}
/* iprh片偏移大于iprh_tmp */
else {
/* iprh_prev不是片偏移最小的分片 */
if (iprh_prev != NULL) {
/* iprh_prev和iprh_tmp不连续 */
if (iprh_prev->end != iprh_tmp->start) {
valid = 0; //分片不连续，还有分片没有收到
}
}
}
q = iprh_tmp->next_pbuf;
iprh_prev = iprh_tmp;
}
/* 链表为空或者已经遍历到链表尾部 */
if (q == NULL) {
/* 已经遍历到链表尾部 */
if (iprh_prev != NULL) {
/* 将分片插到链表尾部 */
iprh_prev->next_pbuf = new_p;
/* 分片不连续，还有分片没有收到 */
if (iprh_prev->end != iprh->start) {
valid = 0;
}
}
/* 链表为空 */
else {
/* 将分片插入链表首部 */
ipr->p = new_p;
}
}
/* 已经收到最后一个分片 */
if ((ipr->flags & IP_REASS_FLAG_LASTFRAG) != 0) {
/* 暂未发现还有分片没收到，进一步判断 */
if (valid) {
/* 第一个分片没有收到 */
if (((struct ip_reass_helper *)ipr->p->payload)->start != 0) {
valid = 0; //第一个分片没有收到
}
/* 已经收到第一个分片 */
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; /* 分片不连续，还有分片没有收到 */
break;
}
iprh_prev = iprh;
q = iprh->next_pbuf;
}
}
}
/* 返回重组IP是否已经收到所有分片 */
return valid;
}
/* 还有分片没有收到 */
return 0;
}
如果传输的过程中有IP分片丢失，协议栈是不可能无限期等待重组完成的。LwIP的做法是等待1秒钟，如果还没有重组完成，则删除该重组IP数据报。
/* 重组IP数据报定时器回调函数(周期1秒) */
void ip_reass_tmr(void)
{
struct ip_reassdata *r, *prev = NULL;
/* 遍历所有重组IP数据报 */
r = reassdatagrams;
while (r != NULL) {
/* 没有超时，将生存周期减一 */
if (r->timer > 0) {
r->timer--;
prev = r;
r = r->next;
}
/* 超时 */
else {
struct ip_reassdata *tmp;
tmp = r;
r = r->next;
/* 释放重组IP数据报的所有分片，并将重组IP数据报从链表中移除 */
ip_reass_free_complete_datagram(tmp, prev);
}
}
}
/* 释放重组IP数据报的所有分片，并将重组IP数据报从链表中移除 */
static int ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)
{
int pbufs_freed = 0;
struct pbuf *p;
struct ip_reass_helper *iprh;
/* 第一个分片pbuf链表 */
p = ipr->p;
/* 遍历该IP重组数据报中的所有分片 */
while (p != NULL) {
struct pbuf *pcur;
iprh = (struct ip_reass_helper *)p->payload;
pcur = p;
p = iprh->next_pbuf;
/* 统计该IP重组数据报中pbuf个数 */
pbufs_freed += pbuf_clen(pcur);
/* 释放该分片pbuf链表 */
pbuf_free(pcur);
}
/* 将IP重组数据报从链表中移除 */
ip_reass_dequeue_datagram(ipr, prev);
/* 更新所有IP分片重组pbuf总个数 */
ip_reass_pbufcount -= pbufs_freed;
/* 返回释放的pbuf个数 */
return pbufs_freed;
}