[原创] KCP 源码解析（下）

ikcp_input

先从下层协议将数据读出来，并将对应的包头信息解析出来，根据不同的包头命令进入不同的处理逻辑。

int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
	IUINT32 prev_una = kcp->snd_una;
	IUINT32 maxack = 0, 	// 收到的这组包里最大的ack
			latest_ts = 0; // 以及最近的时间戳
	int flag = 0; // 接收到的数据包里有CMD_ACK则为1

	if (ikcp_canlog(kcp, IKCP_LOG_INPUT)) {
		ikcp_log(kcp, IKCP_LOG_INPUT, "[RI] %d bytes", (int)size);
	}

	if (data == NULL || (int)size < (int)IKCP_OVERHEAD) return -1;

	// 循环将底层收到的数据读取并解析
	while (1) {
		IUINT32 ts, sn, len, una, conv;
		IUINT16 wnd;
		IUINT8 cmd, frg;
		IKCPSEG *seg;

		// 数据报文长度小于 kcp 包头大小, 头部信息不完整, 退出
		if (size < (int)IKCP_OVERHEAD) break;

		// 取得所有包头信息
		data = ikcp_decode32u(data, &conv);
		if (conv != kcp->conv) return -1;

		data = ikcp_decode8u(data, &cmd);
		data = ikcp_decode8u(data, &frg);
		data = ikcp_decode16u(data, &wnd);
		data = ikcp_decode32u(data, &ts);
		data = ikcp_decode32u(data, &sn);
		data = ikcp_decode32u(data, &una);
		data = ikcp_decode32u(data, &len);

		// 减去包头大小
		size -= IKCP_OVERHEAD;

		// 数据报文长度小于包头指定的数据长度,数据被破坏,退出
		if ((long)size < (long)len || (int)len < 0) return -2;

		// 非法cmd, 退出
		if (cmd != IKCP_CMD_PUSH && cmd != IKCP_CMD_ACK &&
			cmd != IKCP_CMD_WASK && cmd != IKCP_CMD_WINS) 
			return -3;

		kcp->rmt_wnd = wnd;
		ikcp_parse_una(kcp, una);
		ikcp_shrink_buf(kcp);
		...
    }
}

先看一下最后两行的 ikcp_parse_una 和 ikcp_shrink_buf，kcp 收到对方发送的 una，说明 una 之前的包已经收到，那么接收方就可以将 snd_buf里的 una 之前的包删掉，ikcp_parse_una 就是做这个的。

// 从snd_buf(双向循环链表)中删除小于una的包
static void ikcp_parse_una(ikcpcb *kcp, IUINT32 una)
{
	struct IQUEUEHEAD *p, *next;
	for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = next) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		next = p->next;
		// 如果该sendbuf的序列号小于una, 则说明该包已经被确认, 从snd_buf中删除
		if (_itimediff(una, seg->sn) > 0) {
			iqueue_del(p); // 把seg里边的node指针断了
			ikcp_segment_delete(kcp, seg);
			kcp->nsnd_buf--;
		}	else {
			break;
		}
	}
}

上边的函数把 snd_buf 里的数据包删了，对应的 snd_una 也需要更新，ikcp_shrink_buf 就是更新 snd_una 的。

// 调用这个函数之前删除了一些被确认的包, 更新snd_una为当前发送缓冲里的最小序列号
static void ikcp_shrink_buf(ikcpcb *kcp)
{
	struct IQUEUEHEAD *p = kcp->snd_buf.next;
	if (p != &kcp->snd_buf) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node); // 发送缓冲区第一个数据包
		kcp->snd_una = seg->sn;
	}	else {
		kcp->snd_una = kcp->snd_nxt;
	}
}

前期工作处理完，然后根据不同的命令来处理包。

IKCP_CMD_ACK

当收到的命令为IKCP_CMD_ACK，说明该包是一个 ACK，需要将被ACK的包从 snd_buf 里删除，然后更新 snd_una，用的还是上边那两个函数。然后是更新maxack（这组包里最大的ack）和latest_ts（最近的时间戳），后边用于计算snd_buf里哪些包被跳过了（失序），决定是否快速重传。

