KCP一种基于非可靠传输的可靠传输协议（源码分析）

最新推荐文章于 2024-08-13 12:17:02 发布

zhaohad

最新推荐文章于 2024-08-13 12:17:02 发布

阅读量1k

点赞数

本文链接：https://blog.csdn.net/zhaohad/article/details/104795923

版权

序

KCP是一个非常简单的可做流控的可靠传输协议，他的实现很多地方都借鉴了TCP的协议实现。通过学习KCP源码，能够更加熟悉ACK、重传、流控等实现方法，对TCP的理解也能有很大帮助

1. KCP简介

KCP是一个快速可靠协议，底层通过不可靠数据传输，通过浪费带宽的代价来实现降低延迟的效果。纯算法实现的数据协议，可以通过任何形式（UDP、TCP等）发送数据，但其作用是提供低延迟、可靠、流控机制，加到TCP等已经提供相关功能的传输方法而言纯属画蛇添足。所以目前看来，基于UDP来实现KCP的应用是最为合适的一种方法。即拥有UDP简单、快速的传输效果，又能够提供可靠的传输机制。

具体的介绍可以移步：https://github.com/skywind3000/kcp，整个工程其实就两个文件，相对比较简单。

简单列举下KCP特性：

自定义RTO：可以设置选择不同的RTO时间计算方式
选择性重传：只重传丢失的数据段
快速重传：发现数据段丢失时，不等待RTO，直接发起数据段重传
UNA + ACK：收到UNA及ACK都会确认数据段，取消相应数据段重传
非延迟ACK：可以设置ACK是否延迟发送
流量控制：发送端及接收端分别设有发送窗口及接收窗口，同时存在阻塞窗口。当出现丢包或失序的情况时，减小阻塞窗口以控制发送方的流量。

后面会从源码的角度对以上特性一一分析来了解KCP的工作机制。

在后面的讨论中，都会使用UDP作为底层的传输方式。

2. 使用方法

使用方法非常简单，最简单的demo中，客户端 + 服务端代码不超过100行就能搞定。

2.1 客户端

客户端中需要先创建UDP的socket并定义UDP的数据包发送方法，然后初始化KCP。

客户端初始化逻辑：

static int m_fd;
static sockaddr_in server;
static ikcpcb *kcp;
 
 
int udp_output(const char *buf, int len, ikcpcb *kcp, void *user) {
    ::sendto(m_fd, buf, len, 0, (struct sockaddr *) &server, sizeof(server));
    return 0;
}
 
void initSocket() {
    static const std::string i_host = "127.0.0.1";
    static const int i_port = 1120;
 
    m_fd = ::socket(AF_INET, SOCK_DGRAM, 0));
    hostent* he = gethostbyname(i_host.c_str());
    char ip[32];
    inet_ntop(he->h_addrtype, he->h_addr, ip, sizeof(ip));
 
    int flags;
    flags = fcntl(m_fd, F_GETFL, NULL));
    fcntl(m_fd, F_SETFL, flags | O_NONBLOCK);
 
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    inet_aton(ip, &server.sin_addr);
    server.sin_port = htons(i_port);
}
 
 
void initKcp() {
    *kcp = ikcp_create(0x11223344, NULL);
    kcp->output = udp_output;
}

非常简单，不用多讲。注意倒数第二行：kcp->output = udp_output，这里给KCP定义了数据的传输方式

客户端收发逻辑：

char buff[2048];
struct sockaddr_in peer;
 
IUINT32 tLastSend = iclock();
const int TIME_SEND_INTERVAL = 3 * 1000;
int cntSend = 0;
while(1) {
    IUINT32 now = iclock();
    if (now - tLastSend > TIME_SEND_INTERVAL) {
        sprintf(buff, "send %d", ++cntSend);
        tLastSend = iclock();
        int res_send = ikcp_send(kcp, buff, strlen(buff) + 1);
        printf("send: <%s>, res:%d, strlen:%d\n", buff, res_send, strlen(buff));
    }
    ikcp_update(kcp, now);
 
    socklen_t len = sizeof(peer);
    ssize_t r_len = ::recvfrom(m_fd, buff, sizeof(buff), 0, (struct sockaddr*) &peer, &len);
    if (r_len > 0) {
        int res_input = ikcp_input(kcp, buff, r_len);
        int res_recv = ikcp_recv(kcp, buff, r_len);
        printf("receive: <%s>, res_input:%d, res_recv:%d, r_len:%d\n", buff, res_input, res_recv, r_len);
    }
}

这段代码的含义是每3秒向服务端发送一个字符串，并接收服务端传回的字符串。因为在初始化时设置了recv为非阻塞方式，所以，这里会一直循环不会停。

与普通UDP收发方式不同的是，发送数据只用了了ikcp_send方法；接受数据依然使用UDP的接受方式，但是在收到数据之后必须调用ikcp_input和ikcp_recv。

此外，在每次循环里都调用了ikcp_update，这个方法非常重要，需要不断循环调用。随所是需要不断调用，其实也没有必要每次循环都要调用这个方法，可以使用ikcp_check来获取下次调用ikcp_update方法的时间。

2.2 服务端

与客户端类似，先进行UDP的socket初始化和数据包发送方法，然后初始化KCP

服务端初始化逻辑：

static int m_fd = 0;
static ikcpcb *kcp;
 
int udp_output(const char *buf, int len, ikcpcb *kcp, void *user) {
    ::sendto(m_fd, buf, len, 0, (struct sockaddr*)&client, sizeof(client));
    return 0;
}
 
 
void initSocket() {
    m_fd = ::socket(AF_INET, SOCK_DGRAM, 0));
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(i_host.c_str());
    server.sin_port = htons(i_port);
 
 
    ::bind(m_fd, (struct sockaddr*)&server, sizeof(server));
 
 
    int flags;
    flags = fcntl(m_fd, F_GETFL, NULL));
    fcntl(m_fd, F_SETFL, flags | O_NONBLOCK);
}
 
 
void initKcp() {
    kcp = ikcp_create(0x11223344, NULL);
    kcp->output = udp_output;
}

与客户端类似，不解释了

服务端收发逻辑：

