LwIP中TCP协议的实现

TCP控制块

与其他协议一样，为了描述TCP协议，LwIP定义了一个名字叫tcp_pcb的结构体，可以称之为TCP控制块，其内定义了大量的成员变量，基本定义了整个TCP协议运作过程的所有需要的东西，如发送窗口、接收窗口、数据缓冲区。超时处理、拥塞控制、滑动窗口等等。

/** TCP协议控制块 */
struct tcp_pcb 
{
  IP_PCB;
/** 协议特定的PCB成员 */
  TCP_PCB_COMMON(struct tcp_pcb);

  /* 远端端口号 */
  u16_t remote_port;

  tcpflags_t flags;
#define TF_ACK_DELAY   0x01U   /* 延迟发送ACK */
#define TF_ACK_NOW     0x02U   /* 立即发送ACK. */
#define TF_INFR        0x04U   /* 在快速恢复。 */
#define TF_CLOSEPEND   0x08U   /* 关闭挂起 */
#define TF_RXCLOSED    0x10U   /* rx由tcp_shutdown关闭 */
#define TF_FIN         0x20U   /* 连接在本地关闭 */
#define TF_NODELAY     0x40U   /* 禁用Nagle算法 */
#define TF_NAGLEMEMERR 0x80U   /* 本地缓冲区溢出 */
#define TF_TIMESTAMP   0x0400U   /* Timestamp option enabled */
#endif
#define TF_RTO         0x0800U /* RTO计时器 */

  u8_t polltmr, pollinterval;
  /* 控制块被最后一次处理的时间 */
  u8_t last_timer;           
  u32_t tmr;

  /* 接收窗口相关的字段 */
  u32_t rcv_nxt;   /* 下一个期望收到的序号 */
  tcpwnd_size_t rcv_wnd;   /* 接收窗口大小 */
  tcpwnd_size_t rcv_ann_wnd; /* 告诉对方窗口的大小 */
  u32_t rcv_ann_right_edge; /* 窗口的右边缘 */
 
  /* 重传计时器。*/
  s16_t rtime;

  u16_t mss;   /* 最大报文段大小 */

  /* RTT（往返时间）估计变量 */
  u32_t rttest; /* RTT估计，以为500毫秒递增 */
  u32_t rtseq;  /* 用于测试RTT的报文段序号 */
  s16_t sa, sv; /* RTT估计得到的平均值与时间差 */

  s16_t rto;    /* 重传超时 */
  u8_t nrtx;    /* 重传次数 */

  /* 快速重传/恢复 */
  u8_t dupacks;
  u32_t lastack; /* 接收到的最大确认序号 */

  /* 拥塞避免/控制变量 */
  tcpwnd_size_t cwnd;     /* 连接当前的窗口大小 */
  tcpwnd_size_t ssthresh; /* 拥塞避免算法启动的阈值 */


  u32_t rto_end;

  u32_t snd_nxt;   /* 下一个要发送的序号 */
  u32_t snd_wl1, snd_wl2; /* 上一次收到的序号和确认号 */
  u32_t snd_lbb;       /* 要缓冲的下一个字节的序列号 */
  tcpwnd_size_t snd_wnd;   /* 发送窗口大小 */
  tcpwnd_size_t snd_wnd_max; /* 对方的最大发送方窗口 */

  /* 可用的缓冲区空间（以字节为单位）。 */
  tcpwnd_size_t snd_buf;   

  tcpwnd_size_t bytes_acked;

  struct tcp_seg *unsent;   /* 未发送的报文段 */
  struct tcp_seg *unacked;  /* 已发送但未收到确认的报文段 */
  struct tcp_seg *ooseq; 
  /* 以前收到但未被上层处理的数据 */
  struct pbuf *refused_data; 

#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG
  struct tcp_pcb_listen* listener;
#endif 

//TCP协议相关的回调函数
#if LWIP_CALLBACK_API
  /* 当数据发送成功后被调用 */
  tcp_sent_fn sent;
  /* 接收数据完成后被调用 */
  tcp_recv_fn recv;
  /* 建立连接后被调用 */
  tcp_connected_fn connected;
  /* 该函数被内核周期调用 */
  tcp_poll_fn poll;
  /* 发送错误时候被调用 */
  tcp_err_fn errf;
#endif 

