TCP
TCP是一种面向连接的传输协议，为两端的应用程序提供可靠的端到端的数据流传输服务。
数据结构
struct tcphdr {
u_short th_sport; //源端口
u_short th_dport; //目的端口
tcp_seq th_seq; //数据序列号
tcp_seq th_ack; //确认序列号
u_char th_off:4, //TCP头部长度，以4字节计算
th_x2:4; /* (unused) */
u_char th_flags; //标志
#define TH_FIN 0x01 //发送方字节流结束标志
#define TH_SYN 0x02 //建立连接的同步标志
#define TH_RST 0x04 //连接复位
#define TH_PUSH 0x08 //接收方应该立刻将数据交给用户
#define TH_ACK 0x10 //确认序号
#define TH_URG 0x20 //紧急数据
u_short th_win; //窗口大小
u_short th_sum; //校验和=TCP header + data
u_short th_urp; //紧急数据的偏移量
};
struct tcpiphdr {
struct ipovly ti_i; /* overlaid ip structure */
struct tcphdr ti_t; /* tcp header */
};
struct ipovly {
caddr_t ih_next, ih_prev; /* for protocol sequence q's */
u_char ih_x1; /* (unused) */
u_char ih_pr; //协议域
short ih_len; //这个相当于IP头部，len = data Len + udp HeaderLen + ip header
struct in_addr ih_src; //源地址
struct in_addr ih_dst; //目标地址
};
TCP专用控制块：
struct tcpcb {
struct tcpiphdr *seg_next; //对乱序到达数据报进行排队
struct tcpiphdr *seg_prev;
short t_state; //TCP的状态
short t_timer[TCPT_NTIMERS]; //TCP用到的计数器，作为定时器使用，默认为4
short t_rxtshift; //当前的指数，用于指数退避，最大为12
short t_rxtcur; //当前的重传值
short t_dupacks; //重复的ACK计数
u_short t_maxseg; //MSS
char t_force; /* 1 if forcing out a byte */
u_short t_flags;
#define TF_ACKNOW 0x0001 //立即发送ACK
#define TF_DELACK 0x0002 //延迟发送ACK
#define TF_NODELAY 0x0004 //立即发送用户数据，不等待形成最大报文段（禁止Nagle算法）
#define TF_NOOPT 0x0008 //不使用TCP选项
#define TF_SENTFIN 0x0010 //FIN已发送
#define TF_REQ_SCALE 0x0020 /* have/will request window scaling */
#define TF_RCVD_SCALE 0x0040 /* other side has requested scaling */
#define TF_REQ_TSTMP 0x0080 /* have/will request timestamps */
#define TF_RCVD_TSTMP 0x0100 /* a timestamp was received in SYN */
#define TF_SACK_PERMIT 0x0200 /* other side said I could SACK */
struct tcpiphdr *t_template; //保存一个TCP/IP首部模板
struct inpcb *t_inpcb; //指向Internet PCB
/*
* The following fields are used as in the protocol specification.
* See RFC783, Dec. 1981, page 21.
*/
/* send sequence variables */
tcp_seq snd_una; //最早的未确认过的seq
tcp_seq snd_nxt; //下一个将要发送的seq
tcp_seq snd_up; //发送紧急数据的指针
tcp_seq snd_wl1; //用于记录最后接收的报文段的序号，用于更新发送窗口
tcp_seq snd_wl2; //用于记录最后接收的报文段的确认序号，用于更新发送窗口
tcp_seq iss; //初始化发送ISS number
u_long snd_wnd; //发送窗口大小
/* receive sequence variables */
u_long rcv_wnd; //接收窗口大小
tcp_seq rcv_nxt; //预计下一个接收的seq
tcp_seq rcv_up; //接收紧急数据的指针
tcp_seq irs; //初始化接收ISS number
/*
* Additional variables for this implementation.
*/
/* receive variables */
tcp_seq rcv_adv; //通告窗口最大值+1
/* retransmit variables */
tcp_seq snd_max; //最大发送序号
/* congestion control (for slow start, source quench, retransmit after loss) */
u_long snd_cwnd; //拥塞窗口
u_long snd_ssthresh; //慢启动门限
/*
* transmit timing stuff. See below for scale of srtt and rttvar.
* "Variance" is actually smoothed difference.
*/
short t_idle; //空闲时间
short t_rtt; //RTT
tcp_seq t_rtseq; //被定时计算RTT的序列号
short t_srtt; //平滑往返时间
short t_rttvar; //RTT方差
u_short t_rttmin; //允许的最小 的RTT
u_long max_sndwnd; //对端提供的最大的窗口
/* out-of-band data */
char t_oobflags; /* have some */
char t_iobc; /* input character */
#define TCPOOB_HAVEDATA 0x01
#define TCPOOB_HADDATA 0x02
short t_softerror; /* possible error not yet reported */
/* RFC 1323 variables */
u_char snd_scale; /* window scaling for send window */
u_char rcv_scale; /* window scaling for recv window */
u_char request_r_scale; /* pending window scaling */
u_char requested_s_scale;
u_long ts_recent; /* timestamp echo data */
u_long ts_recent_age; /* when last updated */
tcp_seq last_ack_sent;
/* TUBA stuff */
caddr_t t_tuba_pcb; /* next level down pcb for TCP over z */
};
TCP数据报图示：
TCP状态变迁图：
TCP的定时器
TCP为了每条连接维护了七个定时器，从三个角度描述：连接建立，数据传输以及连接终止
- 连接建立：
- 连接建立定时器：定时器在发送SYN报文段的时候启动，如果没有在75S内收到响应，连接建立终止。
- 数据传输：
- 重传定时器：定时器在数据发送时建立。如果定时器已经超时但依旧没有收到对端对数据的确定，TCP将重传数据。重传定时器的取值依赖于RTO（动态计算）。
- 延迟ACK定时器：定时器在TCP收到必须被确认的数据时，延迟ACK的发送，期待在等待期间有数据传输，即数据可以携带ACK一起发送。
- 持续定时器：定时器在对端窗口通知为0，阻止TCP发送数据时启动。在超时后向对端发送1字节的数据，判断对端的接收窗口是否打开。与重传定时器的值类似，超时的值依赖于动态计算的RTO。
- 保活定时器：定时器在应用进程设置了Keep-Alive时生效，如果连续的空闲时间超过了2小时，保活定时器向对端发送连续探测报文，强迫对端响应。
- 连接终止：
- FIN_WAIT_2定时器：主动关闭的一端需要这个定时器，防止对端一直不发送FIN，状态一直处于FIN_WAIT_2
- TIME_WAIT定时器：主动关闭的一端需要这个定时器，防止收到错误的报文段，影响新的连接。
因为其中有一些定时器是互斥的，不可能同时出现，比如说：连接建立定时器与保活定时器，FIN_WAIT_2定时器与TIME_WAIT定时器。因此，TCP使用4个500ms精度的计数器描述除了延迟ACK定时器除外的6个定时器。
而且，重传定时器和持续定时器都有最大值与最小值的限制，因为他们的取值都是给予测量的动态计算得到的，其他定时器都是常值。
定时器的取值范围：
重传定时器的计算
重传定时器与持续定时器依赖于连接上测算的RTT。TCP计算重传时限不仅需要测量RTT，还需要计算已平滑的RTT估计器（SRTT）以及已平滑的RTT平均方差估计器（RTTVAR）。
DELTA = RTT - SRTT //计算新测量的往返时间（RTT）与已经平滑的SRTT之间的差值
SRTT = SRTT + g × DELTA //g = 1/8，更新RTT
RTTVAL = RTTVAL + h × （|DELTA| - RTTVAR） //h=1/4，更新RTTVAL
RTO = SRTT + 4 × RTTVAR //更新计算RTO
tcp_canneltimers
- 功能A：进入TIME_WAIT状态时，tcp_input在设定2MSL定时器之前会将所有的定时器清零。
void
tcp_canceltimers(tp)
struct tcpcb *tp;
{
register int i;
for (i = 0; i < TCPT_NTIMERS; i++)
tp->t_timer[i] = 0;
}
tcp_fasttimo
- 功能A：每200ms调用一次，用于操作ACK延迟定时器操作
void
tcp_fasttimo()
{
register struct inpcb *inp;
register struct tcpcb *tp;
int s = splnet();
inp = tcb.inp_next; //获取TCP的Internet PCB
if (inp)
for (; inp != &tcb; inp = inp->inp_next)
if ((tp = (struct tcpcb *)inp->inp_ppcb) &&
(tp->t_flags & TF_DELACK)) { //如果TCP PCB存在，且DELAY已经置位
tp->t_flags &= ~TF_DELACK; //清楚DELAY标志
tp->t_flags |= TF_ACKNOW; //置位ACK标志
tcpstat.tcps_delack++; //记录全局变量
(void) tcp_output(tp); //立刻发送ACK以及数据
}
splx(s);
}
tcp_slowtimo
- 功能A：每500ms调用一次，用于操作其他六个定时器
void
tcp_slowtimo()
{
register struct inpcb *ip, *ipnxt;
register struct tcpcb *tp;
int s = splnet();
register int i;
tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl; //初始化为10min，这是TCP向对端发送报文后，用于等待的最长时间。FIN_WAIT_2定时器也使用了这个变量
/*
* Search through tcb's and update active timers.
*/
ip = tcb.inp_next; //如果TCP协议层没有合适的PCB存在，直接返回
if (ip == 0) {
splx(s);
return;
}
for (; ip != &tcb; ip = ipnxt) { //遍历协议层所有的PCB
ipnxt = ip->inp_next;
tp = intotcpcb(ip); //从Internet PCB获取TCP PCB
if (tp == 0) //如果TCP PCB为空，直接返回
continue;
for (i = 0; i < TCPT_NTIMERS; i++) { //遍历TIMERS，总共遍历四次
if (tp->t_timer[i] && --tp->t_timer[i] == 0) { //如果在某一次的遍历过程中发现有超时存在，调用相应的函数进行处理，注意倒数第二个参数，使用i标记是那个定时器超时了
(void) tcp_usrreq(tp->t_inpcb->inp_socket,
PRU_SLOWTIMO, (struct mbuf *)0,
(struct mbuf *)i, (struct mbuf *)0);
if (ipnxt->inp_prev != ip) //在返回之前检查这个Internet PCB是否存在（可能在某一次的操作之后，TCP放弃了连接，比如说2MSL超时等）
goto tpgone;
}
}
tp->t_idle++; //记录空闲时间，如果有数据报文到达，就会清理这个计数器。
if (tp->t_rtt) //增加RTT计数器
tp->t_rtt++;
tpgone:
;
}
tcp_iss += TCP_ISSINCR/PR_SLOWHZ; //递增ISS
tcp_now++; //递增时间
splx(s);
}
tcp_timers
- 功能A：处理超时请求
struct tcpcb *
tcp_timers(tp, timer)
register struct tcpcb *tp;
int timer;
{
register int rexmt;
switch (timer) {
case TCPT_2MSL: //使用这个变量实现了两个定时器：FIN_WAIT_2和2MSL
if (tp->t_state != TCPS_TIME_WAIT &&
tp->t_idle <= tcp_maxidle) //如果当前的状态处于FIN_WAIT_2期间，并且空闲时间小于10min，那么会再次将定时器设置为75s；
tp->t_timer[TCPT_2MSL] = tcp_keepintvl;
else //如果此时处于TIME_WAIT状态，定时器超时意味着TIME_WAIT定时器超期，直接关闭TCP PCB。或者空闲的时间>10min（处于FIN_WAIT_2），也会引发关闭
tp = tcp_close(tp);
break;
case TCPT_REXMT: //重传定时器超时
if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) { //如果重传的次数超过了12次，TCP将丢弃连接，直接退出
tp->t_rxtshift = TCP_MAXRXTSHIFT;
tcpstat.tcps_timeoutdrop++;
tp = tcp_drop(tp, tp->t_softerror ?
tp->t_softerror : ETIMEDOUT);
break;
}
tcpstat.tcps_rexmttimeo++; //修改全局变量
rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift]; //通过指数退避，计算新的RTO值
TCPT_RANGESET(tp->t_rxtcur, rexmt,
tp->t_rttmin, TCPTV_REXMTMAX);
tp->t_timer[TCPT_REXMT] = tp->t_rxtcur; //填充新的超时值
if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) { //如果报文段已经重传4次以上
in_losing(tp->t_inpcb); //释放缓存中的路由
tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT); //计算RTT方差
tp->t_srtt = 0; //并清除RTT估计器
}
tp->snd_nxt = tp->snd_una; //将即将发送的报文段位置调整为未被确认的位置
tp->t_rtt = 0; //将RTT置为0
{ //超时重传引发的拥塞避免。如果最后收到了对方发送的ACK，就进行慢启动
u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg; //先将窗口设置为（接收方的通告窗口和发送方的拥塞窗口中较小值的一半）
if (win < 2) //如果窗口小于2
win = 2; //将窗口置为2
tp->snd_cwnd = tp->t_maxseg; //将拥塞窗口设置为一个报文段
tp->snd_ssthresh = win * tp->t_maxseg; //将慢启动门限设置为WIN个报文段，最小为2
tp->t_dupacks = 0; //将重复的ACK计数置为0
}
(void) tcp_output(tp); //发送最早的未经过确认的报文段
break;
case TCPT_PERSIST: //如果持续定时器超时
tcpstat.tcps_persisttimeo++; //修改全局变量
tcp_setpersist(tp); //计算定时器的下一个超时值
tp->t_force = 1; //并强制定时器发送1字节的数据
(void) tcp_output(tp);
tp->t_force = 0;
break;
case TCPT_KEEP: //描述了两种定时器，keep-alive和SYN_SEND状态
tcpstat.tcps_keeptimeo++; //记录全局变量
if (tp->t_state < TCPS_ESTABLISHED) //如果在75s内没有成功的建立连接。连接建立定时器和重传定时器会保证对端在没有相应的时候重传SYN
goto dropit;
if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE &&
tp->t_state <= TCPS_CLOSE_WAIT) { //如果设置了Keep-Alive的选项并且状态<CLOSE_WAIT
if (tp->t_idle >= tcp_keepidle + tcp_maxidle) //如果空闲的时间超过了限制，就丢弃连接
goto dropit;
tcpstat.tcps_keepprobe++;
tcp_respond(tp, tp->t_template, (struct mbuf *)NULL,
tp->rcv_nxt, tp->snd_una - 1, 0); //否则话发送一个探测报文并重置计数器
tp->t_timer[TCPT_KEEP] = tcp_keepintvl;
} else
tp->t_timer[TCPT_KEEP] = tcp_keepidle;
break;
dropit:
tcpstat.tcps_keepdrops++; //从TCP PCBs的链表中移除这个TCP PCB，并返回连接超时的错误
tp = tcp_drop(tp, ETIMEDOUT);
break;
}
return (tp);
}
tcp_newtcpcb
- 功能A：新分配一个TCP PCB并完成初始化
struct tcpcb *
tcp_newtcpcb(inp)
struct inpcb *inp;
{
register struct tcpcb *tp;
tp = malloc(sizeof(*tp), M_PCB, M_NOWAIT); //分配一个TCP PCB
if (tp == NULL)
return ((struct tcpcb *)0);
bzero((char *) tp, sizeof(struct tcpcb));
tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp; //将两个指针都指向自身（转换为TCP/IP Header）
tp->t_maxseg = tcp_mssdflt; //设置MSS
tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
tp->t_inpcb = inp; //指向Internet PCB
tp->t_srtt = TCPTV_SRTTBASE; //将SRTT初始化为0
tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ << 2; //将RTTVAR初始化为3s
tp->t_rttmin = TCPTV_MIN; //将RTT_MIN初始化为500ms
TCPT_RANGESET(tp->t_rxtcur,
((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
TCPTV_MIN, TCPTV_REXMTMAX); //将RTO初始化为6s
tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT; //将cwnd和ssthresh初始化为1G
tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
inp->inp_ip.ip_ttl = ip_defttl; //初始化Internet PCB中的TLL
inp->inp_ppcb = (caddr_t)tp; //确定Internet PCB中的TCP PCB的指向
return (tp);
}
tcp_setpersist
- 功能A：持续定时器到期后调用这个函数，根据RTO的值计算下一次的超时时间
void
tcp_setpersist(tp)
register struct tcpcb *tp;
{
register t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1; //计算RTO
if (tp->t_timer[TCPT_REXMT]) //判断这个定时器是否超时
panic("tcp_output REXMT");
/*
* Start/restart persistance timer.
*/
TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
t * tcp_backoff[tp->t_rxtshift],
TCPTV_PERSMIN, TCPTV_PERSMAX); //根据指数退避设置下一次的超时时间
if (tp->t_rxtshift < TCP_MAXRXTSHIFT) //递增当前的指数
tp->t_rxtshift++;
}