struct sockaddr_in client;
char buff[2048] = {0};
int cntSend = 0;
while (1) {
    socklen_t len = sizeof(client);
    ssize_t r_len = ::recvfrom(m_fd, buff, sizeof(buff), 0, (sockaddr *) &client, &len);
    if (r_len > 0) {
        int res_input = ikcp_input(kcp, buff, r_len);
        int res_recv = ikcp_recv(kcp, buff, r_len);
 
        if (res_recv > 0) {
            printf("receive: <%s>, res_input:%d, res_recv:%d\n", buff, res_input, res_recv);
            sprintf(buff, "back send: %d", ++cntSend);
            ikcp_send(kcp, buff, strlen(buff) + 1);
        }
    }
 
    ikcp_update(kcp, iclock());
}

与客户端类似，这段代码含义是一直等待接收数据，收到数据后变向客户端返回一个数据。

同样，发送数据使用ikcp_send，收到数据后需要调用ikcp_input和ikcp_recv，也需要不断调用ikcp_update。

比较简单，以上就完成了整个利用KCP的客户端服务端收发逻辑

3. 基本收发逻辑

下面来看下KCP最基本的收发逻辑

3.1 数据封装

简介中说过，KCP实际上是一个传输协议，他定义了一套自己的报文格式。

因为kcp有自己的一套报文封装格式，所以在上面使用的时候，要发送的数据是不能通过udp直接发送的，要通过调用ikcp_send来进行发送，发送前会对要发送的数据进行分组和封装。同理，udp收到的数据实际上也是不能直接用的，要通过ikcp_input、ikcp_recv进行解封装装、重组和其他一些控制逻辑才能拿到真实的发送数据。

我们先说一下这个封装体的各个字段的作用：

conv：保存了一次会话的ID，C-S两端要用同样的id进行通讯。可以直接理解为sesionid
cmd：数据报的控制指令类型，有4种：
1. IKCP_CMD_PUSH：表示该报文段是用户数据的推送
2. IKCP_CMD_ACK：表示该报文段是对PUSH报文段的确认
3. IKCP_CMD_WASK：表示该报文是询问对端的接收窗口大小
4. IKCP_CMD_WINS：与IKCP_CMD_WASK对应，表示该报文是通知对端自己的接收窗口大小
frg：数据分段序号，从大到小排列，最后一个分段序号为0。每个数据报有mtu（最大传输单元）和mss（最大报文长度的概念）。如果调用ikcp_send的数据超过了mss，那么他就会被分成两个报文段。frg就是表示了这两个报文段的序号。如果调用ikcp_send的数据没有超过mss，那么frg始终为0
wnd：对方的接收窗口大小。用于流量控制。
ts：数据报发送时的时钟
sn：数据报的序号，每发送一个数据报sn递增1。注意跟frg区别，frg是当用户要发送的数据太大时被分成两个数据报的序号，sn是所有发送的数据报的序号。
una：对端下一个要接收的数据报序号
len：后面data的数据长度，当cmd不是IKCP_CMD_PUSH时，len都为0

数据报头的最大大小是MTU，真实数据的最大大小是MSS，实际上MSS就是MTU - 24。这在初始化的代码中能够看到：

const IUINT32 IKCP_OVERHEAD = 24;
 
 
ikcpcb* ikcp_create(IUINT32 conv, void *user)
{
   ...
   kcp->mss = kcp->mtu - IKCP_OVERHEAD;
   ...
   return kcp;
}

对应到相应的代码中，封装有独立的方法：

//---------------------------------------------------------------------
// ikcp_encode_seg
//---------------------------------------------------------------------
static char *ikcp_encode_seg(char *ptr, const IKCPSEG *seg)
{
   ptr = ikcp_encode32u(ptr, seg->conv);
   ptr = ikcp_encode8u(ptr, (IUINT8)seg->cmd);
   ptr = ikcp_encode8u(ptr, (IUINT8)seg->frg);
   ptr = ikcp_encode16u(ptr, (IUINT16)seg->wnd);
   ptr = ikcp_encode32u(ptr, seg->ts);
   ptr = ikcp_encode32u(ptr, seg->sn);
   ptr = ikcp_encode32u(ptr, seg->una);
   ptr = ikcp_encode32u(ptr, seg->len);
   return ptr;
}
 
 
/* encode 32 bits unsigned int (lsb) */
static inline char *ikcp_encode32u(char *p, IUINT32 l)
{
#if IWORDS_BIG_ENDIAN
   *(unsigned char*)(p + 0) = (unsigned char)((l >>  0) & 0xff);
   *(unsigned char*)(p + 1) = (unsigned char)((l >>  8) & 0xff);
   *(unsigned char*)(p + 2) = (unsigned char)((l >> 16) & 0xff);
   *(unsigned char*)(p + 3) = (unsigned char)((l >> 24) & 0xff);
#else
   *(IUINT32*)p = l;
#endif
   p += 4;
   return p;
}

解封装是在ikcp_input里实现的，没有单独的方法：

int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   ...
   while (1) {
      IUINT32 ts, sn, len, una, conv;
      ...
      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);
      ...
      data += len;
      size -= len;
   }
 
   return 0;
}

每个数据报是由一个单独的结构体来维护的，这个结构体是一个双向链表：

struct IQUEUEHEAD {
   struct IQUEUEHEAD *next, *prev;
};
 
 
//=====================================================================
// SEGMENT
//=====================================================================
struct IKCPSEG
{
   struct IQUEUEHEAD node;
   IUINT32 conv;
   IUINT32 cmd;
   IUINT32 frg;
   IUINT32 wnd;
   IUINT32 ts;
   IUINT32 sn;
   IUINT32 una;
   IUINT32 len;
   IUINT32 resendts;
   IUINT32 rto;
   IUINT32 fastack;
   IUINT32 xmit;
   char data[1];
};

3.2 数据发送逻辑

先不要管流量控制、超时重传、丢包这些东西，这些会在下面讲到。我们只来讨论最基本的发送逻辑。