  /* 保持活性 */
  u32_t keep_idle;
  /* 坚持计时器计数器值 */
  u8_t persist_cnt;
  u8_t persist_backoff;
  u8_t persist_probe;

  /* 保持活性报文发送次数 */
  u8_t keep_cnt_sent;

};

IP_PCB又是一个宏定义，定义了IP层需要的一些成员变量：

#define IP_PCB                             \
  /* 本地ip地址与远端IP地址 */             \
  ip_addr_t local_ip;                      \
  ip_addr_t remote_ip;                     \
  /* 绑定netif索引 */                      \
  u8_t netif_idx;                          \
  /* 套接字选项 */                         \
  u8_t so_options;                         \
  /* 服务类型 */                           \
  u8_t tos;                                \
  /* 生存时间 */                           \
  u8_t ttl                                 \
  /* 链路层地址解析提示 */                 \
  IP_PCB_NETIFHINT

TCP_PCB_COMMON则是定义了一些特定的TCP控制块的成员变量：

#define TCP_PCB_COMMON(type) \
  type *next; /* 指向链表中的下一个控制块 */ \
  void *callback_arg; \
  TCP_PCB_EXTARGS \
  enum tcp_state state; /* TCP状态 */ \
  u8_t prio; \
  /* 本地主机端口号 */ \
  u16_t local_port

LwIP中除了定义了一个完整的TCP控制块之外，还定义了一个删减版的TCP控制块——tcp_pcb_listen，它用于描述处于监听状态的TCP连接，因为分配完整的TCP控制块是比较消耗内存资源的，而TCP协议在建立连接之前是无传输数据的，因此在监听的时候只需要把建立连接的主机的相关信息得到，然后无缝切换到完整的TCP控制块中，这样子就能节省不少资源（毕竟在嵌入式设备中资源是有限的）。除了tcp_pcb_listen外，LwIP还定义了4个链表来维护TCP连接时的各种状态，分别是：

1. 新绑定的端口链表，用于记录新绑定端口的TCP控制块。
2. 监听链表：用于记录处于监听状态的TCP控制块 。
3. 活动状态链表：用于记录处于其他（活动）状态的TCP控制块。
4. TIME_WAIT链表：用于记录处于TIME_WAIT状态的控制块。

/** 用于监听的TCP协议控制块 */
struct tcp_pcb_listen {
/** 所有PCB类型的通用成员 */
  IP_PCB;
/** 协议特定的PCB成员 */
  TCP_PCB_COMMON(struct tcp_pcb_listen);
};

/* TCP 控制块链表. */
/** 新绑定的端口 */
struct tcp_pcb *tcp_bound_pcbs;
/** 处于监听状态的TCP控制块 */
union tcp_listen_pcbs_t tcp_listen_pcbs;
/** 稳定的TCP连接 */
struct tcp_pcb *tcp_active_pcbs;
/** 处于TIME_WAIT状态的控制块 */
struct tcp_pcb *tcp_tw_pcbs;

tcp_bound_pcbs链表上的TCP控制块可以看做是处于CLOSED状态，那些新绑定的端口初始的时候都是处于这个状态。tcp_listen_pcbs链表用于记录处于监听状态的TCP控制块，一般就是记录tcp_pcb_listen控制块。tcp_tw_pcbs链表用于记录连接中处于TIME_WAIT状态下的TCP控制块。而tcp_active_pcbs链表用于记录所有其他状态（活动状态）的TCP控制块，这些端口是活跃的，可以不断进行状态转移。

窗口

