七LWIP学习笔记之传输控制协议（TCP）_lwip rto rtt

//定义 TCP 首部结构体
PACK_STRUCT_BEGIN
struct tcp_hdr {
　　PACK_STRUCT_FIELD(u16_t src); //源端口
　　PACK_STRUCT_FIELD(u16_t dest); //目的端口
　　PACK_STRUCT_FIELD(u32_t seqno); //序号
　　PACK_STRUCT_FIELD(u32_t ackno); //确认序号
　　PACK_STRUCT_FIELD(u16_t _hdrlen_rsvd_flags); //首部长度+保留位+标志位
　　PACK_STRUCT_FIELD(u16_t wnd); //窗口大小
　　PACK_STRUCT_FIELD(u16_t chksum); //校验和
　　PACK_STRUCT_FIELD(u16_t urgp); //紧急指针
} PACK_STRUCT_STRUCT;
PACK_STRUCT_END

//枚举类型，每个成员定义了 TCP 连接的一个状态
enum tcp_state {
　　CLOSED = 0, //没有连接
　　LISTEN = 1, //服务器进入侦听态，等待客户端的连接请求
　　SYN_SENT = 2, //连接请求已发送，等待确认
　　SYN_RCVD = 3, //已收到对方的连接请求
　　ESTABLISHED = 4, //连接已建立
　　FIN_WAIT_1 = 5, //程序已关闭该连接
　　FIN_WAIT_2 = 6, //另一端已接受关闭该连接
　　CLOSE_WAIT = 7, //等待程序关闭连接
　　CLOSING = 8, //两端同时收到对方的关闭请求
　　LAST_ACK = 9, //服务器等待对方接受关闭操作
　　TIME_WAIT = 10 //关闭成功，等待网络中可能出现的剩余数据
};

//先定义一个宏，事实上在 LwIP 中定义了两种类型的 TCP 控制块，一种专门用于描述
//处于 LISTEN 状态的连接，另一种用于描述处于其他状态的连接，这个宏定义出了两种
//类型控制块共有的一些字段
#define TCP_PCB_COMMON(type) \ //type 为宏参数
　　type *next; \ //用于将控制块组成链表
　　enum tcp_state state; \ //连接的状态，如 13.3.4 节所示
　　u8_t prio; \ //优先级，可用于回收低优先级控制块
　　void *callback_arg; \ //指向用户自定义数据，在函数回调时使用
　　u16_t local_port; \ //连接绑定的本地端口
　　err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err) //回调函数
//当处于 LISTEN 状态的控制块侦听到连接，该函数会被调用
//下面定义 TCP 控制块数据结构 tcp_pcb
struct tcp_pcb {
　　IP_PCB; //该宏在 ip.h 中被定义，包含源 IP 地址、目的 IP 地址两个重要字段
　　TCP_PCB_COMMON(struct tcp_pcb); //两种控制块都具有的字段
　　u16_t remote_port; //远端端口号
　　u8_t flags; //控制块状态、标志字段
　　//下面这些宏定义了 flags 字段中各位的含义
　　#define TF_ACK_DELAY ((u8_t)0x01U) //延迟发送 ACK（推迟确认）
　　#define TF_ACK_NOW ((u8_t)0x02U) //立即发送 ACK
　　#define TF_INFR ((u8_t)0x04U) //连接处于快重传状态
　　#define TF_TIMESTAMP ((u8_t)0x08U) //连接的时间戳选项已使能
　　#define TF_FIN ((u8_t)0x20U) //应用程序已关闭该连接
　　#define TF_NODELAY ((u8_t)0x40U) //禁止 Nagle 算法
　　#define TF_NAGLEMEMERR ((u8_t)0x80U) //本地缓冲区溢出
　　//下面所有字段记录了通信双方的数据发送状态，以及本连接上的各种定时器信息
　　//接收窗口相关的字段
　　u32_t rcv_nxt; //下一个期望接收的字节序号
　　u16_t rcv_wnd; //当前接收窗口的大小，会随着数据的接收与递交动态变化
　　u16_t rcv_ann_wnd; //将向对方通告的窗口大小，随着数据的接收与递交动态变化
　　u32_t rcv_ann_right_edge; //上一次窗口通告时窗口的右边界值
　　//下面这个字段记录了控制块上一次活动时的系统时间，也可以表示连接处于
　　//某个状态的时间，控制块其他各计数器都基于 tmr 的值来实现
　　u32_t tmr;
　　//下面两个字段用于周期性的调用一个函数，polltmr 会周期性增加，
　　u8_t polltmr, pollinterval; //当其值超过 pollinterval 时，poll 函数会被回调
　　s16_t rtime; //重传定时器，该值随时间递增，当大于 rto 的值时重传报文
　　u16_t mss; //对方可接收的最大报文段大小
　　//RTT 估计相关的字段
　　u32_t rttest; //RTT 估计时，以 500ms 为周期递增
　　u32_t rtseq; //用于测试 RTT 的报文段序号
　　s16_t sa, sv; //RTT 估计出的平均值及其时间差
　　u16_t rto; //重发超时时间，使用上面的几个值计算出来
　　u8_t nrtx; //重发次数，多次重发时，将使用该字段设置 rto 的值
　　//快速重传与恢复相关的字段
　　u32_t lastack; //接收到的最大确认号
　　u8_t dupacks; //上述最大确认号被重复收到的次数
　　//阻塞控制相关字段
　　u16_t cwnd; //连接当前的阻塞窗口大小
　　u16_t ssthresh; //拥塞避免算法启动阈值
　　//发送窗口相关的字段
　　u32_t snd_nxt; //下一个将要发送的数据的序号
　　u16_t snd_wnd; //发送窗口的大小
　　u32_t snd_wl1, snd_wl2; //上次窗口更新时收到的数据序号和确认序号
　　u32_t snd_lbb; //下一个被缓冲的应用程序数据的编号
　　u16_t acked; //上一次成功发送的字节数
　　u16_t snd_buf; //可使用的发送缓冲区大小
　　#define TCP_SNDQUEUELEN_OVERFLOW (0xffff­3) //该宏用于缓冲区上限溢出检查
　　u16_t snd_queuelen; //缓冲数据已占用的 pbuf 个数
　　//下面三个字段是用户数据缓冲的队列指针
　　struct tcp_seg *unsent; //未发送的报文段队列
　　struct tcp_seg *unacked; //发送了但未收到确认的报文段队列
　　struct tcp_seg *ooseq; //接收到的无序报文段队列
　　struct pbuf *refused_data; //指向上一次成功接收但未被应用层取用的数据 pbuf
　　//下面是几个函数指针，用于回调，用户可以在初始化时注册这些函数
　　err_t (* sent)(void *arg, struct tcp_pcb *pcb, u16_t space); //当数据被成功发送后被调用
　　err_t (* recv)(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err); //接收到数据后被调用
　　err_t (* connected)(void *arg, struct tcp_pcb *pcb, err_t err); //连接建立后被调用
　　err_t (* poll)(void *arg, struct tcp_pcb *pcb); //该函数被内核周期性调用
　　void (* errf)(void *arg, err_t err); //连接发生错误时调用
　　u32_t keep_idle; //保活计时器的上限值
　　u32_t persist_cnt; //坚持定时器计数值
　　u8_t persist_backoff; //坚持定时器探查报文发送的数目
　　u8_t keep_cnt_sent; //保活报文发送的次数
}
//下面定义用于 LISTEN 状态 TCP 连接的控制块结构 tcp_pcb_listen
struct tcp_pcb_listen {
　　IP_PCB; //该宏包含源 IP 地址、目的 IP 地址两个重要字段
　　TCP_PCB_COMMON(struct tcp_pcb_listen); //两种控制块都具有的字段
};