//---------------------------------------------------------------------
// user/upper level send, returns below zero for error
//---------------------------------------------------------------------
int ikcp_send(ikcpcb *kcp, const char *buffer, int len)
{
   IKCPSEG *seg;
   int count, i;
   ...
   if (len <= (int)kcp->mss) count = 1;
   else count = (len + kcp->mss - 1) / kcp->mss;
 
   if (count >= (int)IKCP_WND_RCV) return -2;
 
   if (count == 0) count = 1;
 
   // fragment
   for (i = 0; i < count; i++) {
      int size = len > (int)kcp->mss ? (int)kcp->mss : len;
      seg = ikcp_segment_new(kcp, size);
      assert(seg);
      if (seg == NULL) {
         return -2;
      }
      if (buffer && len > 0) {
         memcpy(seg->data, buffer, size);
      }
      seg->len = size;
      seg->frg = (kcp->stream == 0)? (count - i - 1) : 0;
      iqueue_init(&seg->node);
      iqueue_add_tail(&seg->node, &kcp->snd_queue);
      kcp->nsnd_que++;
      if (buffer) {
         buffer += size;
      }
      len -= size;
   }
 
   return 0;
}

前面说了，当你要发送数据的时候需要调用ikcp_send方法，他会对你的数据进行分组和封装。

count 是发送传入的数据需要使用的数据报个数。传如的数据可能很大，一个数据报可能装不下（前面说了最大数据报是mss），第9～14行就是来计算数据报的数量，分组的数据报序号被倒序写入frg里面（28行）。

19行创建了一个报文数据结构，25行将要发送的数据拷贝到数据结构里面，30行将数据报文添加到待发送队列队尾。

kcp->snd_queue是待发送队列，强调一下是“待发送队列”。是一个按找SN号排列的有序队列，31行的kcp->nsnd_que是待发送队列的长度。

看到这里ikcp_send其实已经完了，但是并没有实际发送数据，而只是将数据放到了待发送队列里面。

最关键的在ikcp_update里面：

//---------------------------------------------------------------------
// update state (call it repeatedly, every 10ms-100ms), or you can ask
// ikcp_check when to call it again (without ikcp_input/_send calling).
// 'current' - current timestamp in millisec.
//---------------------------------------------------------------------
void ikcp_update(ikcpcb *kcp, IUINT32 current)
{
   IINT32 slap;
 
   kcp->current = current;
   ...
   if (slap >= 0) {
      kcp->ts_flush += kcp->interval;
      if (_itimediff(kcp->current, kcp->ts_flush) >= 0) {
         kcp->ts_flush = kcp->current + kcp->interval;
      }
      ikcp_flush(kcp);
   }
}

current是当前的时钟变量。KCP将时钟的定义交给了使用者，使用者只要调用这个方法传入当前平台的系统时钟即可。

kcp->ts_flush是下次需要执行ikcp_flush的时间，kcp→interval表示执行ikcp_flush的时间间隔。

最最重要的部分是在ikcp_update的最后调用了ikcp_flush，ikcp_flush是真正去发送数据的方法。以上也说明了在主逻辑里面为什么要不断的调用ikcp_update方法，他为整个KCP的运行提供了时钟并调用flush清空待发送队列。

来看ikcp_flush：

//---------------------------------------------------------------------
// ikcp_flush
//---------------------------------------------------------------------
void ikcp_flush(ikcpcb *kcp)
{
   ...
   // calculate window size
   cwnd = _imin_(kcp->snd_wnd, kcp->rmt_wnd);
   if (kcp->nocwnd == 0) cwnd = _imin_(kcp->cwnd, cwnd);
 
   // move data from snd_queue to snd_buf
   while (_itimediff(kcp->snd_nxt, kcp->snd_una + cwnd) < 0) {
      IKCPSEG *newseg;
      if (iqueue_is_empty(&kcp->snd_queue)) break;
 
      newseg = iqueue_entry(kcp->snd_queue.next, IKCPSEG, node);
 
      iqueue_del(&newseg->node);
      iqueue_add_tail(&newseg->node, &kcp->snd_buf);
      kcp->nsnd_que--;
      kcp->nsnd_buf++;
 
      newseg->conv = kcp->conv;
      newseg->cmd = IKCP_CMD_PUSH;
      newseg->wnd = seg.wnd;
      newseg->ts = current;
      newseg->sn = kcp->snd_nxt++;
      newseg->una = kcp->rcv_nxt;
      newseg->resendts = current;
      newseg->rto = kcp->rx_rto;
      newseg->fastack = 0;
      newseg->xmit = 0;
   }
 
   // calculate resent
   resent = (kcp->fastresend > 0)? (IUINT32)kcp->fastresend : 0xffffffff;
   rtomin = (kcp->nodelay == 0)? (kcp->rx_rto >> 3) : 0;
 
   // flush data segments
   for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
      IKCPSEG *segment = iqueue_entry(p, IKCPSEG, node);
      int needsend = 0;
      if (segment->xmit == 0) {
         needsend = 1;
         segment->xmit++;
         segment->rto = kcp->rx_rto;
         segment->resendts = current + segment->rto + rtomin;
      }
      ...
 
      if (needsend) {
         int size, need;
         segment->ts = current;
         segment->wnd = seg.wnd;
         segment->una = kcp->rcv_nxt;
 
         size = (int)(ptr - buffer);
         need = IKCP_OVERHEAD + segment->len;
 
         if (size + need > (int)kcp->mtu) {
            ikcp_output(kcp, buffer, size);
            ptr = buffer;
         }
 
         ptr = ikcp_encode_seg(ptr, segment);
 
         if (segment->len > 0) {
            memcpy(ptr, segment->data, segment->len);
            ptr += segment->len;
         }
 
         if (segment->xmit >= kcp->dead_link) {
            kcp->state = -1;
         }
      }
   }
 
   // flash remain segments
   size = (int)(ptr - buffer);
   if (size > 0) {
      ikcp_output(kcp, buffer, size);
   }
   ...
}
 
// output segment
static int ikcp_output(ikcpcb *kcp, const void *data, int size)
{
   assert(kcp);
   assert(kcp->output);
   if (ikcp_canlog(kcp, IKCP_LOG_OUTPUT)) {
      ikcp_log(kcp, IKCP_LOG_OUTPUT, "[RO] %ld bytes", (long)size);
   }
   if (size == 0) return 0;
   return kcp->output((const char*)data, size, kcp, kcp->user);
}

第8行计算阻塞窗口的大小（后面流量控制再讨论）

第12行的循环意思是：当对端接收窗口允许的情况下，将待发送队列的数据报复制到kcp→snd_buf中，kcp→snd_buf表示已发送队列待确认队列，重复“已发送队列待确认队列”

