正点原子lwIP学习笔记——IP协议

已于 2023-09-18 22:10:08 修改
阅读量295 收藏
点赞数
分类专栏： lwIP学习 文章标签： 学习 笔记 tcp/ip stm32 网络协议
于 2023-09-18 18:06:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhj12138/article/details/132974032
版权

1.IP协议简介

IP协议是TCP/IP协议族中最为核心的协议，TCP、UDP、ICMP、IGMP数据都以IP数据报格式传输（IPv4、IPv6）。

IP协议指网际互联协议，Internet Protocol，为上层提供了无连接、不可靠的服务；
无连接：IP通讯双方都不长久的维持对方的任何信息；这表明每次上层协议发送数据都需要指定IP地址。
不可靠：IP协议不能把IP数据报准确到达接收端，只能尽力；一旦发送失败，就会通知上层协议，但是不会重发。

IP协议的作用

IP协议作用

IP寻址：在主机A和主机B不处于同一网段时，就会由主机A发送数据到网关，也就是路由器中，路由器经过解封装，获得目标的IP地址的网络号（IP地址分为网络号和主机号），进行发送；

路由表，也及时路由选择，包含三个信息：目标网络，下一跳地址以及子网掩码；通过路由表来把数据发送到相应的路由器中；

分片和重组就是本节课的重点，大于MTU就会需要这两个操作来获取完整数据（MTU也就是1500字节）。

IP协议会与以下三个协议配套使用：ARP、ICMP以及IGMP协议（正点原子的课程中没有涉及）

MAC地址与IP地址区别

MAC与IP的区别
物理地址，也就是MAC地址，是数据链路层和物理层使用的地址；而IP地址是网络层及以上层使用的地址。

数据传输举例

  1. 数据传输过程中，源IP地址和目标IP地址不变；
  2. 路由器根据目标IP地址的网络号进行路由。

IP地址由网络号和主机号构成，根据位的不同，可分为ABCDE五类地址。

总结：

  • MAC地址用来数据转发，IP地址用来确认路标；
  • MAC的作用是实现两个直联设备的通讯，而IP则是负责在两个没有直联设备的两个网络之间进行通讯。

2.IP协议原理

IP分片原理

抓取IP协议内容

IP协议抓包示例
可以看出，这里是采用IPv4；IP协议的首部一共有20字节；第三个是差分服务区域；然后总长度是52字节；标识位；标志位；偏移量（一般为8的倍数）；生存时间；上层协议，是TCP；校验和；源和目标的IP地址。

IP协议字段解析

IP字段解析
IP数据的示意图

IP协议处理分片

MTU

  • 最大传输单元，默认1500字节；
  • 一个数据包从网卡发出时，最大的total length的长度；
  • 如果大于1500字节，就会分片。

identification、flags、fragment offset作用

  • identification：
    标识一个分片（例如经过分片，4000字节的数据就要分为1500、1500、1060三片，分片后的数据包identification字段是一样的）；之所以是1060，是因为每一片最多1500字节的信息，还需要包含IP的结构体大小20字节，也就是说每一片最多带传输数据1480字节；

  • flags：
    标志位flags
    FM位会用到，描述最后一个分片（最后一个就是0，否则为1）。

  • fragment offset：

偏移量，计算的是payload部分；
payload就是去掉二层头部和三层头部后的内容；
1500字节的分片，就是IP+payload的大小；
加上E2，整个数据包抓包看到的大小是1514字节。

分片示例
数据大小为3980，所有的标识是一样的，代表是同一个数据，经过分片；然后标志位前两个都是1，代表不是最后一个分片，直到最后一个分片变成0；偏移量每一个都不一样；总长度最后一片就是3980-1480-1480+20的结果。

payload指针指向示例

分片原理

申请pbuf

pbuf申请
这个就是之前课程有讲的pbuf的内存申请出来的格式，其中tot_len就可以直接置3960，payload指向pbuf结构体结束之后的地址再向后偏移54个字节处；

递交给传输层

添加TCP头部
payload指针向上偏移20个字节（这一过程调用pbuf_add_header(p, TCP_HLEN)），该段留作TCP的首部；tot_len变为3960+20；

递交给网络层

添加IP头部
payload继续上移20字节（这一过程调用pbuf_add_header(p, IP_HLEN)），留作IP头部；tot_len变为3960+20+20；