关于窗口的理论我不想讲太多，大家有兴趣可以看一下网络上的其他博文，都是描述得很详细的。
TCP控制块中关于接收窗口的成员变量有rcv_nxt、rcv_wnd、rcv_ann_wnd、rcv_ann_right_edge，rcv_nxt表示下次期望接收到的数据编号，rcv_wnd表示接收窗口的大小，rcv_ann_wnd用于告诉发送方窗口的大小，rcv_ann_right_edge记录了窗口的右边界，这4个成员变量都会在数据传输的过程中动态改变的。

TCP控制块中关于发送窗口的成员变量有lastack、snd_nxt、snd_lbb、snd_wnd，lastack记录了已经确认的最大序号，snd_nxt表示下次要发送的序号，snd_lbb是表示下一个将被应用线程缓冲的序号，而snd_wnd表示发送窗口的大小，是由接收已方提供的。这些值也是动态变化的，当发送的数据收到确认，就会更新lastack，并且随着数据的发送出去，窗口会向右移动，即snd_nxt的值在增加。

每条TCP 连接的每一端都必须设有两个窗口：一个发送窗口和一个接收窗口，TCP 的可靠传输机制用字节的序号（编号）进行控制，TCP 所有的确认都是基于数据的序号而不是基于报文段，发送过的数据未收到确认之前必须保留，以便超时重传时使用，发送窗口在没收到确认序号之前是保持不动的，当收到确认序号就会向右移动，并且更新lastack 的值。

发送缓冲区用来暂时存放应用程序发送给对方的数据，这是主机已发送出但未收到确认的数据。接收缓存用来暂时存放按序到达的、但尚未被接收应用程序读取的数据以及 不按序到达的数据。

关于窗口的概念必须强调2点：

1. 发送方的发送窗口并不总是和 接收方接收窗口一样大，因为有一定的时间滞后。
2. TCP 标准没有规定对不按序到达的数据应如何处理，通常是先临时存放在接收窗口中，等到字节流中所缺少的字节收到后，再按序交付上层的应用进程。

TCP报文段发送

每个已经连接的TCP控制块中维护了3个是指针，分别是unsent、unacked、ooseq，unsent指向未发送的报文段缓冲队列，unacked指向已发送但未收到确认的报文段缓冲队列，ooseq指向已经收到的无序报文段缓冲队列。

简单来说TCP协议发送报文就是将应用层的数据写入发送缓冲区（缓冲队列）中，根据窗口大小进行发送。在LwIP中，为了更高效发送数据，Nagle算法是默认打开的。因此LwIP的处理是调用tcp_write()函数将应用层的数据写入TCP报文段缓冲队列，即TCP控制块中的unsent指针所指向的队列中，但是不会立即发送，而是存储在缓冲区里面，等待更多的数据进行高效的发送。当然只要你写入的数据满足Nagle算法的大小MSS，这是可以立即发送出去的，否则就等待超时或者数据达到MSS就会将数据发送出去。当然，我们也能将Nagle算法禁用。ps:关于写入缓冲队列的操作大家可以直接看源码即可。

当然，我们也能手动在写入数据后直接调用TCP协议的发送数据函数来发送这些数据（RAW API 比较常用这种方法），LwIP是调用tcp_output()函数来发送这些数据的，这样子一个应用层的数据就通过TCP协议传递给IP层了。

关于Nagle算法的介绍，我引用维基百科的一段描述：

TCP/IP协议中，无论发送多少数据，总是要在数据前面加上协议头，同时，对方接收到数据，也需要发送ACK表示确认。为了尽可能的利用网络带宽，TCP总是希望尽可能的发送足够大的数据。（一个连接会设置MSS参数，因此，TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据）。Nagle算法就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。
Nagle算法的基本定义是任意时刻，最多只能有一个未被确认的小段。 所谓“小段”，指的是小于MSS尺寸的数据块，所谓“未被确认”，是指一个数据块发送出去后，没有收到对方发送的ACK确认该数据已收到。

代码的实现如下：