int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
	...
	// 循环将底层收到的数据读取并解析
	while (1) {
		IUINT32 ts, sn, len, una, conv;
		IUINT16 wnd;
		IUINT8 cmd, frg;
		IKCPSEG *seg;
		...
		if (cmd == IKCP_CMD_ACK) {
			// ts为该数据包发送时间, current为当前时间(收到该数据包的ack), 两者之差为rtt
			if (_itimediff(kcp->current, ts) >= 0) {
                // 计算超时重传时间
				ikcp_update_ack(kcp, _itimediff(kcp->current, ts));
			}

			ikcp_parse_ack(kcp, sn);
			ikcp_shrink_buf(kcp);

			// 下边的代码就是更新maxack和latest_ts,
			if (flag == 0) { // 只有在解析第一个IKCP_CMD_ACK包进入这个分支
				flag = 1;
				maxack = sn;
				latest_ts = ts;
			}	else {
				if (_itimediff(sn, maxack) > 0) { // 这里不能用max函数，因为有序号回绕的问题
				#ifndef IKCP_FASTACK_CONSERVE
					maxack = sn;
					latest_ts = ts;
				#else
					if (_itimediff(ts, latest_ts) > 0) {
						maxack = sn;
						latest_ts = ts;
					}
				#endif
				}
			}
		}
		...
    }
}

// 计算超时重传时间, 和计网自顶向下3.5.3节的公式一样
static void ikcp_update_ack(ikcpcb *kcp, IINT32 rtt)
{
	// rtt：该数据包的往返时间
	// rx_srtt: 平滑的rtt,近8次rtt平均值
	// rx_rttval: 近4次rtt和srtt的平均差值，反应了rtt偏离srtt的程度
	// rx_rto: 重传超时时间
	IINT32 rto = 0;
	if (kcp->rx_srtt == 0) {
		kcp->rx_srtt = rtt;
		kcp->rx_rttval = rtt / 2;
	}	else {
		long delta = rtt - kcp->rx_srtt;
		if (delta < 0) delta = -delta;
		kcp->rx_rttval = (3 * kcp->rx_rttval + delta) / 4;
		kcp->rx_srtt = (7 * kcp->rx_srtt + rtt) / 8;
		if (kcp->rx_srtt < 1) kcp->rx_srtt = 1;
	}
	rto = kcp->rx_srtt + _imax_(kcp->interval, 4 * kcp->rx_rttval); // rx_srtt + 4*rx_rttval表示一种比较坏的情况
	kcp->rx_rto = _ibound_(kcp->rx_minrto, rto, IKCP_RTO_MAX);
}

IKCP_CMD_PUSH

当收到的命令为IKCP_CMD_ACK，说明是数据包。新建一个 IKCPSEG，将头信息和data 拷贝进去。然后调用 ikcp_ack_push 将该数据包加入 acklist，以便发送 ack 。

然后检查该 seg 是否已经接受过，如果接收过则忽略，如果没有接收过则将其加入 rcv_buf，之后将 rcv_buf 里连续序号的包转移到 rcv_que供上层读取，通过检查rcv_nxt即可判断数据包是否连续。这个检查过程是 ikcp_parse_data 实现的。

int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
	...
	// 循环将底层收到的数据读取并解析
	while (1) {
		IUINT32 ts, sn, len, una, conv;
		IUINT16 wnd;
		IUINT8 cmd, frg;
		IKCPSEG *seg;
		...
		else if (cmd == IKCP_CMD_PUSH) {
			if (_itimediff(sn, kcp->rcv_nxt + kcp->rcv_wnd) < 0) { // 判断是否超出(大于)接收窗口
				ikcp_ack_push(kcp, sn, ts);
				if (_itimediff(sn, kcp->rcv_nxt) >= 0) { // 判断是否超出(小于)接收窗口
					seg = ikcp_segment_new(kcp, len); // 新建一个数据包拷贝接收到的数据
					seg->conv = conv;
					seg->cmd = cmd;
					seg->frg = frg;
					seg->wnd = wnd;
					seg->ts = ts;
					seg->sn = sn;
					seg->una = una;
					seg->len = len;

					if (len > 0) {
						//    (to       , from, len)
						memcpy(seg->data, data, len); // 拷贝数据
					}
					// 检查newseg数据包，如果没有接受过，就将其放在接收缓存内，
                    // 并将缓存内连续的数据放到接受队列里，可供上层应用读取。
					ikcp_parse_data(kcp, seg);
				}
			}
		}
		...
    }
}