第40行的循环表示：对所有的已发送待确认队列，如果是第一次发送（未重传），则构造真实的数据报到ptr中。ptr和buffer这两个也是很重要的变量，之前没讲。buffer是一个固定大小的内存数组，大小是MTU的3倍。ptr算是buffer的pc指针。ptr开始指向buffer，每写一些数据，ptr遍向后移动一些距离，ptr - buffer也就表示了已经写入buffer的数据大小。

第81行，将所有需要发送的数据发出去。61行也有同样的调用，意思是，如果buffer满了，先发送一批。在ikcp_output方法中，最终调用了kcp->output方法。可以回到最上面“客户端使用方法”代码中的第33行，他实际上就是调用了udp的接口将数据发出去。

还有一些变量需要补充一下：

第43行segment->xmit，表示该数据报被发送的次数，包括后面要说的重传在内，每发送一次这个变量自增1。

第47行segment->resendts表示如果该数据报未被确认时数据重传的时间kcp->rx_rto，是重传超时时间，后面会讨论，rtomin是重传延迟，可以通过ikcp的接口进行设置。

第55行的kcp->rcv_nxt，表示当前端下一个要接收的数据报的序号。他跟减少确认报文的策略有关，后面再讨论。

3.3 数据接收逻辑

前面有说，数据接收时数据是用udp的接口进行接收的。但是收到的数据是不能用的，因为他包含了KCP协议的报文头。需要执行ikcp_input、ikcp_recv将数据解开报文头，如果数据太大还要进行数据重组。那么先来看下ikcp_input的工作：

//---------------------------------------------------------------------
// input data
//---------------------------------------------------------------------
int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   IUINT32 una = kcp->snd_una;
   IUINT32 maxack = 0;
   int flag = 0;
 
   if (ikcp_canlog(kcp, IKCP_LOG_INPUT)) {
      ikcp_log(kcp, IKCP_LOG_INPUT, "[RI] %d bytes", size);
   }
 
   if (data == NULL || (int)size < (int)IKCP_OVERHEAD) return -1;
 
   while (1) {
      ...
      else if (cmd == IKCP_CMD_PUSH) {
         if (ikcp_canlog(kcp, IKCP_LOG_IN_DATA)) {
            ikcp_log(kcp, IKCP_LOG_IN_DATA,
               "input psh: sn=%lu ts=%lu", sn, ts);
         }
         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) {
                  memcpy(seg->data, data, len);
               }
 
               ikcp_parse_data(kcp, seg);
            }
         }
      }
      ...
   }
   ...
 
   return 0;
}

第16行，一个循环来对data进行解包，因为data可能包含不止一个数据报，所以用循环来执行。直到解完最后一个数据报跳出循环。

第18行，cmd就是数据报头的cmd字段（前面“数据解包”部分代码已经展示了是怎么拿到这个变量的），如果cmd是IKCP_CMD_PUSH，也就是用户发送的真实数据，那么会执行：

产生对这个数据报的ACK，并放到ACK队列。第24行：ikcp_ack_push(kcp, sn, ts);
创建数据报的数据结构，并放到队列（这里还不确定会放到哪个队列里面）。第26 ～ 40行

其他的：

_itimediff方法传入两个参数A，B，可以理解为A-B

第23行：判断收到的数据报是否小于接收窗口尾部，在则处理，不在丢弃数据报。kcp->rcv_nxt表示下一个要接收的数据报序号，可以理解为接收窗口头部。kcp->rcv_wnd表示接收窗口。

第25行：判断收到的数据报是否大于接收窗口头部，在则处理，不在丢弃。

要知道，因为涉及到丢包重传的机制，而且ACK包也有可能会出现丢包现象。所以很有可能会出现接收端已经正确接收了某个数据报，但是发送端没有收到这个数据报的ACK，所以发送端可能会重传一次，这种情况（当然这只是其中一种情况）可能就会出现接收端收到了小于接收窗口头部的包。这种情况就把收到的包直接丢掉。

第24行的ikcp_ack_push(kcp, sn, ts);暂且不讲，这里就先记住，收到的所有PUSH数据报都会产生一个ACK，并放到ACK队列中。

下面来看ikcp_parse_data。前面说，收到的数据会先放到队列里面，但是还不确定是那个队列。为什么不知道是那个队列，因为收到的这个数据报可能是后发送的数据报。因为网络链路或者丢包等原因，发送端是按序发送数据报，但是接收端不一定是按序收到数据报，如果接收端先收到了后面的数据报，那就先将他暂存起来。

KCP的接收有也有两个队列分别是：

rcv_buf：接收到的数据队列
rcv_queue：待返回给调用这的数据队列，后面称待反队列

//---------------------------------------------------------------------
// parse data
//---------------------------------------------------------------------
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;
   }
 
   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;
      }
      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);
   }
 
#if 0
   ikcp_qprint("rcvbuf", &kcp->rcv_buf);
   printf("rcv_nxt=%lu\n", kcp->rcv_nxt);
#endif
 
   // move available data from rcv_buf -> rcv_queue
   while (! iqueue_is_empty(&kcp->rcv_buf)) {
      IKCPSEG *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;
      }
   }
 
#if 0
   ikcp_qprint("queue", &kcp->rcv_queue);
   printf("rcv_nxt=%lu\n", kcp->rcv_nxt);
#endif
 
#if 1
// printf("snd(buf=%d, queue=%d)\n", kcp->nsnd_buf, kcp->nsnd_que);
// printf("rcv(buf=%d, queue=%d)\n", kcp->nrcv_buf, kcp->nrcv_que);
#endif
}

前面说过，KCP里面的队列基本都是按SN的有序队列，第16 ～ 26行就是把收到的数据报插入到rcv_buf队列中，并保证有序。

第42 ～ 53行中遍历所有rcv_buf队列中的数据报，如果数据报的SN（数据报序号）与下一个要接收的数据报序号相同则将数据报放入待反队列。再说一下各个变量的含义，kcp->rcv_nxt表示下一个要接收的数据报序号，也可以理解为接收窗口头部，kcp->nrcv_que表示待反队列中的数据报个数，kcp->rcv_wnd表示待反队列的窗口大小（就理解为待反队列的最大长度吧）。如果满足条件，就将数据报从rcv_buf转移到kcp->rcv_queue（都是按序的）。如果不满足条件跳出循环，此时rcv_buf可能还有一些数据报，因为可能会出现乱序到达的情况，乱序到达时由rcv_buf先暂失序的数据报。