struct tcp_pcb *tcp_bound_pcbs; //连接所有进行了端口号绑定，但是还没有发起连接（主动连接）或进入侦听状态（被动连接）的控制块
union tcp_listen_pcbs_t tcp_listen_pcbs; //连接所有进入侦听状态（被动连接）的控制块
struct tcp_pcb *tcp_active_pcbs; //连接所有处于其他状态的控制块
struct tcp_pcb *tcp_tw_pcbs; //连接所有处于 TIME­WAIT 状态的控制块

struct tcp_pcb *tcp_alloc(u8_t prio)
{
　　struct tcp_pcb *pcb;
　　u32_t iss;
　　pcb = memp_malloc(MEMP_TCP_PCB); //申请一个内存池空间
　　if (pcb == NULL) { //申请失败
　　　　tcp_kill_timewait(); //回收最老的 TIME­WAIT 状态控制块
　　　　pcb = memp_malloc(MEMP_TCP_PCB); //再次申请分配
　　　　if (pcb == NULL) { //申请失败
　　　　　　tcp_kill_prio(prio); //回收优先级较低的控制块
　　　　　　pcb = memp_malloc(MEMP_TCP_PCB); //再次申请分配
　　　　}
　　}
　　if (pcb != NULL) { //若分配成功，则初始化相关各个字段
　　　　memset(pcb, 0, sizeof(struct tcp_pcb)); //清 0 所有字段
　　　　pcb­>prio = TCP_PRIO_NORMAL; //设置控制块优先级
　　　　pcb­>snd_buf = TCP_SND_BUF; //可使用的发送缓冲区大小
　　　　pcb­>snd_queuelen = 0; //缓冲区已占用的 pbuf 个数
　　　　pcb­>rcv_wnd = TCP_WND; //接收窗口
　　　　pcb­>rcv_ann_wnd = TCP_WND; //通告接收窗口
　　　　pcb­>tos = 0; //服务类型
　　　　pcb­>ttl = TCP_TTL; //TTL 字段
　　　　pcb­>mss = (TCP_MSS > 536) ? 536 : TCP_MSS; //初始化最大报文段大小
　　　　pcb­>rto = 3000 / TCP_SLOW_INTERVAL; //初始化超时时间
　　　　pcb­>sa = 0; //初始化与 RTT 估计相关的字段
　　　　pcb­>sv = 3000 / TCP_SLOW_INTERVAL;
　　　　pcb­>rtime = ­1;
　　　　pcb­>cwnd = 1; //初始化阻塞窗口
　　　　iss = tcp_next_iss(); //获得初始序列号
　　　　pcb­>snd_wl2 = iss; //初始化发送窗口的各个字段
　　　　pcb­>snd_nxt = iss;
　　　　pcb­>lastack = iss;
　　　　pcb­>snd_lbb = iss;
　　　　pcb­>tmr = tcp_ticks; //记录控制块创建时的系统时刻
　　　　pcb­>polltmr = 0; //清空周期性事件的定时器
　　　　pcb­>recv = tcp_recv_null; //注册接收数据的默认上层函数
　　　　pcb­>keep_idle = TCP_KEEPIDLE_DEFAULT; //保活计数器计数上限值
　　　　pcb­>keep_cnt_sent = 0; //保活报文发送的次数
　　}
　　return pcb;
}