// 收到对方发送的sn号包，更新acklist，acknode的格式为(sn, ts), sn这个包的发出时间为ts
// 注意可能收到多个sn相同的包
static void ikcp_ack_push(ikcpcb *kcp, IUINT32 sn, IUINT32 ts)
{
	IUINT32 newsize = kcp->ackcount + 1;
	IUINT32 *ptr;

	// 申请更大的acklist空间
	if (newsize > kcp->ackblock) {
		IUINT32 *acklist;
		IUINT32 newblock;

		for (newblock = 8; newblock < newsize; newblock <<= 1); // 倍增的方式扩容
		acklist = (IUINT32*)ikcp_malloc(newblock * sizeof(IUINT32) * 2); // 申请newblock个acknode空间

		if (acklist == NULL) {
			assert(acklist != NULL);
			abort();
		}

		if (kcp->acklist != NULL) { // 将旧的acklist拷贝到新的acklist中
			IUINT32 x;
			for (x = 0; x < kcp->ackcount; x++) { // 从这里看出来每个acknode占用2个IUINT32
				acklist[x * 2 + 0] = kcp->acklist[x * 2 + 0];
				acklist[x * 2 + 1] = kcp->acklist[x * 2 + 1];
			}
			ikcp_free(kcp->acklist);
		}

		kcp->acklist = acklist;
		kcp->ackblock = newblock;
	}

	ptr = &kcp->acklist[kcp->ackcount * 2];
	ptr[0] = sn;
	ptr[1] = ts;
	kcp->ackcount++;
}

// 检查newseg数据包，如果没有接受过，就将其放在接收缓存内，并将缓存内连续的数据放到接受队列里，可供上层应用读取。
void ikcp_parse_data(ikcpcb *kcp, IKCPSEG *newseg)
{
	struct IQUEUEHEAD *p, *prev;
	IUINT32 sn = newseg->sn;
	int repeat = 0;
	
	// 新数据包在接收窗口之外, 直接丢弃
	if (_itimediff(sn, kcp->rcv_nxt + kcp->rcv_wnd) >= 0 || 
		_itimediff(sn, kcp->rcv_nxt) < 0) {
		ikcp_segment_delete(kcp, newseg);
		return;
	}

	// 判断是否接受过sn包
	for (p = kcp->rcv_buf.prev; p != &kcp->rcv_buf; p = prev) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		prev = p->prev;
		if (seg->sn == sn) {
			repeat = 1;
			break;
		}
        // 当前包序号大于被检查的包，之后就不可能有 seg->sn 了，因为 rcv_buf 的链表 sn 是递增的。
		if (_itimediff(sn, seg->sn) > 0) {
			break;
		}
	}

	if (repeat == 0) { // 没有接受过
		iqueue_init(&newseg->node);
		iqueue_add(&newseg->node, p);
		kcp->nrcv_buf++;
	}	else {
		ikcp_segment_delete(kcp, newseg);
	}


	// 将收到的连续数据包从rcv_buf 转移到 rcv_queue 供上层应用读取
	while (! iqueue_is_empty(&kcp->rcv_buf)) {
		IKCPSEG *seg = iqueue_entry(kcp->rcv_buf.next, IKCPSEG, node);
        // 通过检查rcv_nxt即可判断数据包是否连续
		if (seg->sn == kcp->rcv_nxt && kcp->nrcv_que < kcp->rcv_wnd) { //数据包连续 且 rcv_queue 不满
			iqueue_del(&seg->node);
			kcp->nrcv_buf--;
			iqueue_add_tail(&seg->node, &kcp->rcv_queue);
			kcp->nrcv_que++;
			kcp->rcv_nxt++;
		}	else {
			break;
		}
	}
	...
}

IKCP_CMD_WASK