第20行的repeat表示该数据报已经接收过了，因为可能网络的一些原因发送端没有收到该数据报的ACK，所以又重传了一次。如果有repeat在第28行丢弃他。

第10 ~ 14行也是判断数据报是否在接收窗口内，不在，丢弃他。不用担心未处理的数据报被丢弃，因为不会产生这种数据报的ACK，所以发送端会重传这些数据报。

下面到了最后一个步骤，将收到的所有数据返给调用者：

//---------------------------------------------------------------------
// user/upper level recv: returns size, returns below zero for EAGAIN
//---------------------------------------------------------------------
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);
 
   if (peeksize < 0)
      return -2;
 
   if (peeksize > len)
      return -3;
 
   if (kcp->nrcv_que >= kcp->rcv_wnd)
      recover = 1;
 
   // merge fragment
   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 (ikcp_canlog(kcp, IKCP_LOG_RECV)) {
         ikcp_log(kcp, IKCP_LOG_RECV, "recv sn=%lu", seg->sn);
      }
 
      if (ispeek == 0) {
         iqueue_del(&seg->node);
         ikcp_segment_delete(kcp, seg);
         kcp->nrcv_que--;
      }
 
      if (fragment == 0)
         break;
   }
 
   assert(len == peeksize);
   ...
   return len;
}

比较简单了，一个循环遍历待反队列，并将数据拷贝到调用者传入的buffer里面。还是要注意，数据大的时候是要分组的，而且分组数（frg）在数据报中是倒序排放的，所以到每个frg为0的时候就跳出循环。

如果待反队列里面的数据比较多，看似是要不断的调用ikcp_recv以获取数据。

4. 重传

4.1 RTT、RTO计算

保证可靠传输的很重要一个策略就是超时重传，超时重传的一个关键问题是如何计算RTT及RTO。

RTO（Retransmission TimeOut）：重传超时时间，即从数据发送时刻起，超过这个时间将进行数据报重传。

RTT（Round Trip Time）：往返时间，即数据报发送到收到确认的时差。

在“数据封装”中提到过，数据报的第8 ～ 11字节为ts字段，ts表示数据报发送时刻的时钟，他在计算RTT中起到了关键作用。

先看下计算RTT的时机：

//---------------------------------------------------------------------
// input data
//---------------------------------------------------------------------
int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   ...
   while (1) {
      ...
      if (cmd == IKCP_CMD_ACK) {
         if (_itimediff(kcp->current, ts) >= 0) {
            ikcp_update_ack(kcp, _itimediff(kcp->current, ts));
         }
         ikcp_parse_ack(kcp, sn);
         ikcp_shrink_buf(kcp);
         if (flag == 0) {
            flag = 1;
            maxack = sn;
         }  else {
            if (_itimediff(sn, maxack) > 0) {
               maxack = sn;
            }
         }
         if (ikcp_canlog(kcp, IKCP_LOG_IN_ACK)) {
            ikcp_log(kcp, IKCP_LOG_IN_DATA,
               "input ack: sn=%lu rtt=%ld rto=%ld", sn,
               (long)_itimediff(kcp->current, ts),
               (long)kcp->rx_rto);
         }
      }
      ...
   }
   ...
   return 0;
}

如果收到的数据报为ACK数据报，那么就会在第11行执行ikcp_update_ack，这个方法就是计算RTT、RTO的。ts是数据报中的ts字段，表示数据报发送是的时钟，不过注意ts不是ACK这个数据报发送的时钟，而是ACK要确认的PUSH数据报发送的时钟。

来看下如何计算RTT和RTO的：

//---------------------------------------------------------------------
// parse ack
//---------------------------------------------------------------------
static void ikcp_update_ack(ikcpcb *kcp, IINT32 rtt)
{
   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);
   kcp->rx_rto = _ibound_(kcp->rx_minrto, rto, IKCP_RTO_MAX);
}

有兴趣的同学可以去翻阅《计算机网络自顶向下方法原书第七版》中文版中的第158页“3.5.3 往返时间的估计与超时”。这里的计算方法和书上讲的计算方法一模一样。

kcp->rx_srtt就是当前计算出的RTT时间。

kcp->rx_rttval是当前RTT偏差。

kcp->rx_rto就是之后用来重传的超时时间（在普通模式下，这个超时时间还会加一个延迟，在后面“非延迟ACK”中会有提到）。

RTT的计算，就是纯数学计算，真要探究为啥这么算可能要去研究其数学模型了。

4.2 选择性重传

后面“处理ACK”的部分会讨论

4.3 快速重传

快速重传即不等待超时，当探测到达丢包的可能行达到一定程度之后，直接对未确认的数据报机型重传。KCP中设置kcp->fastresend可以启动快速重传模式。

//---------------------------------------------------------------------
// input data
//---------------------------------------------------------------------
int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   ...
   while (1) {
      ...
      if (cmd == IKCP_CMD_ACK) {
         if (_itimediff(kcp->current, ts) >= 0) {
            ikcp_update_ack(kcp, _itimediff(kcp->current, ts));
         }
         ikcp_parse_ack(kcp, sn);
         ikcp_shrink_buf(kcp);
         if (flag == 0) {
            flag = 1;
            maxack = sn;
         }  else {
            if (_itimediff(sn, maxack) > 0) {
               maxack = sn;
            }
         }
         if (ikcp_canlog(kcp, IKCP_LOG_IN_ACK)) {
            ikcp_log(kcp, IKCP_LOG_IN_DATA,
               "input ack: sn=%lu rtt=%ld rto=%ld", sn,
               (long)_itimediff(kcp->current, ts),
               (long)kcp->rx_rto);
         }
      }
      ...
   }
 
   if (flag != 0) {
      ikcp_parse_fastack(kcp, maxack);
   }
   ...
   return 0;
}
 
 
static void ikcp_parse_fastack(ikcpcb *kcp, IUINT32 sn)
{
   struct IQUEUEHEAD *p, *next;
 
   if (_itimediff(sn, kcp->snd_una) < 0 || _itimediff(sn, kcp->snd_nxt) >= 0)
      return;
 
   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) {
         seg->fastack++;
      }
   }
}

发送端收到ACK数据报后还会去检查失序数据报（第16行和第33行）

在不断调用ikcp_input的过程中，seg->fastack自增，该值表示了数据报失序到达的次数。