//函数功能：将某个绑定的控制块置为侦听状态
//参数 pcb：操作的控制块对象；参数 backlog：用户参数，这里未使用到
//返回值：指向处于侦听状态的控制块
struct tcp_pcb *tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
{
　　struct tcp_pcb_listen *lpcb;
　　if (pcb­>state == LISTEN) { //如果控制块是 LISTEN 状态，直接返回
　　　　return pcb;
　　}
　　lpcb = memp_malloc(MEMP_TCP_PCB_LISTEN); //分配一个内存池空间
　　if (lpcb == NULL) { //申请失败，直接返回
　　　　return NULL;
　　}
　　lpcb­>callback_arg = pcb­>callback_arg; //拷贝控制块的各个字段
　　lpcb­>local_port = pcb­>local_port;
　　lpcb­>state = LISTEN;
　　lpcb­>so_options = pcb­>so_options;
　　lpcb­>so_options |= SOF_ACCEPTCONN;
　　lpcb­>ttl = pcb­>ttl;
　　lpcb­>tos = pcb­>tos;
　　ip_addr_set(&lpcb­>local_ip, &pcb­>local_ip);
　　TCP_RMV(&tcp_bound_pcbs, pcb); //从 tcp_bound_pcbs 链表中删除控制块
　　memp_free(MEMP_TCP_PCB, pcb); //释放控制块内存空间
　　lpcb­>accept = tcp_accept_null; //接受客户端连接的默认回调函数
　　TCP_REG(&tcp_listen_pcbs.listen_pcbs, lpcb); //控制块加入 tcp_listen_pcbs 链表首部
　　return (struct tcp_pcb *)lpcb;
}

//函数功能：向服务器发送一个 SYN 握手报文
//参数 ipaddr：服务器 IP 地址，参数 port：服务器端口号
//参数 connected：注册给控制块的回调函数，当 SYN 报文得到服务器的正确响应
//（SYN+ACK）后，该函数将被内核回调
err_t tcp_connect(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port,err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err))
{
　　err_t ret;
　　u32_t iss;
　　if (ipaddr != NULL) { //服务器 IP 地址有效，则在连接中记录该 IP 地址
　　　　pcb­>remote_ip = *ipaddr;
　　} else { //服务器 IP 地址无效，返回错误
　　　　return ERR_VAL;
　　}
　　pcb­>remote_port = port; //记录服务器端口（目的端口）
　　if (pcb­>local_port == 0) { //如果本地端口未绑定，则绑定一个短暂端口
　　　　pcb­>local_port = tcp_new_port();
　　}
　　iss = tcp_next_iss(); //初始化序号
　　pcb­>rcv_nxt = 0; //设置发送窗口的各个字段
　　pcb­>snd_nxt = iss;
　　pcb­>lastack = iss ­ 1;
　　pcb­>snd_lbb = iss ­ 1;
　　pcb­>rcv_wnd = TCP_WND; //设置默认接收窗口各个字段值
　　pcb­>rcv_ann_wnd = TCP_WND;
　　pcb­>rcv_ann_right_edge = pcb­>rcv_nxt;
　　pcb­>snd_wnd = TCP_WND;
　　pcb­>mss = (TCP_MSS > 536) ? 536 : TCP_MSS; //初始化最大报文段大小
　　pcb­>cwnd = 1; //初始化阻塞窗口
　　pcb­>ssthresh = pcb­>mss * 10;
　　pcb­>state = SYN_SENT; //控制块设置为 SYN_SENT 状态
　　pcb­>connected = connected; //注册 connected 回调函数
　　TCP_RMV(&tcp_bound_pcbs, pcb); //控制块从 tcp_bound_pcbs 链表中删除
　　TCP_REG(&tcp_active_pcbs, pcb); //控制块加入到 tcp_active_pcbs 链表
　　//下面调用函数 tcp_enqueue 为连接构造一个报文段，首部 SYN 置 1，数据为空，
　　//且报文中包含最大报文段选项
　　ret = tcp_enqueue(pcb, NULL, 0, TCP_SYN, 0, TF_SEG_OPTS_MSS);
　　if (ret == ERR_OK) { //将控制块上连接的报文段发送出去
　　　　tcp_output(pcb);
　　}
　　return ret;
}

//函数功能：连接向另一方发送数据，该函数构造一个报文段并放在控制块缓冲队列中
//参数 pcb：指向相应连接的控制块
//参数 data：待发送数据的起始地址
//参数 len：待发送数据的长度
//参数 apiflags：数据是否进行拷贝，以及报文段首部是否设置 PSH 标志
err_t tcp_write(struct tcp_pcb *pcb, const void *data, u16_t len, u8_t apiflags)
{
　　if (pcb­>state == ESTABLISHED ||pcb­>state == CLOSE_WAIT || //控制块状态允许
　　　　pcb­>state == SYN_SENT ||pcb­>state == SYN_RCVD) {
　　　　if (len > 0) {//发送数据的长度不为 0
　　　　　　return tcp_enqueue(pcb, (void *)data, len, 0, apiflags, 0); //调用函数构造报文段
　　　　}
　　　　return ERR_OK;
　　　　} else { //控制块状态不允许发送数据，则返回错误
　　　　　　return ERR_CONN;
　　　　}
}

