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
连接时的各种状态,分别是:
新绑定的端口链表
,用于记录新绑定端口
的TCP控制块。监听链表
:用于记录处于监听状态
的TCP控制块 。活动状态链表
:用于记录处于其他(活动)状态
的TCP控制块。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点:
- 发送方的发送窗口并不总是和 接收方接收窗口一样大,因为有一定的时间滞后。
- 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报文段
:
- 如果收到的是
复位报文
或终止连接应答报文
,那么就释放pbuf,终止连接 - 如果是收到了
应答报文段
(发送数据后必须等待应答),那么就调用宏TCP_EVENT_SENT
(其实是一个sent的回调函数)去处理,并且更新窗口 - 如果报文段中包含有效的数据,就调用
TCP_EVENT_RECV
去处理它,此时将产生应答报文与更新接收窗口的操作 - 如果是收到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);
/* ··· */
/* 省略处理 */
/* ··· */
}
}