//---------------------------------------------------------------------
// ikcp_flush
//---------------------------------------------------------------------
void ikcp_flush(ikcpcb *kcp)
{
   ...
   // calculate resent
   resent = (kcp->fastresend > 0)? (IUINT32)kcp->fastresend : 0xffffffff;
   rtomin = (kcp->nodelay == 0)? (kcp->rx_rto >> 3) : 0;
 
   // flush data segments
   for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
      IKCPSEG *segment = iqueue_entry(p, IKCPSEG, node);
      ...
      else if (segment->fastack >= resent) {
         needsend = 1;
         segment->xmit++;
         segment->fastack = 0;
         segment->resendts = current + segment->rto;
         change++;
      }
      ...
   }
   ...
}

在ikcp_flush中，如果设置了快速重传失序数（第八行的kcp->fastresend），一旦超过这个失序数，失序的数据报便会不等待超时时间，直接执行重传操作。

5. UNA + ACK

5.1 ACK

5.1.1 产生ACK

在“数据接收逻辑”的代码第24行，调用了ikcp_ack_push。每当收到PUSH数据报时，都会通过这个方法产生数据报的ACK，并放到ACK队列中

//---------------------------------------------------------------------
// ack append
//---------------------------------------------------------------------
static void ikcp_ack_push(ikcpcb *kcp, IUINT32 sn, IUINT32 ts)
{
   size_t newsize = kcp->ackcount + 1;
   IUINT32 *ptr;
 
   if (newsize > kcp->ackblock) {
      IUINT32 *acklist;
      size_t newblock;
 
      for (newblock = 8; newblock < newsize; newblock <<= 1);
      acklist = (IUINT32*)ikcp_malloc(newblock * sizeof(IUINT32) * 2);
 
      if (acklist == NULL) {
         assert(acklist != NULL);
         abort();
      }
 
      if (kcp->acklist != NULL) {
         size_t x;
         for (x = 0; x < kcp->ackcount; x++) {
            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++;
}

kcp->ackcount是还没发送的ACK的数量，kcp→ackblock当前ACK队列的容量。只不过ACK队列是用一个数组来表示的，这个数组的 X * 2 + 0位是数据报的序号，X * 2 + 1位是收到的PUSH数据报发送时的时钟。强调是”收到的PUSH数据报发送时的时钟”，这个时钟就厉害了，他是计算RTT和RTO的重要参数，后面再讨论。

现在且记下会在ACK队列里面产生一个ACK，后面再讨论ACK的发送。

5.1.2 发送ACK

前面已经介绍了，接收端收到了PUSH的数据报之后会产生ACK放到ACK队列里面，kcp->acklist是以数组形式表示的ACK队列，kcp->ackcount表示了ACK队列中的元素个数。下面我们就来看下ACK是如何发送的。

位置还是在ikcp_flush里面，前面“数据发送逻辑”里面也介绍过，ikcp_flush是由ikcp_update调用的，ikcp_update需要不断的被调用这调用以便更新时钟以及清空发送队列。

//---------------------------------------------------------------------
// ikcp_flush
//---------------------------------------------------------------------
void ikcp_flush(ikcpcb *kcp)
{
   IUINT32 current = kcp->current;
   char *buffer = kcp->buffer;
   char *ptr = buffer;
   int count, size, i;
   IUINT32 resent, cwnd;
   IUINT32 rtomin;
   struct IQUEUEHEAD *p;
   int change = 0;
   int lost = 0;
   IKCPSEG seg;
 
   // 'ikcp_update' haven't been called.
   if (kcp->updated == 0) return;
 
   seg.conv = kcp->conv;
   seg.cmd = IKCP_CMD_ACK;
   seg.frg = 0;
   seg.wnd = ikcp_wnd_unused(kcp);
   seg.una = kcp->rcv_nxt;
   seg.len = 0;
   seg.sn = 0;
   seg.ts = 0;
 
   // flush acknowledges
   count = kcp->ackcount;
   for (i = 0; i < count; i++) {
      size = (int)(ptr - buffer);
      if (size + (int)IKCP_OVERHEAD > (int)kcp->mtu) {
         ikcp_output(kcp, buffer, size);
         ptr = buffer;
      }
      ikcp_ack_get(kcp, i, &seg.sn, &seg.ts);
      ptr = ikcp_encode_seg(ptr, &seg);
   }
 
   kcp->ackcount = 0;
   ...
   // flash remain segments
   size = (int)(ptr - buffer);
   if (size > 0) {
      ikcp_output(kcp, buffer, size);
   }
   ...
}
 
 
static void ikcp_ack_get(const ikcpcb *kcp, int p, IUINT32 *sn, IUINT32 *ts)
{
   if (sn) sn[0] = kcp->acklist[p * 2 + 0];
   if (ts) ts[0] = kcp->acklist[p * 2 + 1];
}

比较简单了，不再介绍。

5.1.3 处理ACK

//---------------------------------------------------------------------
// input data
//---------------------------------------------------------------------
int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   ...
   while (1) {
      ...
      if (cmd == IKCP_CMD_ACK) {
         if (_itimediff(kcp->current, ts) >= 0) {
            ikcp_update_ack(kcp, _itimediff(kcp->current, ts));
         }
         ikcp_parse_ack(kcp, sn);
         ikcp_shrink_buf(kcp);
         if (flag == 0) {
            flag = 1;
            maxack = sn;
         }  else {
            if (_itimediff(sn, maxack) > 0) {
               maxack = sn;
            }
         }
         if (ikcp_canlog(kcp, IKCP_LOG_IN_ACK)) {
            ikcp_log(kcp, IKCP_LOG_IN_DATA,
               "input ack: sn=%lu rtt=%ld rto=%ld", sn,
               (long)_itimediff(kcp->current, ts),
               (long)kcp->rx_rto);
         }
      }
      ...
   }
   ...
   return 0;
}
 
 
static void ikcp_parse_ack(ikcpcb *kcp, IUINT32 sn)
{
   struct IQUEUEHEAD *p, *next;
 
   if (_itimediff(sn, kcp->snd_una) < 0 || _itimediff(sn, kcp->snd_nxt) >= 0)
      return;
 
   for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = next) {
      IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
      next = p->next;
      if (sn == seg->sn) {
         iqueue_del(p);
         ikcp_segment_delete(kcp, seg);
         kcp->nsnd_buf--;
         break;
      }
      if (_itimediff(sn, seg->sn) < 0) {
         break;
      }
   }
}
 
 
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_input方法中，当收到ACK后第18行调用ikcp_parse_ack处理ACK。

第37 ～ 57行展示了ikcp_parse_ack处理ACK的过程，比较简单，就是找到ACK所代表数据报序号，将已发送待确认队列数据报删掉。

处理完ACK后，可以看到第19行调用了ikcp_shrink_buf。第60 ～ 69行展示了ikcp_shrink_buf的过程。他是将una向后移动，即发送窗口头部向后移动。

如何实现的快速重传：

结合“数据发送逻辑”中讨论的数据报发送的过程。所有的已发送但是还没有确认的数据报会被放到kcp->snd_buf这个队列当中，当收到ACK时，会在kcp->snd_buf队列中删掉已经确认过得数据报，然后在通过ikcp_shrink_buf方法移动发送窗口。同样“数据接收逻辑”中也讨论过，收到的数据报会在接收端先放到kcp->rcv_buf队列中，直到收到完整且连续的数据报后才会转移到kcp->rcv_queue并传给调用者。当接收端出现失序或丢包情况时，发送端可能会先收到后面数据报的ACK，发送端就会先把kcp->snd_buf中后面的数据报删掉，不再重新发送。如果前面的数据报接收ACK超时，会只重发前面未收到ACK的数据报。当发送窗口前端连续的数据报都收到ACK后，便会向后移动发送窗口。这种逻辑就是前面说过的“选择性重传”，与之对应的是回退式的重传。

5.2 UNA

KCP在使用ACK确认的同时，也使用了捎带式的UNA确认。大概思路是：在收发的数据报中添加了UNA字段，该字段表示的是对端下一个要接收的数据报序号。这个字段也表示，所有序号小于UNA的数据报已经被对端正确接收。那么也就是说，所有未收到ACK的数据报如果SN小于UNA，都可以直接丢弃了，因为这些数据报已经被对端正确接收，不用再等待ACK进行重传了。

还是来看ikcp_input方法：

//---------------------------------------------------------------------
// input data
//---------------------------------------------------------------------
int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   IUINT32 una = kcp->snd_una;
   IUINT32 maxack = 0;
   int flag = 0;
 
   if (ikcp_canlog(kcp, IKCP_LOG_INPUT)) {
      ikcp_log(kcp, IKCP_LOG_INPUT, "[RI] %d bytes", size);
   }
 
   if (data == NULL || (int)size < (int)IKCP_OVERHEAD) return -1;
 
   while (1) {
      ...
      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);
      ...
      ikcp_parse_una(kcp, una);
      ikcp_shrink_buf(kcp);
      ...
   }
   ...
   return 0;
}