当收到的命令为 IKCP_CMD_WASK，说明对方想探测你的窗口大小。只需要在本地标记一下，等到发送的时候会检查这个标记然后发送窗口大小。

else if (cmd == IKCP_CMD_WASK) { // 发送方探测接收方的窗口大小
    // ready to send back IKCP_CMD_WINS in ikcp_flush
    // tell remote my window size
    kcp->probe |= IKCP_ASK_TELL;
}

IKCP_CMD_WINS

当收到的命令为 IKCP_CMD_WASK，说明对方回答了你的窗口探测，在这里不需要做处理。

检查失序（冗余）ACK

当收完数据包，KCP 会检查哪些数据包被跳过了，然后标记其被跳过的次数。不过有人会发现通过 maxack 去检查哪个数据包被跳过会不会有问题？因为小于 maxack 的包可能也收到了，但也要记录一次被跳过。答案是不会的，因为在收到IKCP_CMD_ACK的时候会调用ikcp_parse_ack; ikcp_shrink_buf ; 这两个函数，而这两个函数会把所有收到ack 的包从 snd_buf 删除掉，那么在ikcp_parse_fastack 中也就不会检查到这个包了。

int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
	...
	// 循环将底层收到的数据读取并解析
	while (1) {
		...
		if (cmd == IKCP_CMD_ACK)  ...
		else if(cmd == IKCP_CMD_PUSH)  ...
        else if(cmd == IKCP_CMD_WASK)  ...
        else if(cmd == IKCP_CMD_WINS)  ...
        else return -3;  
		...
    }
    // 只要收到了IKCP_CMD_PUSH，flag 就为 true
    if (flag != 0) {
		ikcp_parse_fastack(kcp, maxack, latest_ts);
	}
}

// 计算快速重传的参数fastack(发送缓存里的包被跳过的总次数,冗余ACK)
static void ikcp_parse_fastack(ikcpcb *kcp, IUINT32 sn, IUINT32 ts)
{
	struct IQUEUEHEAD *p, *next;

	if (_itimediff(sn, kcp->snd_una) < 0 || _itimediff(sn, kcp->snd_nxt) >= 0)
		return;

	// 统计maxack之前的有几个没有被ack包
	for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = next) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		next = p->next;
		if (_itimediff(sn, seg->sn) < 0) {
			break;
		}
		else if (sn != seg->sn) { // 被跳过一次
		#ifndef IKCP_FASTACK_CONSERVE
			seg->fastack++; // 该数据包被跳过一次
		#else
			if (_itimediff(ts, seg->ts) >= 0)
				seg->fastack++;
		#endif
		}
	}
}

计算拥塞窗口

上边的工作做完后，需要计算并更新拥塞窗口，

int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
	...
	/*  
		接收时，拥塞窗口增加
		拥塞窗口控制, 慢启动：每收到一个ACK，拥塞窗口就加1，一个RTT拥塞窗口会翻倍增长。 
		拥塞避免：每收到一个ACK，拥塞窗口就加1/cwnd, 一个RTT拥塞窗口加1
		下边发送时，拥塞窗口减少
	*/
	if (_itimediff(kcp->snd_una, prev_una) > 0) {
		if (kcp->cwnd < kcp->rmt_wnd) {
			IUINT32 mss = kcp->mss;
			if (kcp->cwnd < kcp->ssthresh) { // 拥塞窗口小于慢启动阈值，快速增加拥塞窗口
				kcp->cwnd++; // 慢启动
				kcp->incr += mss;
				// 达到阈值的时候 cwnd*mss = incr
			}	else { 	// 拥塞窗口大于慢启动阈值，拥塞避免模式
				if (kcp->incr < mss) kcp->incr = mss;
				// 经过计算，差不多是每个RTT增加一个mss, 间隔略小于一个RTT，也就是更快地增加拥塞窗口
				// incr = k*mss , 拥塞窗口等于floor(k)
				kcp->incr += (mss * mss) / kcp->incr + (mss / 16); 
				if ((kcp->cwnd + 1) * mss <= kcp->incr) {
				#if 1
					kcp->cwnd = (kcp->incr + mss - 1) / ((mss > 0)? mss : 1);
				#else
					kcp->cwnd++;
				#endif
				}
			}
			if (kcp->cwnd > kcp->rmt_wnd) {
				kcp->cwnd = kcp->rmt_wnd;
				kcp->incr = kcp->rmt_wnd * mss;
			}
		}
	}
}

