TCP/IP详解V2（三）之TCP协议

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++;
}