第29行ikcp_parse_una(kcp, una);就是丢弃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;
      if (_itimediff(una, seg->sn) > 0) {
         iqueue_del(p);
         ikcp_segment_delete(kcp, seg);
         kcp->nsnd_buf--;
      }  else {
         break;
      }
   }
}

之后执行ikcp_shrink_buf，前面“处理ACK”部分也已经提到过了，是为了更新本地的una将发送窗口头部向后移动。

5.3 非延迟ACK

这是一个设置项，在kcp->nodelay中设置：

//---------------------------------------------------------------------
// ikcp_flush
//---------------------------------------------------------------------
void ikcp_flush(ikcpcb *kcp)
{
   ...
   // calculate resent
   resent = (kcp->fastresend > 0)? (IUINT32)kcp->fastresend : 0xffffffff;
   rtomin = (kcp->nodelay == 0)? (kcp->rx_rto >> 3) : 0;
 
   // flush data segments
   for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
      IKCPSEG *segment = iqueue_entry(p, IKCPSEG, node);
      int needsend = 0;
      if (segment->xmit == 0) {
         needsend = 1;
         segment->xmit++;
         segment->rto = kcp->rx_rto;
         segment->resendts = current + segment->rto + rtomin;
      }
      else if (_itimediff(current, segment->resendts) >= 0) {
         needsend = 1;
         segment->xmit++;
         kcp->xmit++;
         if (kcp->nodelay == 0) {
            segment->rto += kcp->rx_rto;
         }  else {
            segment->rto += kcp->rx_rto / 2;
         }
         segment->resendts = current + segment->rto;
         lost = 1;
      }
      else if (segment->fastack >= resent) {
         needsend = 1;
         segment->xmit++;
         segment->fastack = 0;
         segment->resendts = current + segment->rto;
         change++;
      }
      ...
   }
   ...
}

如上代码segment->resendts表示的是如果为收到ACK，数据报重传的时间点。

第9行，如果设置了无延迟模式，即kcp->nodelay不是0，那么rtomin为0。rtomin实际上是代表了超时重传的延迟时间，这个数值会影响后面的重传时间。

第19行，如果是第一次发送数据报，超时时间直接设置到RTO之后并加上rtomin的时间点，非延迟模式下rtomin为0，超时时间就是RTO时间。

第25行，如果是已经出现重传的数据报，非延迟模式下，下次重传的时间是RTO/2。重传延迟是普通模式下的1/2。

其实可以看到，但出现数据报重传后非延迟模式下减小了数据重传的超时时间，网络中可能会出现多个重传的数据报，是一种用带宽换速度的策略。具体效果只能看实测数据，至少其github上写的是有效的。

6. 流量控制

6.1 阻塞窗口

kcp->cwnd这个变量记录了当前发送的窗口大小，其实这个就是我们所指的阻塞窗口。他是用来调节发送端的发送速度的。