分片

分片示意图
因为数据的大小3960>MTU，所以需要进行分片；

源码和对应的注释如下：

err_t
ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest)
{
  struct pbuf *rambuf;
#if !LWIP_NETIF_TX_SINGLE_PBUF
  struct pbuf *newpbuf;
  u16_t newpbuflen = 0;
  u16_t left_to_copy;
#endif
  struct ip_hdr *original_iphdr;
  struct ip_hdr *iphdr;
  /* 第一步：nfb = (1500 - 20)/8 = 185 */
  const u16_t nfb = (u16_t)((netif->mtu - IP_HLEN) / 8);
  u16_t left, fragsize;
  u16_t ofo;
  int last;
  /* poff = 20 */
  u16_t poff = IP_HLEN;
  u16_t tmp;
  int mf_set;

  /* 第二步：获取IP首部信息 */
  original_iphdr = (struct ip_hdr *)p->payload;
  iphdr = original_iphdr;
  /* 第三步：判断首部获取成功 */
  if (IPH_HL_BYTES(iphdr) != IP_HLEN) {
    /* ip4_frag() does not support IP options */
    return ERR_VAL;
  }

  /* 第四步：tmp = 保存偏移量的字段数值	= 0 */
  tmp = lwip_ntohs(IPH_OFFSET(iphdr));
  /* 第五步：ofo = 0 & 0x1fffU = 0 */
  ofo = tmp & IP_OFFMASK;
  /* 第六步：mf_set = 0 & 0x2000U = 0 */ */
  mf_set = tmp & IP_MF;
  /* 第七步：left = p->tot_len - 20  
     1：4000 - 20 = 3980 */
  left = (u16_t)(p->tot_len - IP_HLEN);

  /* 第八步：left > 0 ? */
  while (left) {
    /* 第九步：分片大小fragsize = left < (nfb * 8) ? left : (nfb * 8) 
       1：3980 < 1480 ?  3980 : 1480  fragsize = 1480
       2：2500 < 1480 ？ 2500 ：1480  fragsize = 1480
       3：1020 < 1480 ？ 1020 ：1480  fragsize = 1020	   */
    fragsize = LWIP_MIN(left, (u16_t)(nfb * 8));

    /* 第十步：申请pbuf内存---用来描述分片 */
    rambuf = pbuf_alloc(PBUF_LINK, IP_HLEN, PBUF_RAM);
    if (rambuf == NULL) {
      goto memerr;
    }

	/* 第十一步：把IP首部复制到rambuf当中 */
    SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN);
	/* iphdr指向rambuf->payload */
    iphdr = (struct ip_hdr *)rambuf->payload;
	/* left_to_copy = 分片大小fragsize
       1：left_to_copy = 1480
       2：left_to_copy = 1480
       3：left_to_copy = 1020	   */
    left_to_copy = fragsize;
	
    while (left_to_copy) {
      struct pbuf_custom_ref *pcr;
	  /* plen = p->len - poff
         1：4000 - 20 = 3980	plen = 3980
         2：4000 - 1500	= 2500  plen = 2500
         3：4000 - 2980	= 1020  plen = 1020		 */
      u16_t plen = (u16_t)(p->len - poff);
		
	  /* 新的pbuf大小 newpbuflen =  left_to_copy < plen ?  left_to_copy : plen 
	  1：newpbuflen = 1480
      2：newpbuflen = 1480
      3：newpbuflen = 1020	  */
      newpbuflen = LWIP_MIN(left_to_copy, plen);
      /* 是否为空 */
      if (!newpbuflen) {
        poff = 0;
        p = p->next;
        continue;
      }
	  
	  /* 申请一个新的结构pbuf_custom_ref */
      pcr = ip_frag_alloc_pbuf_custom_ref();
      if (pcr == NULL) {
        pbuf_free(rambuf);
        goto memerr;
      }
	  
      /* 镜像pbuf（p），尽管我们可能不需要它的全部。 */
      newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc,
                                    (u8_t *)p->payload + poff, newpbuflen);
      if (newpbuf == NULL) {
        ip_frag_free_pbuf_custom_ref(pcr);
        pbuf_free(rambuf);
        goto memerr;
      }
      pbuf_ref(p);
      pcr->original = p;
      pcr->pc.custom_free_function = ipfrag_free_pbuf_custom;

      /* rambuf与newpbuf链接 */
      pbuf_cat(rambuf, newpbuf);
	  /* 1：left_to_copy = 1480 - 1480 = 0
         2：left_to_copy = 1480 - 1480 = 0
         3：left_to_copy = 1020 - 1020 = 0		 */
      left_to_copy = (u16_t)(left_to_copy - newpbuflen);
	  
      if (left_to_copy) {
        poff = 0;
        p = p->next;
      }
    }
	/* 1：poff = 20 + 1480 = 1500
	   2：poff = 1500 + 1480 = 2980
       3：poff = 2980 + 1020 = 4000	   */
    poff = (u16_t)(poff + newpbuflen);

    /* 1：last = （3980 <= 1500 - 20 ） = 0
	   2：last = （2500 <= 1500 - 20 ） = 0
       3：last = （1020 <= 1500 - 20 ） = 1	   */
    last = (left <= netif->mtu - IP_HLEN);

    /* 设置新的偏移量和MF标志 */
    tmp = (IP_OFFMASK & (ofo));
    if (!last || mf_set) {
      /* 最后一个片段有MF设置 */
      tmp = tmp | IP_MF;
    }
	/* 设置该分片的IP首部信息 */
    IPH_OFFSET_SET(iphdr, lwip_htons(tmp));
    IPH_LEN_SET(iphdr, lwip_htons((u16_t)(fragsize + IP_HLEN)));
    IPH_CHKSUM_SET(iphdr, 0);

    /* 发送该分片IP数据包 */
    netif->output(netif, rambuf, dest);
    IPFRAG_STATS_INC(ip_frag.xmit);

    /* 释放内存 */
    pbuf_free(rambuf);
	/* 1：left = 3980 - 1480 = 2500
       2：left = 2500 - 1480 = 1020
       3：left = 1020 - 1020 = 0	   */
    left = (u16_t)(left - fragsize);
	/* 1：ofo = 0 + 185 = 185
       2：ofo = 185 + 185 = 370
       3：ofo = 370 + 185 = 555	   */
    ofo = (u16_t)(ofo + nfb);
  }
  MIB2_STATS_INC(mib2.ipfragoks);
  return ERR_OK;