err_t
tcp_output(struct tcp_pcb *pcb)
{
  struct tcp_seg *seg, *useg;
  u32_t wnd, snd_nxt;
  err_t err;
  struct netif *netif;

  //如果控制块有数据在处理，直接返回
  if (tcp_input_pcb == pcb) {
    return ERR_OK;
  }
  
  //得到合适的发送窗口
  wnd = LWIP_MIN(pcb->snd_wnd, pcb->cwnd);
  
  //找到控制块中的未发送数据缓冲区链表
  seg = pcb->unsent;

  //根据控制块IP地址信息找到合适的网卡发送
  netif = tcp_route(pcb, &pcb->local_ip, &pcb->remote_ip);
  if (netif == NULL) {
    return ERR_RTE;
  }

  /* 如果没有本地IP地址，我们会从netif获得一个 */
  if (ip_addr_isany(&pcb->local_ip)) {
    const ip_addr_t *local_ip = 
    ip_netif_get_local_ip(netif, &pcb->remote_ip);
    if (local_ip == NULL) {
      return ERR_RTE;
    }
    ip_addr_copy(pcb->local_ip, *local_ip);
  }

  /* 处理当前不适合窗口的报文段 */
  if (lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd) 
  {
    //开始持续定时器
    if (wnd == pcb->snd_wnd && pcb->unacked == NULL &&
    pcb->persist_backoff == 0) 
    {
      pcb->persist_cnt = 0;
      pcb->persist_backoff = 1;
      pcb->persist_probe = 0;
    }
    /* 我们需要ACK，但现在无法发送数据（无法捎带），所以发送一个ACK报文段 */
    if (pcb->flags & TF_ACK_NOW) {
      return tcp_send_empty_ack(pcb);
    }
    goto output_done;
  }
  /* 停止持续计时器 */
  pcb->persist_backoff = 0;

  /* useg指向未应答队列中的最后一个tcp_seg结构 */
  useg = pcb->unacked;
  if (useg != NULL) {
    for (; useg->next != NULL; useg = useg->next);
  }
  /* 可用数据和窗口允许它发送报文段，直到把未发送链表的数据完全发送出去或者直到填满发送窗口 */
  while (seg != NULL &&lwip_ntohl(seg->tcphdr->seqno)
         - pcb->lastack + seg->len <= wnd) 
    {
    if ((tcp_do_output_nagle(pcb) == 0) &&
        ((pcb->flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)) {
      break;
    }

    if (pcb->state != SYN_SENT) {
      TCPH_SET_FLAG(seg->tcphdr, TCP_ACK);
    }
    
    //真正发送TCP报文的函数，此处发送TCP报文段
    err = tcp_output_segment(seg, pcb, netif);
    
    if (err != ERR_OK) 
    {
      tcp_set_flags(pcb, TF_NAGLEMEMERR);
      return err;
    }
    
    //得到下一个未发送的tcp_seg
    pcb->unsent = seg->next;
    if (pcb->state != SYN_SENT) 
    {
      tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW);
    }
    //计算snd_nxt的值
    snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg);
    
    //更新下一个要发送的数据编号
    if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) 
    {
      pcb->snd_nxt = snd_nxt;
    }
    /* 如果发送出去的数据长度>0，则将这些报文段放在未确认链表中 */
    if (TCP_TCPLEN(seg) > 0) 
    {
      seg->next = NULL;
      /* 未确认链表为空，插入即可 */
      if (pcb->unacked == NULL) {
        pcb->unacked = seg;
        useg = seg;
        
      } 
      //如果不为空，按照顺序插入未确认链表中
      else 
      {
        if (TCP_SEQ_LT(lwip_ntohl(seg->tcphdr->seqno),
        lwip_ntohl(useg->tcphdr->seqno))) 
        {
          struct tcp_seg **cur_seg = &(pcb->unacked);
          while (*cur_seg &&
                 TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) {
            cur_seg = &((*cur_seg)->next );
          }
          seg->next = (*cur_seg);
          (*cur_seg) = seg;
        }
        else 
        {
          useg->next = seg;
          useg = useg->next;
        }
      }
    }
    else 
    {
      tcp_seg_free(seg);
    }
    seg = pcb->unsent;
  }