//---------------------------------------------------------------------
// ikcp_flush
//---------------------------------------------------------------------
void ikcp_flush(ikcpcb *kcp)
{
   ...
   seg.conv = kcp->conv;
   seg.cmd = IKCP_CMD_ACK;
   seg.frg = 0;
   seg.wnd = ikcp_wnd_unused(kcp);
   seg.una = kcp->rcv_nxt;
   seg.len = 0;
   seg.sn = 0;
   seg.ts = 0;
   ...
   // calculate window size
   cwnd = _imin_(kcp->snd_wnd, kcp->rmt_wnd);
   if (kcp->nocwnd == 0) cwnd = _imin_(kcp->cwnd, cwnd);
 
   // move data from snd_queue to snd_buf
   while (_itimediff(kcp->snd_nxt, kcp->snd_una + cwnd) < 0) {
      IKCPSEG *newseg;
      if (iqueue_is_empty(&kcp->snd_queue)) break;
 
      newseg = iqueue_entry(kcp->snd_queue.next, IKCPSEG, node);
 
      iqueue_del(&newseg->node);
      iqueue_add_tail(&newseg->node, &kcp->snd_buf);
      kcp->nsnd_que--;
      kcp->nsnd_buf++;
 
      newseg->conv = kcp->conv;
      newseg->cmd = IKCP_CMD_PUSH;
      newseg->wnd = seg.wnd;
      newseg->ts = current;
      newseg->sn = kcp->snd_nxt++;
      newseg->una = kcp->rcv_nxt;
      newseg->resendts = current;
      newseg->rto = kcp->rx_rto;
      newseg->fastack = 0;
      newseg->xmit = 0;
   }
 
   // calculate resent
   resent = (kcp->fastresend > 0)? (IUINT32)kcp->fastresend : 0xffffffff;
   rtomin = (kcp->nodelay == 0)? (kcp->rx_rto >> 3) : 0;
 
   // flush data segments
   for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
      IKCPSEG *segment = iqueue_entry(p, IKCPSEG, node);
      int needsend = 0;
      if (segment->xmit == 0) {
         needsend = 1;
         segment->xmit++;
         segment->rto = kcp->rx_rto;
         segment->resendts = current + segment->rto + rtomin;
      }
      else if (_itimediff(current, segment->resendts) >= 0) {
         needsend = 1;
         segment->xmit++;
         kcp->xmit++;
         if (kcp->nodelay == 0) {
            segment->rto += kcp->rx_rto;
         }  else {
            segment->rto += kcp->rx_rto / 2;
         }
         segment->resendts = current + segment->rto;
         lost = 1;
      }
      else if (segment->fastack >= resent) {
         needsend = 1;
         segment->xmit++;
         segment->fastack = 0;
         segment->resendts = current + segment->rto;
         change++;
      }
 
      if (needsend) {
         int size, need;
         segment->ts = current;
         segment->wnd = seg.wnd;
         segment->una = kcp->rcv_nxt;
 
         size = (int)(ptr - buffer);
         need = IKCP_OVERHEAD + segment->len;
 
         if (size + need > (int)kcp->mtu) {
            ikcp_output(kcp, buffer, size);
            ptr = buffer;
         }
 
         ptr = ikcp_encode_seg(ptr, segment);
 
         if (segment->len > 0) {
            memcpy(ptr, segment->data, segment->len);
            ptr += segment->len;
         }
 
         if (segment->xmit >= kcp->dead_link) {
            kcp->state = -1;
         }
      }
   }
 
   // flash remain segments
   size = (int)(ptr - buffer);
   if (size > 0) {
      ikcp_output(kcp, buffer, size);
   }
 
   // update ssthresh
   if (change) {
      IUINT32 inflight = kcp->snd_nxt - kcp->snd_una;
      kcp->ssthresh = inflight / 2;
      if (kcp->ssthresh < IKCP_THRESH_MIN)
         kcp->ssthresh = IKCP_THRESH_MIN;
      kcp->cwnd = kcp->ssthresh + resent;
      kcp->incr = kcp->cwnd * kcp->mss;
   }
 
   if (lost) {
      kcp->ssthresh = cwnd / 2;
      if (kcp->ssthresh < IKCP_THRESH_MIN)
         kcp->ssthresh = IKCP_THRESH_MIN;
      kcp->cwnd = 1;
      kcp->incr = kcp->mss;
   }
 
   if (kcp->cwnd < 1) {
      kcp->cwnd = 1;
      kcp->incr = kcp->mss;
   }
}
 
 
static int ikcp_wnd_unused(const ikcpcb *kcp)
{
   if (kcp->nrcv_que < kcp->rcv_wnd) {
      return kcp->rcv_wnd - kcp->nrcv_que;
   }
   return 0;
}

第68行的lost表示了丢包的个数。

第75行的change表示了进行快速重传的包的个数。

第112 ~ 133行中展示了，一旦出现丢包或者有快速重传的现象存在，那么就要逐渐的减小kcp->cwnd发送窗口大小。

代码中在第21行将kcp->snd_queue的数据报放入kcp->snd_buf时，通过cwnd来限制转移的数据报数量。通过控制转移入kcp→snd_buf的数据报数量，来控制整个发送端的发送。

//---------------------------------------------------------------------
// input data
//---------------------------------------------------------------------
int ikcp_input(ikcpcb *kcp, const char *data, long size)
{
   ...
   if (_itimediff(kcp->snd_una, una) > 0) {
      if (kcp->cwnd < kcp->rmt_wnd) {
         IUINT32 mss = kcp->mss;
         if (kcp->cwnd < kcp->ssthresh) {
            kcp->cwnd++;
            kcp->incr += mss;
         }  else {
            if (kcp->incr < mss) kcp->incr = mss;
            kcp->incr += (mss * mss) / kcp->incr + (mss / 16);
            if ((kcp->cwnd + 1) * mss <= kcp->incr) {
               kcp->cwnd++;
            }
         }
         if (kcp->cwnd > kcp->rmt_wnd) {
            kcp->cwnd = kcp->rmt_wnd;
            kcp->incr = kcp->rmt_wnd * mss;
         }
      }
   }
 
   return 0;
}

kcp->rmt_wnd表示对端的接收窗口大小，这个数值是怎么来的？可以看上面flush方法里面的第10行，在每次flush时都会计算自己端的接收窗口，并通过数据报传到对端。具体的计算方法在上面代码中的最后ikcp_wnd_unused展示了。

在收到数据时判断kcp->snd_una与una的大小。kcp->snd_una是发送端下一个未收到ACK的数据报，una是已经收到的ACK。如果una大于kcp->snd_una，也就是说收到的ACK的una比下一个要确认的snd_una大，那么此时可能会有丢包现象的存在。相反，如果kcp->snd_una比una大，那么此时网络可能比较畅通。当网络畅通时，逐渐增加kcp->cwnd，这样在flush的时候就能够从kcp->snd_queue放入更多的数据报到kcp->snd_buf中。这样就实现了逐渐扩大发送流量。