memerr:
  MIB2_STATS_INC(mib2.ipfragfails);
  return ERR_MEM;
}

其中，有关于nbf，也就是IP首部的片偏移，是以8个字节为单位进行统计的；

最终三个切片如下图所示：
三个切片示意图

IP重组原理

IP数据包重组

由于IP分组在网络中的传输到达目的地点的时间是不确定的，所以后面的分组可能比前面的分组先到达目的地。
IP分片后示例
IP分片关键信息

lwIP处理分片原理

  • 将接收到的分片暂存；
  • 对所有分片进行排序；
  • 所有分片接收完成，再将数据递交给传输层处理。
    IP重组的关键结构体
    每一个ip_reassdata结构体，代表了一个正在重装的IP数据报文；接收到分组时，会将分组的pbuf连接到对应ip_reassdata里的pbuf链中；IP数据报文接受完整才递交上层。

分片后单向链表示意图
这是接收一个IP数据包的示例，如果没接收全，会把IP首部以8字节为代价强制转换为如下3个字段，其中next_pbuf会互相进行链接；其中如果三个分片都接收到了，就会释放掉ip_reassdata这个结构体数据；然后IP首部就会重新重装，并且pbuf的payload会指向每一个分片的IP包；pbuf的next就会相互链接起来。

其中，8字节为代价的强制转换的结构体如下所示：
IP首部的强制转换
以上结构体，就使得IP包没接收完整时，可以把多个IP分片以链表形式链接。

lwIP处理分片

ip4_reass()