ikcp_recv

ikcp_recv 是用户调用的接口，期待收到长度最多为 len 的消息。

int ikcp_recv(ikcpcb *kcp, char *buffer, int len)
{
	struct IQUEUEHEAD *p;
	int ispeek = (len < 0)? 1 : 0; // 如果为真，只把数据复制给用户，不从接收队列中删除数据
	int peeksize;
	int recover = 0;
	IKCPSEG *seg;
	assert(kcp);

	if (iqueue_is_empty(&kcp->rcv_queue))
		return -1;

	if (len < 0) len = -len;
	
	peeksize = ikcp_peeksize(kcp); // 查看用户消息大小，主要检查buffer大小能不能装下这个消息

	if (peeksize < 0) 
		return -2;
	
    // 用户的 buffer 不够装
	if (peeksize > len) 
		return -3;
	
	// 这里发现接收队列里数据太多，则标记一下，将会向对方发送一个窗口大小防止对面太快的发数据
	if (kcp->nrcv_que >= kcp->rcv_wnd)
		recover = 1;

	// 将一个数据包拷贝进用户 buffer
	for (len = 0, p = kcp->rcv_queue.next; p != &kcp->rcv_queue; ) {
		int fragment;
		seg = iqueue_entry(p, IKCPSEG, node);
		p = p->next;

		if (buffer) {
			memcpy(buffer, seg->data, seg->len);
			buffer += seg->len;
		}

		len += seg->len;
		fragment = seg->frg;

		if (ispeek == 0) {
			iqueue_del(&seg->node);
			ikcp_segment_delete(kcp, seg);
			kcp->nrcv_que--;
		}
		// 非字节流模式 ： 读到最后一段，已经组装出一个完整的上层数据包
		// 字节流模式：每个包的frg都为0，每次recv只会读到一个包
		// 也有可能遇不到fragment为0的包，消息的其他部分还在接收缓存或者网络中
		if (fragment == 0) 
			break;
	}

	assert(len == peeksize);

	// move available data from rcv_buf -> rcv_queue
	// ikcp_input里已经转移过一次了, 用户把数据读走后rcv_que变小了, 这里再转移一次
	while (! iqueue_is_empty(&kcp->rcv_buf)) {
		seg = iqueue_entry(kcp->rcv_buf.next, IKCPSEG, node);
		if (seg->sn == kcp->rcv_nxt && kcp->nrcv_que < kcp->rcv_wnd) {
			iqueue_del(&seg->node);
			kcp->nrcv_buf--;
			iqueue_add_tail(&seg->node, &kcp->rcv_queue);
			kcp->nrcv_que++;
			kcp->rcv_nxt++;
		}	else {
			break;
		}
	}

	// fast recover
	if (kcp->nrcv_que < kcp->rcv_wnd && recover) {
		// ready to send back IKCP_CMD_WINS in ikcp_flush
		// tell remote my window size
		kcp->probe |= IKCP_ASK_TELL;
	}

	return len;
}


// 返回消息的大小（应用层的一个数据包大小, 如果分段, 则要计算所有段的和），如果是流模式，返回一个KCP包的大小
int ikcp_peeksize(const ikcpcb *kcp)
{
	struct IQUEUEHEAD *p;
	IKCPSEG *seg;
	int length = 0;

	assert(kcp);

	if (iqueue_is_empty(&kcp->rcv_queue)) return -1;

	seg = iqueue_entry(kcp->rcv_queue.next, IKCPSEG, node);
	if (seg->frg == 0) return seg->len;
	
    // 如果接收队列里的数据不足一个包，返回-1
	if (kcp->nrcv_que < seg->frg + 1) return -1;

	for (p = kcp->rcv_queue.next; p != &kcp->rcv_queue; p = p->next) {
		seg = iqueue_entry(p, IKCPSEG, node);
		length += seg->len;
		if (seg->frg == 0) break;
	}

	return length;
}