//函数功能：关闭一个 TCP 连接
err_t tcp_close(struct tcp_pcb *pcb)
{
　　err_t err;
　　switch (pcb­>state) { //根据控制块的不同状态做出不同的处理
　　case CLOSED: // CLOSED 状态
　　　　err = ERR_OK;
　　　　TCP_RMV(&tcp_bound_pcbs, pcb); //从链表上删除
　　　　memp_free(MEMP_TCP_PCB, pcb); //释放内存空间
　　　　pcb = NULL;
　　　　break;
　　case LISTEN: // LISTEN 状态
　　　　err = ERR_OK;
　　　　tcp_pcb_remove((struct tcp_pcb **)&tcp_listen_pcbs.pcbs, pcb); //从链表上删除
　　　　memp_free(MEMP_TCP_PCB_LISTEN, pcb); //释放内存空间
　　　　pcb = NULL;
　　　　break;
　　case SYN_SENT: //SYN_SENT 状态
　　　　err = ERR_OK;
　　　　tcp_pcb_remove(&tcp_active_pcbs, pcb); //从链表上删除
　　　　memp_free(MEMP_TCP_PCB, pcb); //释放内存空间
　　　　pcb = NULL;
　　　　break;
　　case SYN_RCVD: //SYN_RCVD 状态
　　　　err = tcp_send_ctrl(pcb, TCP_FIN); //构造主动关闭 FIN 握手报文
　　　　if (err == ERR_OK) { //转到 FIN_WAIT_1 状态
　　　　　　pcb­>state = FIN_WAIT_1;
　　　　}
　　　　break;
　　case ESTABLISHED: //ESTABLISHED 状态
　　　　err = tcp_send_ctrl(pcb, TCP_FIN); //构造主动关闭 FIN 握手报文
　　　　if (err == ERR_OK) {
　　　　　　pcb­>state = FIN_WAIT_1; //转到 FIN_WAIT_1 状态
　　　　}
　　　　break;
　　case CLOSE_WAIT: //CLOSE_WAIT 状态，即已收到对方的 FIN
　　　　err = tcp_send_ctrl(pcb, TCP_FIN); //构造 FIN 握手报文
　　　　if (err == ERR_OK) {
　　　　　　pcb­>state = LAST_ACK; //进入 LAST_ACK 等待 ACK 或超时
　　　　}
　　　　break;
　　default: //对于其他状态，由 TCP 定时函数来处理
　　　　err = ERR_OK;
　　　　pcb = NULL;
　　　　break;
　　}
　　if (pcb != NULL && err == ERR_OK) {//调用函数，发送控制块队列中的剩余报文段
　　　　tcp_output(pcb); //包括 FIN 握手报文段
　　}
　　return err;
}

//定义组织 TCP 报文段的结构
struct tcp_seg {
　　struct tcp_seg *next; //该指针用于将报文段组织为队列的形式
　　struct pbuf *p; //指向装载报文段的 pbuf
　　void *dataptr; //指向报文段中的 TCP 数据区域
　　u16_t len; //报文段中的数据长度
　　u8_t flags; //表示所描述报文段的选项属性
　　#define TF_SEG_OPTS_MSS (u8_t)0x01U //包含了最大报文段大小选项
　　#define TF_SEG_OPTS_TS (u8_t)0x02U //包含了时间戳选项
　　struct tcp_hdr *tcphdr; //指向报文段中的 TCP 首部
};

err_t tcp_enqueue(struct tcp_pcb *pcb, void *arg, u16_t len,u8_t flags, u8_t apiflags, u8_t optflags)

if ((flags & TCP_SYN) || (flags & TCP_FIN)) { // SYN 或 FIN 占用 1 个数据长度
　　++len; //计算所有报文段占用的长度
}
if (flags & TCP_FIN) { // 若为 FIN，则设置控制块 flags 字段为相应状态
　　pcb­>flags |= TF_FIN;
}
pcb­>snd_lbb += len; //下一个要被缓冲数据的序号
pcb­>snd_buf ­= len; //减小空闲的发送缓冲空间
pcb­>snd_queuelen = queuelen; //控制块已占用的 pbuf 个数