struct pbuf *
ip4_reass(struct pbuf *p)
{
  struct pbuf *r;
  struct ip_hdr *fraghdr;
  struct ip_reassdata *ipr;
  struct ip_reass_helper *iprh;
  u16_t offset, len, clen;
  u8_t hlen;
  int valid;
  int is_last;

  IPFRAG_STATS_INC(ip_frag.recv);
  MIB2_STATS_INC(mib2.ipreasmreqds);
  /**************************计算分片参数******************************/
  /* 获取该分片的IP首部 */
  fraghdr = (struct ip_hdr *)p->payload;

  if (IPH_HL_BYTES(fraghdr) != IP_HLEN) {
    LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: IP options currently not supported!\n"));
    IPFRAG_STATS_INC(ip_frag.err);
    goto nullreturn;
  }

  /* offset = 该分片的偏移量
     1：0
     2：185
     3：370 */
  offset = IPH_OFFSET_BYTES(fraghdr);
  /* len = 该分片的总长度
     1：1500
     2：1500
     3：1040 */
  len = lwip_ntohs(IPH_LEN(fraghdr));
  /* hlen = 首部长度 = 20 */
  hlen = IPH_HL_BYTES(fraghdr);
  if (hlen > len) {
    goto nullreturn;
  }
  
  /* len = 数据长度
     1：len = 1500 - 20 = 1480
     2：len = 1500 - 20 = 1480
     3：len = 1040 - 20 = 1020 */
  len = (u16_t)(len - hlen);

  /* clen = 1 (获取输入分组的 pbuf 数量) */
  clen = pbuf_clen(p);
  
  /* 若将输入报文的 pbuf 加上 reassdatagrams 链表所有的 pbuf 的数量超出限制 */
  if ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) {
#if IP_REASS_FREE_OLDEST
    if (!ip_reass_remove_oldest_datagram(fraghdr, clen) ||
        ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS))
#endif /* IP_REASS_FREE_OLDEST */
    {
      /* 省略..... */
      goto nullreturn;
    }
  }

  /* 遍历分组重装链表，找到该分组对应的 reassdatagrams */
  for (ipr = reassdatagrams; ipr != NULL; ipr = ipr->next) {
	/* IP数据报首部是否一致 */
    if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) {
      /* 省略代码 */
      break;
    }
  }
  
  /* 未找到其对应的重装链表，新建一个重装链表 */
  if (ipr == NULL) {
    ipr = ip_reass_enqueue_new_datagram(fraghdr, clen);
    if (ipr == NULL) {
      goto nullreturn;
    }
  } else {/* 找到对应的重装链表，若输入分组的片偏移为 0，则是数据报的第一个分组 */
    if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) &&
        ((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) {
      /* 复制输入分组的 ip 首部到 ipr 的 iphdr 成员，由它的首部作为完整数据报的 ip 首部 */
      SMEMCPY(&ipr->iphdr, fraghdr, IP_HLEN);
    }
  }

  /* 是否是最后一个分组.MF = 0 */
  is_last = (IPH_OFFSET(fraghdr) & PP_NTOHS(IP_MF)) == 0;
  if (is_last) {
	/* 计算数据报长度 */
    u16_t datagram_len = (u16_t)(offset + len);
	/* 超过 65535 字节了， IP 报不能这么长 */
    if ((datagram_len < offset) || (datagram_len > (0xFFFF - IP_HLEN))) {
      goto nullreturn_ipr;
    }
  }
  
  /**************************把分片插入重装链表******************************/
  /* 将分片插入对应重装链表 */
  valid = ip_reass_chain_frag_into_datagram_and_validate(ipr, p, is_last);
  /* 注意：如果valid = IP_REASS_VALIDATE_PBUF_DROPPED表示还没有收到所有的碎片! */
  if (valid == IP_REASS_VALIDATE_PBUF_DROPPED) {
    goto nullreturn_ipr;
  }
  
  
  /**************************重装完成执行的代码******************************/
  
  /* 到此，分片的插入完成,统计一下有多少个PBUF */
  ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount + clen);
  
  /* 最后一片 */
  if (is_last) {
	/* 计算数据报长度 */
    u16_t datagram_len = (u16_t)(offset + len);
	/* 总长度保存在结构体 */
    ipr->datagram_len = datagram_len;
	/* 设置数据报标志 */
    ipr->flags |= IP_REASS_FLAG_LASTFRAG;
  }
  
  
  
  /* 若所有数据报已完成重装，构建一个存放完整ip数据报的pbuf链（填充首部，连接 pbuf），
    并将ipr从reassdatagrams链表删除 */
  if (valid == IP_REASS_VALIDATE_TELEGRAM_FINISHED) {
    struct ip_reassdata *ipr_prev;
    /* 设置数据报总长度：数据长度+首部长度20字节 */
    u16_t datagram_len = (u16_t)(ipr->datagram_len + IP_HLEN);

    /* 指向第二个pbuf（后面有用） */
    r = ((struct ip_reass_helper *)ipr->p->payload)->next_pbuf;

    /* fraghdr现在是第一个pbuf的 payload，指向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);
	/* 保存第一个头 PBUF */
    p = ipr->p;

    /* 将同一重装数据链表中分片的pbuf链接在一起 */
    while (r != NULL) {
	  /* iprh->next_pbuf指向下一个分片 */
      iprh = (struct ip_reass_helper *)r->payload;

      /* 将下一个分片第一个 pbuf 的 payload 后移，指向数据区，隐藏掉 ip 首部
         （我们只需要一个 ip 首部） */
      pbuf_remove_header(r, IP_HLEN);
	  /* 将分片的 pbuf 链连接到 p 上 */
      pbuf_cat(p, r);
	  /* 获取下一个分片的 pbuf 链 */
      r = iprh->next_pbuf;
    }

    /* 如果 ipr 是第一个，则前面 ipr_prev 为空，因为前面没有了 */
    if (ipr == reassdatagrams) {
      ipr_prev = NULL;
    } else {/* 如果不是，找到 ipr_prev 的下一个是 ipr ，用于后面的释放 */
      for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) {
        if (ipr_prev->next == ipr) {
          break;
        }
      }
    }

    /* 释放ipr */
    ip_reass_dequeue_datagram(ipr, ipr_prev);

    /* 因为已经完成，算一下这个 P 有多少个 PBUF */
    clen = pbuf_clen(p);
    /* 因为完整了，要传到上层，因此要减去 */
    ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - clen);

    MIB2_STATS_INC(mib2.ipreasmoks);

    /* Return the pbuf chain */
    return p;
  }
  /* the datagram is not (yet?) reassembled completely */
  LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_pbufcount: %d out\n", ip_reass_pbufcount));
  return NULL;