output_done:
  tcp_clear_flags(pcb, TF_NAGLEMEMERR);
  return ERR_OK;
}

总的来说，流程还是很简单明了的，如果控制块的flags字段被设置为TF_ACK_NOW，表示需要立即响应对方，但是此时还没有数据发送，就只发送一个纯粹的ACK应答报文段，如果能发送数据，那就将ACK应答捎带过去（捎带机制），这样子就能减少网络中的流量。TCP协议在发送的时候先找到未发送队列unsent，然后调用tcp_output_segment()->ip_output_if()函数进行发送，将TCP报文段传递到IP层，直到把未发送队列的数据完全发送出去或者直到填满发送窗口才算是完成一次发送操作，同时要更新发送窗口相关字段，还要将这些已发送但是未确认的数据存储在已发送但未确认链表unacked中，以防丢失数据进行重发操作，放入未确认链表的时候是按序号升序进行排序的。

TCP报文段接收

IP数据报中如果是递交给TCP协议的数据，就会调用tcp_input()函数往上层传递，因此TCP协议的报文段接收函数就是tcp_input()函数。只不过这个函数太过于复杂，我自己都不想看它，就简单用文字描述一下处理过程吧，然后删减一下代码让大伙看看。
tcp_input()函数会对传递进来的IP数据报进行处理，做一些校验，检查数据报是否正确等操作，查看一下数据报中是否有数据，如果没有就丢掉，再看一下是不是多播、广播报文，如果是就不做处理，释放pbuf。将TCP首部中的各字段内容提取出来，首先在 tcp_active_pcbs链表中寻找对应的TCP控制块，找到了就调用tcp_process()函数进行处理；如果找不到就去tcp_tw_pcbs链表中查找，找到了就调用tcp_timewait_input()函数处理它；如果还是找不到就去tcp_listen_pcbs链表中找，如果找到就调用tcp_listen_input()函数处理，如果还是找不到的话，那没办法了，这收到的是垃圾数据，释放pbu。

还要注意的是，TCP协议很可能收到不是正常数据，而是一些特殊TCP报文段：

1. 如果收到的是复位报文或终止连接应答报文，那么就释放pbuf，终止连接
2. 如果是收到了应答报文段（发送数据后必须等待应答），那么就调用宏TCP_EVENT_SENT（其实是一个sent的回调函数）去处理，并且更新窗口
3. 如果报文段中包含有效的数据，就调用TCP_EVENT_RECV去处理它，此时将产生应答报文与更新接收窗口的操作
4. 如果是收到FIN报文，则调用TCP_EVENT_CLOSED去处理它，此时将产生应答并且开始终止连接

代码如下：