//发送控制块缓冲队列中的报文段
err_t tcp_output(struct tcp_pcb *pcb)
{
　　struct tcp_seg *seg, *useg;
　　u32_t wnd, snd_nxt;
　　//如果控制块当前正有数据被处理，这里不做任何输出，直接返回
　　if (tcp_input_pcb == pcb) { //在控制块的数据处理完成后，内核会再次
　　　　return ERR_OK; //调用 tcp_output 发送数据，见函数 tcp_input
　　}
　　//从发送窗口和阻塞窗口取小者得到有效发送窗口，拥塞避免会讲解到这个原理
　　wnd = LWIP_MIN(pcb­>snd_wnd, pcb­>cwnd);
　　seg = pcb­>unsent; //未发送队列
　　//若要求立即确认，但该 ACK 又不能被捎带出去，则只发送一个纯 ACK 的报文段
　　if (pcb­>flags & TF_ACK_NOW &&
　　　　(seg == NULL ||ntohl(seg­>tcphdr­>seqno) ­ pcb­>lastack + seg­>len > wnd)) {
　　　　return tcp_send_empty_ack(pcb); //发送只带 ACK 的报文段
　　}
　　//将 useg 变量指向未确认队列的尾部 tcp_seg 结构
　　useg = pcb­>unacked;
　　if (useg != NULL) {
　　　　for (; useg­>next != NULL; useg = useg­>next); //得到尾部
　　}
　　//若当前有效发送窗口允许报文的发送，则循环发送报文，直至填满窗口
　　while (seg != NULL &&ntohl(seg­>tcphdr­>seqno) ­ pcb­>lastack + seg­>len <= wnd) {
　　　　//如果 Nagle 算法有效，或者当前控制块内存有错误，则不发送报文
　　　　if((tcp_do_output_nagle(pcb) == 0) &&
　　　　　　((pcb­>flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)){
　　　　　　break; //结束发送循环
　　　　}
　　　　//否则，当前报文段可以发送
　　　　pcb­>unsent = seg­>next; //从缓冲队列中删除报文段
　　　　if (pcb­>state != SYN_SENT) { //当前不为 SYN_SENT 状态
　　　　　　TCPH_SET_FLAG(seg­>tcphdr, TCP_ACK); //填写首部中的 ACK 标志
　　　　　　pcb­>flags &= ~(TF_ACK_DELAY | TF_ACK_NOW); //清除标志位
　　　　}
　　　　tcp_output_segment(seg, pcb); //调用函数发送报文段
　　　　snd_nxt = ntohl(seg­>tcphdr­>seqno) + TCP_TCPLEN(seg); //计算 snd_nxt 值
　　　　if (TCP_SEQ_LT(pcb­>snd_nxt, snd_nxt)) { //更新下一个要发送的数据编号
　　　　　　pcb­>snd_nxt = snd_nxt;
　　　　}
　　　　//如果发送出去的报文段数据长度不为 0，或者带有 SYN、FIN 标志，则将该报
　　　　//文段加入到未确认队列中以便超时后重传
　　　　if (TCP_TCPLEN(seg) > 0) {
　　　　　　seg­>next = NULL; //清空报文段 next 字段
　　　　　　if (pcb­>unacked == NULL) { //若未确认队列为空，则直接挂接
　　　　　　　　pcb­>unacked = seg;
　　　　　　　　useg = seg; //变量 useg 指向未确认队列尾部
　　　　　　} else {
　　　　　　　　//如果未确认队列不为空，则需要把当前报文按照顺序组织在队列中
　　　　　　　　if (TCP_SEQ_LT(ntohl(seg­>tcphdr­>seqno), ntohl(useg­>tcphdr­>seqno))){
　　　　　　　　　　//如果当前报文的序列号比队列尾部报文的序列号低，则从队列首部开始
　　　　　　　　　　//查找合适的位置，插入报文段
　　　　　　　　　　struct tcp_seg **cur_seg = &(pcb­>unacked);
　　　　　　　　　　while (*cur_seg &&
　　　　　　　　　　　　TCP_SEQ_LT(ntohl((*cur_seg)­>tcphdr­>seqno), ntohl(seg­>tcphdr­>seqno))) {
　　　　　　　　　　　　cur_seg = &((*cur_seg)­>next );
　　　　　　　　　　} //找到插入位置，将报文段插入到队列中
　　　　　　　　　　seg­>next = (*cur_seg);
　　　　　　　　　　(*cur_seg) = seg;
　　　　　　　　} else { //报文段序号最高，则放在未确认队列尾部
　　　　　　　　　　useg­>next = seg;
　　　　　　　　　　useg = useg­>next;
　　　　　　　　}
　　　　　　}
　　　　} else { //报文段长度为 0，不需要重传，直接删除
　　　　　　　tcp_seg_free(seg);
　　　　}
　　　　seg = pcb­>unsent; //发送下一个报文段
　　}//while
　　//如果发送窗口被填满导致报文段不能发送，则启动零窗口探测，以保证能
　　//准确地收到接收方的窗口通告，关于窗口探测，将在后续讲解
　　if (seg != NULL && pcb­>persist_backoff == 0 &&
　　ntohl(seg­>tcphdr­>seqno) ­ pcb­>lastack + seg­>len > pcb­>snd_wnd) {
　　　　pcb­>persist_cnt = 0; //清 0 已发送的窗口探测包数目
　　　　pcb­>persist_backoff = 1; //启动探测定时器
　　}
　　pcb­>flags &= ~TF_NAGLEMEMERR; //报文段成功发送，清除内存错误标志
　　return ERR_OK;
}

//定义一些全局静态变量，这些变量可以在该文件的所有函数中直接引用
static struct tcp_seg inseg; //tcp_seg 结构，用来描述输入的报文段
static struct tcp_hdr *tcphdr; //指向报文段中的 TCP 首部
static struct ip_hdr *iphdr; //指向 IP 数据报首部
static u32_t seqno, ackno; //报文段 TCP 首部中的序号字段与确认号字段值
static u8_t flags; //首部中的标志字段值
static u16_t tcplen; //TCP 报文段长度
static u8_t recv_flags; //该变量记录了所有函数对当前报文段的处理结果
static struct pbuf *recv_data; //指向报文段中的数据 pbuf
struct tcp_pcb *tcp_input_pcb; //处理当前报文段的控制块

void tcp_input(struct pbuf *p, struct netif *inp)
{
　　……
　　tcp_input_pcb = pcb; //记录处理当前报文的控制块
　　err = tcp_process(pcb); //处理报文段
　　//若返回值为 ERR_ABRT，说明控制块已经被完全删除，这里什么也不需要做
　　if (err != ERR_ABRT) { //不为 ERR_ABRT
　　　　if (recv_flags & TF_RESET) { //若收到对方的复位报文，连接出错，回调用户的
　　　　　　TCP_EVENT_ERR(pcb­>errf, pcb­>callback_arg, ERR_RST); //errf 函数
　　　　　　tcp_pcb_remove(&tcp_active_pcbs, pcb); //删除控制块
　　　　　　memp_free(MEMP_TCP_PCB, pcb); //释放控制块空间
　　　　} else if (recv_flags & TF_CLOSED) { //双方连接成功断开
　　　　　　tcp_pcb_remove(&tcp_active_pcbs, pcb); //删除控制块
　　　　　　memp_free(MEMP_TCP_PCB, pcb); //释放控制块空间
　　　　} else {
　　　　　　err = ERR_OK; //若有数据被确认，则回调用户的 sent 函数
　　　　　　if (pcb­>acked > 0) {
　　　　　　　　TCP_EVENT_SENT(pcb, pcb­>acked, err);
　　　　　　}
　　　　　　if (recv_data != NULL) { //如果有数据被接收到
　　　　　　　　if(flags & TCP_PSH) { //若有 PSH 标志，则设置 pbuf 首部的 flags 字段
　　　　　　　　　　recv_data­>flags |= PBUF_FLAG_PUSH;
　　　　　　　　}
　　　　　　　　TCP_EVENT_RECV(pcb, recv_data, ERR_OK, err); //回调用户的 recv 函数
　　　　　　　　if (err != ERR_OK) { //如果用户处理数据失败
　　　　　　　　　　pcb­>refused_data = recv_data; //将数据暂存在 refused_data 中
　　　　　　　　}
　　　　　　}
　　　　　　//如果收到对方的 FIN 请求，则用一个 NULL 的数据指针回调 recv，
　　　　　　/通过这种方式用户程序可以知道对方的关闭请求
　　　　　　if (recv_flags & TF_GOT_FIN) {
　　　　　　　　TCP_EVENT_RECV(pcb, NULL, ERR_OK, err);
　　　　　　}
　　　　　　tcp_input_pcb = NULL; //清空全局变量
　　　　　　tcp_output(pcb); //尝试输出报文
　　　　}
　　}// if (err != ERR_ABRT)
……
}

//函数功能：TIME_WAIT 状态的控制块处理报文段
//函数说明：所有报文相关的信息已被保存在上节所述的全局变量中，在该状态下，应该
//忽略掉所有 RST、ACK、FIN 置位的报文，且任何数据都会被删除，但需要向发送方
//返回 ACK 报文
static err_t tcp_timewait_input(struct tcp_pcb *pcb)
{
　　if (flags & TCP_RST) { //若报文的 RST 置位，直接返回
　　　　return ERR_OK;
　　}
　　if (flags & TCP_SYN) { //若报文段包含了 SYN 握手信息
　　　　//且握手数据编号在接收窗口内，则向对方发送 RST 报文
　　　　if (TCP_SEQ_BETWEEN(seqno, pcb­>rcv_nxt, pcb­>rcv_nxt+pcb­>rcv_wnd)) {
　　　　　　tcp_rst(ackno, seqno + tcplen, &(iphdr­>dest), &(iphdr­>src),
　　　　　　tcphdr­>dest, tcphdr­>src);
　　　　　　return ERR_OK;
　　　　}
　　} else if (flags & TCP_FIN) { //若报文段包含了 FIN 握手信息
　　　　pcb­>tmr = tcp_ticks; //复位 2MSL 等待时间，控制块重新等待 2MSL
　　}
　　if ((tcplen > 0)) {//对于有数据的报文，或者在接收窗口外的 SYN 报文
　　　　pcb­>flags |= TF_ACK_NOW; //发送一个 ACK 报文段
　　　　return tcp_output(pcb);
　　}
　　return ERR_OK;
}

//函数功能：LISTEN 状态的控制块处理报文段
//函数说明：所有报文相关的信息已经被保存在前面所述的全局变量中
static err_t tcp_listen_input(struct tcp_pcb_listen *pcb)
{
　　struct tcp_pcb *npcb;
　　err_t rc;
　　if (flags & TCP_ACK) {
　　　　//侦听到任何包含 ACK 的报文段，直接返回 RST 报文，SYN 握手包
　　　　//不应该包含 ACK
　　　　tcp_rst(ackno + 1, seqno + tcplen,&(iphdr­>dest), &(iphdr­>src),tcphdr­>dest, tcphdr­>src);
　　} else if (flags & TCP_SYN) { //收到 SYN 握手报文
　　　　npcb = tcp_alloc(pcb­>prio); //为新连接创建一个控制块
　　　　if (npcb == NULL) { //若创建失败，直接返回内存错误，不进行任何回复，
　　　　　　return ERR_MEM; //对方超时后会重发 SYN，那时可能就有内存空间了
　　　　}
　　　　//设置新控制块中与连接相关的四个字段
　　　　ip_addr_set(&(npcb­>local_ip), &(iphdr­>dest));
　　　　npcb­>local_port = pcb­>local_port;
　　　　ip_addr_set(&(npcb­>remote_ip), &(iphdr­>src));
　　　　npcb­>remote_port = tcphdr­>src;
　　　　//设置控制块中其余字段
　　　　npcb­>state = SYN_RCVD; //设置连接状态
　　　　npcb­>rcv_nxt = seqno + 1; //设置下一个接收数据序号
　　　　npcb­>rcv_ann_right_edge = npcb­>rcv_nxt;
　　　　npcb­>snd_wnd = tcphdr­>wnd; //设置发送窗口
　　　　npcb­>ssthresh = npcb­>snd_wnd;
　　　　//snd_wl1 设置为 seqno­1，在收到对方 ACK（含窗口通告）后会迫使发送窗口更新
　　　　npcb­>snd_wl1 = seqno ­ 1;
　　　　npcb­>callback_arg = pcb­>callback_arg;
　　　　npcb­>accept = pcb­>accept;
　　　　npcb­>so_options = pcb­>so_options &
　　　　(SOF_DEBUG|SOF_DONTROUTE|SOF_KEEPALIVE|SOF_OOBINLINE|SOF_LINGER);
　　　　TCP_REG(&tcp_active_pcbs, npcb); //将新控制块加入 tcp_active_pcbs 链表
　　　　//处理 SYN 包中的选项字段，并设置控制块 flags 字段中与相应选项对应的位，
　　　　//目前只支持最大报文段选项和时间戳选项
　　　　tcp_parseopt(npcb);
　　　　npcb­>mss = tcp_eff_send_mss(npcb­>mss, &(npcb­>remote_ip)); //设置最大报文段长度
　　　　//构造 SYN+ACK 握手报文，且包含 MSS 选项，通告自己的最大报文段大小
　　　　rc = tcp_enqueue(npcb, NULL, 0, TCP_SYN | TCP_ACK, 0, TF_SEG_OPTS_MSS);
　　　　if (rc != ERR_OK) { //如果发生错误则释放新控制块
　　　　　　tcp_abandon(npcb, 0);
　　　　　　return rc;
　　　　}
　　　　return tcp_output(npcb); //发送报文段
　　}
　　return ERR_OK;
}

//函数功能：实现 TCP 状态机的函数
//函数说明：所有报文相关的信息已经被保存在如前所述的全局变量中
static err_t tcp_process(struct tcp_pcb *pcb)
{
    struct tcp_seg *rseg;
    u8_t acceptable = 0;
    err_t err;
    err = ERR_OK;
    //如果收到的报文段 RST 标志置位，则判断该报文段是否合法，若合法，
    //则复位当前的连接
    if (flags & TCP_RST) {
        if (pcb->state == SYN_SENT) { //第一种情况，连接处于 SYN_SENT 状态
            if (ackno == pcb->snd_nxt) { //且报文中确认号与 snd_nxt 相等
                acceptable = 1;
            }
        } else { //第二种情况，其他状态下报文中的序列号在接收窗口内
            if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt+pcb->rcv_wnd)) {
                acceptable = 1;
            }
        }
        //如果复位报文合法，则需要复位当前连接的控制块
        if (acceptable) {
            recv_flags |= TF_RESET; //设置 recv_flags 为复位，tcp_input 将删除控制块
            pcb->flags &= ~TF_ACK_DELAY;
            return ERR_RST; //返回
        } else { //复位报文不合法，直接返回，不对报文做处理
            return ERR_OK;
        }
    }//if(flags& TCP_RST)
    //处理握手报文 SYN，连接已经建立，但还收到对方的握手包，说明这
    //可能是一个超时重发的握手包，直接向对方返回 ACK 即可
    if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) {
        tcp_ack_now(pcb); //返回 ACK
        return ERR_OK;
    }
    pcb->tmr = tcp_ticks; //复位控制块的活动计数器
    pcb->keep_cnt_sent = 0; //保活报文计数器清 0，后续讲解保活机制
    tcp_parseopt(pcb); //处理报文首部中的选项字段，设置控制块中的 flags 标志
    //下面是实现 TCP 状态机的具体部分
    switch (pcb->state) {
        case SYN_SENT://客户端发送 SYN 后，处于该状态等待服务器返回 AYN+ACK
            if ((flags & TCP_ACK) && (flags & TCP_SYN) //是 AYN+ACK，且序列号正确
            && ackno == ntohl(pcb->unacked->tcphdr->seqno) + 1) {
                pcb->snd_buf++; //SYN 被确认，该报文占用一个字节，可用空间加上 1 字节
                pcb->rcv_nxt = seqno + 1; //设置接收序号
                pcb->rcv_ann_right_edge = pcb->rcv_nxt; //初始化通告窗口的右边界值
                pcb->lastack = ackno; //被确认的最高序号
                pcb->snd_wnd = tcphdr->wnd; //发送窗口设置为接收窗口大小
                //snd_wl1 设置为 seqno-1，在收到对方
                pcb->snd_wl1 = seqno - 1; //有效窗口通告后会迫使发送窗口更新
                pcb->state = ESTABLISHED; //进入 ESTABLISHED 状态
                pcb->mss = tcp_eff_send_mss(pcb->mss, &(pcb->remote_ip)); //设置最大报文段
                pcb->ssthresh = pcb->mss * 10; //重新设置了 mss 值，所以要重设 ssthresh 值
                pcb->cwnd = ((pcb->cwnd == 1) ; (pcb->mss * 2) : pcb->mss); //初始化阻塞窗口
                --pcb->snd_queuelen; // SYN 报文被确认，占用 pbuf 个数减 1
                rseg = pcb->unacked; //在缓冲队列中删除 SYN 报文
                pcb->unacked = rseg->next;
                if(pcb->unacked == NULL) //未确认队列为空，则停止重传计时器
                    pcb->rtime = -1;
                else { //队列上有报文，则复位重传计时器、重传次数
                    pcb->rtime = 0;
                    pcb->nrtx = 0;
                }
                tcp_seg_free(rseg); //释放取下的 SYN 报文段空间
                TCP_EVENT_CONNECTED(pcb, ERR_OK, err); //回调用户的 connected 函数
                tcp_ack_now(pcb); //向服务器返回 ACK，三次握手结束
            }
            else if (flags & TCP_ACK) {//只收到对方的 ACK 却没有 SYN，则向对方返回 RST
                tcp_rst(ackno, seqno + tcplen, &(iphdr->dest), &(iphdr->src), //不支持半打开状态
                tcphdr->dest, tcphdr->src);
            }
            break;
        case SYN_RCVD: //服务器在发送完 SYN+ACK 后，将处于该状态
            if (flags & TCP_ACK) { //收到 ACK 报文，三次握手的最后一个报文
                if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)) { //确认号合法
                    u16_t old_cwnd;
                    pcb->state = ESTABLISHED; //进入 ESTABLISHED 状态
                    TCP_EVENT_ACCEPT(pcb, ERR_OK, err); //回调用户的 accept 函数
                    if (err != ERR_OK) { //如果 accept 回调函数执行错误，则关闭当前连接
                        tcp_abort(pcb);
                        return ERR_ABRT; //返回错误
                    }
                    old_cwnd = pcb->cwnd; //保存旧的阻塞窗口
                    tcp_receive(pcb); //调用函数处理报文中的数据
                    if (pcb->acked != 0) { //如果本地有未确认数据被报文中的 ACK 确认
                        pcb->acked--; //调整确认的字节数，因为 SYN 报文占了一个字节
                    }
                    pcb->cwnd = ((old_cwnd == 1) ; (pcb->mss * 2) : pcb->mss);//重新设置阻塞窗口
                    if (recv_flags & TF_GOT_FIN) { //tcp_receive 处理时设置了关闭连接标志
                        tcp_ack_now(pcb); //响应对方的 FIN 握手标志
                        pcb->state = CLOSE_WAIT; //进入 CLOSE_WAIT 状态
                    }
                }
                else { //不合法 ACK 序号则返回一个复位报文
                    tcp_rst(ackno, seqno + tcplen, &(iphdr->dest), &(iphdr->src),
                    tcphdr->dest, tcphdr->src);
                }
            } else if ((flags & TCP_SYN) && (seqno == pcb->rcv_nxt - 1)) { //收到对方重复的
                tcp_rexmit(pcb); //SYN 握手，说明 SYN+ACK 丢失，这里重传 SYN+ACK
            }
            break;
        case CLOSE_WAIT: //服务器处于半关闭状态，不可能再接收到来自客户端的报文，服
            //务器在此状态下会一直等待上层应用执行关闭命令 tcp_close，
            //并将状态变为 LAST_ACK
        case ESTABLISHED: //连接双方都处于稳定状态
            tcp_receive(pcb); //调用函数处理报文中的数据
            if (recv_flags & TF_GOT_FIN) { //tcp_receive 处理时设置了关闭连接标志
                tcp_ack_now(pcb); //响应对方的 FIN 握手标志
                pcb->state = CLOSE_WAIT; //进入 CLOSE_WAIT 状态
            }
            break;
        case FIN_WAIT_1: //上层应用调用 tcp_close 关闭连接，发送 FIN 后处于该状态
            tcp_receive(pcb); //调用函数处理报文中的数据
            if (recv_flags & TF_GOT_FIN) { //收到对方的 FIN 握手
                if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt)) { //且包含有效 ACK
                    tcp_ack_now(pcb); //发送 ACK
                    tcp_pcb_purge(pcb); //清除该连接中的所有现存数据
                    TCP_RMV(&tcp_active_pcbs, pcb); //从 tcp_active_pcbs 链表中删除
                    pcb->state = TIME_WAIT; //置为 TIME_WAIT 状态
                    TCP_REG(&tcp_tw_pcbs, pcb); //加入 tcp_tw_pcbs 链表
                } else { //双方同时执行关闭操作
                    tcp_ack_now(pcb); //返回 ACK
                    pcb->state = CLOSING; //进入 CLOSING 状态
                }
            } else if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt)) { //只收到有效 ACK
                pcb->state = FIN_WAIT_2; //进入 FIN_WAIT_2 状态
            }
            break;
        case FIN_WAIT_2: //主动关闭，发送 FIN 握手且接收到 ACK 后处于该状态
            tcp_receive(pcb); //调用函数处理报文中的数据
            if (recv_flags & TF_GOT_FIN) { //收到对方的 FIN 握手
                tcp_ack_now(pcb); //发送 ACK
                tcp_pcb_purge(pcb); //清除该连接中的所有现存数据
                TCP_RMV(&tcp_active_pcbs, pcb); //从 tcp_active_pcbs 链表中删除
                pcb->state = TIME_WAIT; //置为 TIME_WAIT 状态
                TCP_REG(&tcp_tw_pcbs, pcb); //加入 tcp_tw_pcbs 链表
            }
            break;
        case CLOSING: //双方同时执行主动关闭，处于该状态
            tcp_receive(pcb); //调用函数处理报文中的数据
            if (flags & TCP_ACK && ackno == pcb->snd_nxt) { //收到有效 ACK
                tcp_pcb_purge(pcb); //清除该连接中的所有现存数据
                TCP_RMV(&tcp_active_pcbs, pcb); //从 tcp_active_pcbs 链表中删除
                pcb->state = TIME_WAIT; //置为 TIME_WAIT 状态
                TCP_REG(&tcp_tw_pcbs, pcb); //加入 tcp_tw_pcbs 链表
            }
            break;
        case LAST_ACK: //服务器在执行被动关闭时，发送完 FIN，等待 ACK 返回
            tcp_receive(pcb); //调用函数处理报文中的数据
            if (flags & TCP_ACK && ackno == pcb->snd_nxt) { //收到有效 ACK
            recv_flags |= TF_CLOSED; //设置 recv_flags 为 TF_CLOSED，由 tcp_input 函数
            } //对该控制块进行释放和清除工作
            break;
        default:
            break;
    }
    return ERR_OK;
}