nullreturn_ipr:
  LWIP_ASSERT("ipr != NULL", ipr != NULL);
  if (ipr->p == NULL) {
    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);
  return NULL;
}

ip_reass_chain_frag_into_datagram_and_validate()函数-----把分片插入ip_reassdata重装链表

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首部 */
  fraghdr = (struct ip_hdr *)new_p->payload;
  /* len = 该分片的总长度
     1：1500
     2：1500
     3：1040 */
  len = lwip_ntohs(IPH_LEN(fraghdr));
  /* 获取该分片的首部长度（20） */
  hlen = IPH_HL_BYTES(fraghdr);
  /* 首部长度大于分片总长度？ */
  if (hlen > len) {
    return IP_REASS_VALIDATE_PBUF_DROPPED;
  }
  
  /* len：数据大小
     1：1500 - 20 = 1480
     2：1500 - 20 = 1480
     3：1040 - 20 = 1020 */
  len = (u16_t)(len - hlen);
  /* offset = 该分片的偏移量
     1：0
     2：185
     3：370 */
  offset = IPH_OFFSET_BYTES(fraghdr);

  /* 在new_p->payload指向的地址附加一个ip_reass_helper结构体 */
  iprh = (struct ip_reass_helper *)new_p->payload;
  
  iprh->next_pbuf = NULL;
  /* offset = 该分片的偏移量
     1：0
     2：185
     3：370 */
  iprh->start = offset;
  /* offset = 该分片的偏移量
     1：0 + 1480 = 1048
     2：185 + 1480 = 1665
     3：370 + 1020 = 1396 */
  iprh->end = (u16_t)(offset + len);
  
  /* 这个数据报无效 */
  if (iprh->end < offset) {
    return IP_REASS_VALIDATE_PBUF_DROPPED;
  }

  /* 遍历分组重装链表 */
  for (q = ipr->p; q != NULL;) {
	/* 指向第一个分片的ip_reass_helper，重要！用于确定分组插入位置 */
    iprh_tmp = (struct ip_reass_helper *)q->payload;
	/* 确认插入的数据报和重装链表的第一个分片顺序 */
    if (iprh->start < iprh_tmp->start) {
      /* 如果插入分片的数据起始序号小于重装链表的第一个分片的数据起始序号
         插入分片的指针指向这个分片 */
      iprh->next_pbuf = q;
      if (iprh_prev != NULL) {
        /* not the fragment with the lowest offset */
#if IP_REASS_CHECK_OVERLAP
        if ((iprh->start < iprh_prev->end) || (iprh->end > iprh_tmp->start)) {
          return IP_REASS_VALIDATE_PBUF_DROPPED;
        }
#endif
        iprh_prev->next_pbuf = new_p;
        if (iprh_prev->end != iprh->start) {
          valid = 0;
        }
      } else {
#if IP_REASS_CHECK_OVERLAP
        if (iprh->end > iprh_tmp->start) {
          return IP_REASS_VALIDATE_PBUF_DROPPED;
        }
#endif
        /* 插入的分片与重装链表的第一个分片调换位置 */
        ipr->p = new_p;
      }
      break;
    } else if (iprh->start == iprh_tmp->start) {/* 接收到重复的分组 */
      /* 掉弃该分组 */
      return IP_REASS_VALIDATE_PBUF_DROPPED;
#if IP_REASS_CHECK_OVERLAP
    } else if (iprh->start < iprh_tmp->end) {/* 分片的内容与 iprh_temp 的内容重叠 */
	  /* 掉弃该分组 */
      return IP_REASS_VALIDATE_PBUF_DROPPED;
#endif /* IP_REASS_CHECK_OVERLAP */
    } else {
	  /* 检查数据报是否连续 */
      if (iprh_prev != NULL) {
        if (iprh_prev->end != iprh_tmp->start) {
          /* 不连续 */
          valid = 0;
        }
      }
    }
	/* q = NULL */
    q = iprh_tmp->next_pbuf;
	/* iprh_prev指向第一个分片 */
    iprh_prev = iprh_tmp;
  }

  /* 若 q 为 null，输入分组序号最高 则说明分组应该在链表的最末 */
  if (q == NULL) {
	
    if (iprh_prev != NULL) {
	  /* 第一个分片的next_pbuf指针指向插入的分片 */
      iprh_prev->next_pbuf = new_p;
	  /* 判断是否连续 */
      if (iprh_prev->end != iprh->start) {
        valid = 0;
      }
    } else {
      /* 到这里只能是链表为 null */
      ipr->p = new_p;
    }
  }

  /* 最后一个分片处理的代码段 */
  if (is_last || ((ipr->flags & IP_REASS_FLAG_LASTFRAG) != 0)) {
    /* 输入分片与它前面的分片的数据连续无断点 */
    if (valid) {
      /* 检查数据报首部是否为 null 或者偏移是不是 0 */
      if ((ipr->p == NULL) || (((struct ip_reass_helper *)ipr->p->payload)->start != 0)) {
		/* 以上情况说不对 */
        valid = 0;
      } else {
        /* 检查输入分组之后的分组是否也是连续的 */
        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;
        }

        if (valid) {
          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);
        }
      }
    }
    /* 返回 1 说明数据报重装完成 */
    return valid ? IP_REASS_VALIDATE_TELEGRAM_FINISHED : IP_REASS_VALIDATE_PBUF_QUEUED;
  }
  /* 如果我们来到这里，还没有收到所有的碎片! */
  return IP_REASS_VALIDATE_PBUF_QUEUED;
}