void
tcp_input(struct pbuf *p, struct netif *inp)
{
  struct tcp_pcb *pcb, *prev;
  struct tcp_pcb_listen *lpcb;

  u8_t hdrlen_bytes;
  err_t err;

  LWIP_UNUSED_ARG(inp);

  PERF_START;

  TCP_STATS_INC(tcp.recv);
  MIB2_STATS_INC(mib2.tcpinsegs);

  tcphdr = (struct tcp_hdr *)p->payload;

  /* 检查报文段是否有有效数据 */
  if (p->len < TCP_HLEN) 
  {
    /* 如果没有就丢掉报文段 */
    TCP_STATS_INC(tcp.lenerr);
    goto dropped;
  }

  /* 不处理传入的广播/多播报文段。 */
  if (ip_addr_isbroadcast(ip_current_dest_addr(), 
      ip_current_netif()) ||
      ip_addr_ismulticast(ip_current_dest_addr())) 
  {
    TCP_STATS_INC(tcp.proterr);
    goto dropped;
  }

  /* 检查TCP报文段首部长度 */
  hdrlen_bytes = TCPH_HDRLEN_BYTES(tcphdr);
  if ((hdrlen_bytes < TCP_HLEN) || (hdrlen_bytes > p->tot_len)) 
  {
    TCP_STATS_INC(tcp.lenerr);
    goto dropped;
  }

  /* 移动pbuf指针，指向TCP报文段数据区域 */
  tcphdr_optlen = (u16_t)(hdrlen_bytes - TCP_HLEN);
  tcphdr_opt2 = NULL;
  if (p->len >= hdrlen_bytes) 
  {
    tcphdr_opt1len = tcphdr_optlen;
    pbuf_remove_header(p, hdrlen_bytes); 
  } 

  /* 将TCP首部中的各字段内容提取出来。 */
  tcphdr->src = lwip_ntohs(tcphdr->src);
  tcphdr->dest = lwip_ntohs(tcphdr->dest);
  seqno = tcphdr->seqno = lwip_ntohl(tcphdr->seqno);
  ackno = tcphdr->ackno = lwip_ntohl(tcphdr->ackno);
  tcphdr->wnd = lwip_ntohs(tcphdr->wnd);

  flags = TCPH_FLAGS(tcphdr);
  tcplen = p->tot_len;
  
  if (flags & (TCP_FIN | TCP_SYN)) 
  {
    tcplen++;
    if (tcplen < p->tot_len) 
    {
      /* u16_t溢出，无法处理这个 */
      TCP_STATS_INC(tcp.lenerr);
      goto dropped;
    }
  }
  
  prev = NULL;

  //遍历tcp_active_pcbs链表寻找对应的TCP控制块
  for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) 
  {
    /* 检查控制块是否与对应的网卡绑定 */
    if ((pcb->netif_idx != NETIF_NO_INDEX) &&
        (pcb->netif_idx != 
        netif_get_index(ip_data.current_input_netif))) 
    {
      prev = pcb;
      continue;
    }
     /* ··· */
     /* 省略处理 */
     /* ··· */

  if (pcb == NULL) 
  {
    /* 如果TCP控制块没有处于连接状态，就去tcp_tw_pcbs链表中找 */
    for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) 
    {
      /* 检查控制块是否与对应的网卡绑定 */
      if ((pcb->netif_idx != NETIF_NO_INDEX) &&
          (pcb->netif_idx != netif_get_index
          (ip_data.current_input_netif))) 
          {
            continue;
          }

      if (pcb->remote_port == tcphdr->src &&
          pcb->local_port == tcphdr->dest &&
          ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()) &&
          ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) 
      {
            //找到了就处理它
            tcp_timewait_input(pcb);
          
        pbuf_free(p);
        return;
      }
    }

    /* 还是找不到就去tcp_listen_pcbs链表中找 */
    prev = NULL;
    for (lpcb = tcp_listen_pcbs.listen_pcbs; 
    lpcb != NULL; lpcb = lpcb->next) 
    {
      /* 检查控制块是否与对应的网卡绑定 */
      if ((lpcb->netif_idx != NETIF_NO_INDEX) &&
          (lpcb->netif_idx != netif_get_index(ip_data.current_input_netif))) {
        prev = (struct tcp_pcb *)lpcb;
        continue;
      }
     /* ··· */
     /* 省略处理 */
     /* ··· */
     
    //找到了处于监听状态的TCP控制块
    if (lpcb != NULL) 
    {
      if (prev != NULL) {
        ((struct tcp_pcb_listen *)prev)->next = lpcb->next;
        lpcb->next = tcp_listen_pcbs.listen_pcbs;
        tcp_listen_pcbs.listen_pcbs = lpcb;
      } else {
        TCP_STATS_INC(tcp.cachehit);
      }
      //处理报文段
      tcp_listen_input(lpcb);
      pbuf_free(p);
      return;
    }
  }
  
     /* ··· */
     /* 省略处理 */
     /* ··· */

    tcp_input_pcb = pcb;
    err = tcp_process(pcb);

     /* ··· */
     /* 省略处理 */
     /* ··· */

    }
}