IP重装示意图1
IP重装示意图2
以上的源码就是实现了如图所示的整个重装过程。

总结

这一章内容比较多，总体就对着源码，能够看懂这几个示意图就可以了，源码比较多，大概看一看就好，理清整个传输逻辑比较重要！
这里所有的IP包数据都代表着TCP首部+实际传输数据。

已学完的lwIP协议总结
以上就是当前已经学习过的lwIP相关的协议框架，包括了网卡驱动、IP协议以及ARP协议，以太网DMA以及MAC内核的内容。

努力自学的小夏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lwIP TCP/IP 协议栈笔记之十七： NETCONN 接口编程IPV6
Xanthium
09-18 3795
目录 1. 初识IPv6 2. IPv6地址格式 3. LwIP TCP client 示例 1. 初识IPv6 LwIP IPv6 本不在本次计划中，正好遇到，特此简单记录一下。下图为PC端 IP信息，可以看到IPv6和IPv4地址都在用，随着IPv4资源的日益匮乏，IPv6的逐步在替代使用中，2017年 国务院办公厅印发《推进互联网协议第六版（IPv6）规模部署行动计划》。 ...
正点原子阿波罗F429+STM32CubeMX+LAN8720+LWIP+Freetos:带操作系统实现网络热插拔
12-31
正点原子阿波罗F429+STM32CubeMX+LAN8720+LWIP+Freetos:带操作系统实现网络热插拔。
lwip学习资料及部分源码 - 正点原子
05-15
lwip学习资料及部分源码 - 正点原子
lwip开源协议栈移植学习笔记
01-06
lwip开源协议栈移植之旅开始了，哈哈 很有挑战哦！！ lwip有无操作系统支持都可以使用，不依赖于操作系统。 带操作系统移植需要实现操作系统模拟层实现文件，LwIP 的作者为操作系统模拟层提供了较为详细描述在doc夹下文件名为 sys_arch.txt。我们的编写工作根据这个说明进行。 1、支持的操作系统需要添加的头文件说明： 文件 描述 cc.h 与硬件平台及编译器相关的环境变量及数据类型声明文件 perf.h centered 定义了性能测量使用的宏，由 LwIP 调用，可以将其定义为一个空的宏。 sys_arch.h sys_arch.c 的头文件,定义 Arc
LwIP编程指南LwIP协议详解lwip学习笔记IP+LWIP移植实现等相关资料12个合集.zip
05-19
LwIP编程指南LwIP协议详解lwip学习笔记IP+LWIP移植实现等相关资料12个合集： IP+LWIP移植实现.pdf Lwip.doc LWIP中文.pdf LwIP协议栈源码详解.pdf LwIP协议栈的设计与实现_中文译稿.pdf LwIP协议详解.pdf lwip学习笔记.doc lwip源码详解_狗拿耗子.pdf LwIP编程指南.pdf 分析LwIP.pdf 基于LWIP协议栈的嵌入式WEB服务器的设计及实现.pdf 基于_C_OS_和LwIP的嵌入式Web服务器实现.pdf 嵌入式web服务器的实时性研究.pdf 嵌入式__LWIP_WEB服务器.doc
LwIP协议栈之IP协议
XMJYever的博客
08-03 450
IP数据报头结构 IP层主要为信息包的接收、分片数据包重装、信息包的发送和转发三个内容。 IP数据报头结构如下所示，通常的IP数据报头长度为20个字节。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RW7SzZ6w-1596445349890)(images/14.jpg)] 第一个字段是4bit的版本号，对于IPv4，该值为4；对于IPv6，该值为6； 第二个4bit字段用于记录首部长度，以字为单位。对于不含任何选项字段的IP报头，则该长度值为5，其能描述的最大IP报头
正点原子lwIP学习笔记——MQTT协议
xhj12138的博客
09-30 474
正点原子lwIP协议的学习笔记，这是第二十八篇
正点原子lwIP学习笔记——裸机移植lwIP
xhj12138的博客
09-13 653
正点原子lwIP网络协议的学习笔记，这是第五篇
正点原子阿波罗V2 Lwip例程与手册
03-15
正点原子 阿波罗V2 Lwip例程与手册
正点原子例程，lwip+stm32f407
09-08
正点原子例程，lwip+stm32f407
LwIP Application Developers Manual3---链路层和网络层协议之IPV6,ICMP，IGMP
weixin_30247781的博客
01-05 193
1.前言 本文主要讲述链路层和网络层的协议IPV6,ICMP 2.IPV6 2.1 IPV6特性 IPv6是IPv4的更新。其最显著的差别在于地址空间由32位转换成128位 2.2从应用的角度看IPv6 lwIP正在加入IPv6，直到版本为1.4.x才可以使用IPv4或IPv6，但是并不能同时使用IPv4和IPv6。 双协议栈的代码已经在当前的开发版本中（可以通过git下载）。能同...
lwIP更新记03：IPv6
朱工的专栏
05-21 1434
从 lwIP-2.0.0 开始，lwIP 终于有可用的 IPv6 协议栈了！从这个版本开始，lwIP 支持 `双栈`（IPv4 和 IPv6 同时使用） 或 `IPv4/IPv6 二选一` 。 lwIP-1.4.1 版本也有 IPv6，但那是实验性质的（见..\lwip-1.4.1\src\core\ipv6目录下的`README`文件），并不能在实际项目中使用的。
TCP/IP协议栈之LwIP（三）---网际寻址与路由(IPv4 + ARP + IPv6)
流云
07-18 5548
一、网际寻址原理 当网络设备地址总数并不是很多的情况下，有了唯一地址（比如MAC地址）就可以定位相互通信的主体。然而，当地址总数越来越多时，如何高效地从中找出通信的目标地址将成为一个重要的问题。为此人们发现地址除了具有唯一性还需要具有层次性。MAC地址虽然具有唯一性，但没有层次性，也即当网络设备增加到一定程度，需要将网络分成多个数据链路时，MAC地址无法跨链路寻址，是真正负责最终通信的地址。要实现跨局域网的网际寻址，就要靠具有层次性的网络IP地址实现了。
Freertos+LWIP，使用IPV6+Netconn UDP协议频繁发送存在随机的丢包问题
xiaolong233的博客
07-25 620
电脑和单片机使用交换机连接。TCP测试很稳定，没有丢包问题。测试UDP，丢包概率从几万分之一到一百万分之一不等。偶尔出现几千次就丢包的情况。测试逻辑是电脑给单片机发长度为512字节的字符串，等待单片机响应，超时1秒钟判断为丢包。发送间隔时间20ms。使用抓包软件，电脑最后一条数据已经发给单片机了，但是单片机recv函数没有动作。最近基于公司原有产品，验证采用ipv6传输的可靠性。有没有大神碰到过类似的问题，请指点一二，感激不尽！
书籍学习|基于SprinBoot+vue的书籍学习平台(源码+数据库+文档)
JIngJaneIL的博客
05-28 1244
首先,论文一开始便是清楚的论述了平台的研究内容。其次,剖析平台需求分析,弄明白“做什么”,分析包括业务分析和业务流程的分析以及用例分析,更进一步明确平台的需求。然后在明白了平台的需求基础上需要进一步地设计平台,主要包罗软件架构模式、整体功能模块、数据库设计。本项目软件架构选择B/S模式和java技术，总体功能模块运用自顶向下的分层思想。再然后就是实现平台并进行代码编写实现功能。论文的最后章节总结一下自己完成本论文和开发本项目的心得和总结。通过书籍学习平台将会使书籍学习各个方面的工作效率带来实质性的提升。
强化学习——学习笔记3
qq_52302919的博客
05-29 1566
先上图：在上述流程图中所说的Q表即为下表：假设我们在玩一个小游戏，该游戏有上下左右不同的动作，同时也会有不同的状态，比如游戏结束等。Q表也可以称为状态-价值函数QsaQ(s,a)Qsa：这个表格的每一行代表每个 state上述例子中的游戏结束等，每一列代表每个 action上述例子中的上下左右，表格的数值就是在各个 state 下采取各个 action 时能够获得的最大的未来期望奖励。
学习整理 docker
wonder_dog的博客
05-31 263
nexus。
超大功率光伏并网逆变器学习(三相) 一
最新发布
我的博客
05-31 340
1.超大功率用的IGBT开关频率通常很低,比如6KHz。2.线电压和相电压的关系。
基于lwip的modbus tcp/Ip协议代码编写
06-11
基于lwip的modbus tcp/ip协议代码编写需要以下步骤： 1. 安装lwip库：首先需要下载并安装lwip库，可以使用官方网站提供的源代码或者从GitHub等其他开源代码托管平台获取。 2. 创建TCP/IP连接：使用lwip库提供的API创建TCP/IP连接，这是使用modbus tcp/ip协议进行通信的基础。 3. 实现modbus协议：根据modbus tcp/ip协议的规范，实现modbus协议的各个功能码，包括读写寄存器、读写线圈等。 4. 实现modbus数据传输：使用lwip库提供的API实现modbus数据的传输，包括数据的发送和接收。 5. 测试代码：编写测试代码进行测试，确保modbus tcp/ip协议的实现符合规范，并且数据传输正确。 总的来说，基于lwip的modbus tcp/ip协议代码编写需要一定的网络编程和modbus协议实现经验，需要注意细节，确保代码的正确性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值