KCP-GO源码解析【转】
概念
ARQ:自动重传请求(Automatic Repeat-reQuest,ARQ)是OSI模型中数据链路层的错误纠正协议之一. RTO:Retransmission TimeOut FEC:Forward Error Correction
kcp简介
kcp是一个基于udp实现快速、可靠、向前纠错的的协议，能以比TCP浪费10%-20%的带宽的代价，换取平均延迟降低30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发。查看官方文档kcp
kcp-go是用go实现了kcp协议的一个库，其实kcp类似tcp，协议的实现也很多参考tcp协议的实现，滑动窗口，快速重传，选择性重传，慢启动等。 kcp和tcp一样，也分客户端和监听端。
1+-+-+-+-+-+ +-+-+-+-+-+
2 | Client | | Server |
3 +-+-+-+-+-+ +-+-+-+-+-+
4 |------ kcp data ------>|
5 |<----- kcp data -------|
kcp协议
layer model
1+----------------------+
2| Session |
3+----------------------+
4| KCP(ARQ) |
5+----------------------+
6| FEC(OPTIONAL) |
7+----------------------+
8| CRYPTO(OPTIONAL)|
9+----------------------+
10| UDP(Packet) |
11+----------------------+
KCP header
KCP Header Format
1 4 1 1 2 (Byte)
2 +---+---+---+---+---+---+---+---+
3 | conv |cmd|frg| wnd |
4 +---+---+---+---+---+---+---+---+
5 | ts | sn |
6 +---+---+---+---+---+---+---+---+
7 | una | len |
8 +---+---+---+---+---+---+---+---+
9 | |
10 + DATA +
11 | |
12 +---+---+---+---+---+---+---+---+
13
代码结构
1src/vendor/github.com/xtaci/kcp-go/
2├── LICENSE
3├── README.md
4├── crypt.go 加解密实现
5├── crypt_test.go
6├── donate.png
7├── fec.go 向前纠错实现
8├── frame.png
9├── kcp-go.png
10├── kcp.go kcp协议实现
11├── kcp_test.go
12├── sess.go 会话管理实现
13├── sess_test.go
14├── snmp.go 数据统计实现
15├── updater.go 任务调度实现
16├── xor.go xor封装
17└── xor_test.go
着重研究两个文件kcp.go和sess.go
kcp浅析
kcp是基于udp实现的，所有udp的实现这里不做介绍，kcp做的事情就是怎么封装udp的数据和怎么解析udp的数据，再加各种处理机制，为了重传，拥塞控制，纠错等。下面介绍kcp客户端和服务端整体实现的流程，只是大概介绍一下函数流，不做详细解析，详细解析看后面数据流的解析。
kcp client整体函数流
和tcp一样，kcp要连接服务端需要先拨号，但是和tcp有个很大的不同是，即使服务端没有启动，客户端一样可以拨号成功，因为实际上这里的拨号没有发送任何信息，而tcp在这里需要三次握手。
1DialWithOptions(raddr string, block BlockCrypt, dataShards, parityShards int)
2 V
3net.DialUDP("udp", nil, udpaddr)
4 V
5NewConn()
6 V
7newUDPSession() {初始化UDPSession}
8 V
9NewKCP() {初始化kcp}
10 V
11updater.addSession(sess) {管理session会话，任务管理，根据用户设置的internal参数间隔来轮流唤醒任务}
12 V
13go sess.readLoop()
14 V
15go s.receiver(chPacket)
16 V
17s.kcpInput(data)
18 V
19s.fecDecoder.decodeBytes(data)
20 V
21s.kcp.Input(data, true, s.ackNoDelay)
22 V
23kcp.parse_data(seg) {将分段好的数据插入kcp.rcv_buf缓冲}
24 V
25notifyReadEvent()
26
客户端大体的流程如上面所示，先Dial，建立udp连接，将这个连接封装成一个会话，然后启动一个go程，接收udp的消息。
kcp server整体函数流
1ListenWithOptions()
2 V
3net.ListenUDP()
4 V
5ServerConn()
6 V
7newFECDecoder()
8 V
9go l.monitor() {从chPacket接收udp数据，写入kcp}
10 V
11go l.receiver(chPacket) {从upd接收数据，并入队列}
12 V
13newUDPSession()
14 V
15updater.addSession(sess) {管理session会话，任务管理，根据用户设置的internal参数间隔来轮流唤醒任务}
16 V
17s.kcpInput(data)`
18 V
19s.fecDecoder.decodeBytes(data)
20 V
21s.kcp.Input(data, true, s.ackNoDelay)
22 V
23kcp.parse_data(seg) {将分段好的数据插入kcp.rcv_buf缓冲}
24 V
25notifyReadEvent()
服务端的大体流程如上图所示，先Listen，启动udp监听，接着用一个go程监控udp的数据包，负责将不同session的数据写入不同的udp连接，然后解析封装将数据交给上层。
kcp 数据流详细解析
不管是kcp的客户端还是服务端，他们都有io行为，就是读与写，我们只分析一个就好了，因为它们读写的实现是一样的，这里分析客户端的读与写。
kcp client 发送消息
1s.Write(b []byte)
2 V
3s.kcp.WaitSnd() {}
4 V
5s.kcp.Send(b) {将数据根据mss分段，并存在kcp.snd_queue}
6 V
7s.kcp.flush(false) [flush data to output] {
8 if writeDelay==true {
9 flush
10 }else{
11 每隔`interval`时间flush一次
12 }
13}
14 V
15kcp.output(buffer, size)
16 V
17s.output(buf)
18 V
19s.conn.WriteTo(ext, s.remote)
20 V
21s.conn..Conn.WriteTo(buf)
读写都是在sess.go文件中实现的，Write方法：
1// Write implements net.Conn
2func (s *UDPSession) Write(b []byte) (n int, err error) {
3 for {
4 ...
5 // api flow control
6 if s.kcp.WaitSnd() < int(s.kcp.snd_wnd) {
7 n = len(b)
8 for {
9 if len(b) <= int(s.kcp.mss) {
10 s.kcp.Send(b)
11 break
12 } else {
13 s.kcp.Send(b[:s.kcp.mss])
14 b = b[s.kcp.mss:]
15 }
16 }
17 if !s.writeDelay {
18 s.kcp.flush(false)
19 }
20 s.mu.Unlock()
21 atomic.AddUint64(&DefaultSnmp.BytesSent, uint64(n))
22 return n, nil
23 }
24 ...
25 // wait for write event or timeout
26 select {
27 case <-s.chWriteEvent:
28 case <-c:
29 case <-s.die:
30 }
31 if timeout != nil {
32 timeout.Stop()
33 }
34 }
35}
假设发送一个hello消息，Write方法会先判断发送窗口是否已满，满的话该函数阻塞，不满则kcp.Send(“hello”),而Send函数实现根据mss的值对数据分段，当然这里的发送的hello，长度太短，只分了一个段，并把它们插入发送的队列里。
1func (kcp *KCP) Send(buffer []byte) int {
2 ...
3 for i := 0; i < count; i++ {
4 var size int
5 if len(buffer) > int(kcp.mss) {
6 size = int(kcp.mss)
7 } else {
8 size = len(buffer)
9 }
10 seg := kcp.newSegment(size)
11 copy(seg.data, buffer[:size])
12 if kcp.stream == 0 { // message mode
13 seg.frg = uint8(count - i - 1)
14 } else { // stream mode
15 seg.frg = 0
16 }
17 kcp.snd_queue = append(kcp.snd_queue, seg)
18 buffer = buffer[size:]
19 }
20 return 0
21}
接着判断参数writeDelay，如果参数设置为false，则立马发送消息，否则需要任务调度后才会触发发送，发送消息是由flush函数实现的。
1// flush pending data
2func (kcp *KCP) flush(ackOnly bool) {
3 var seg Segment
4 seg.conv = kcp.conv
5 seg.cmd = IKCP_CMD_ACK
6 seg.wnd = kcp.wnd_unused()
7 seg.una = kcp.rcv_nxt
8 buffer := kcp.buffer
9 // flush acknowledges
10 ptr := buffer
11 for i, ack := range kcp.acklist {
12 size := len(buffer) - len(ptr)
13 if size+IKCP_OVERHEAD > int(kcp.mtu) {
14 kcp.output(buffer, size)
15 ptr = buffer
16 }
17 // filter jitters caused by bufferbloat
18 if ack.sn >= kcp.rcv_nxt || len(kcp.acklist)-1 == i {
19 seg.sn, seg.ts = ack.sn, ack.ts
20 ptr = seg.encode(ptr)
21 }
22 }
23 kcp.acklist = kcp.acklist[0:0]
24 if ackOnly { // flash remain ack segments
25 size := len(buffer) - len(ptr)
26 if size > 0 {
27 kcp.output(buffer, size)
28 }
29 return
30 }
31 // probe window size (if remote window size equals zero)
32 if kcp.rmt_wnd == 0 {
33 current := currentMs()
34 if kcp.probe_wait == 0 {
35 kcp.probe_wait = IKCP_PROBE_INIT
36 kcp.ts_probe = current + kcp.probe_wait
37 } else {
38 if _itimediff(current, kcp.ts_probe) >= 0 {
39 if kcp.probe_wait < IKCP_PROBE_INIT {
40 kcp.probe_wait = IKCP_PROBE_INIT
41 }
42 kcp.probe_wait += kcp.probe_wait / 2
43 if kcp.probe_wait > IKCP_PROBE_LIMIT {
44 kcp.probe_wait = IKCP_PROBE_LIMIT
45 }
46 kcp.ts_probe = current + kcp.probe_wait
47 kcp.probe |= IKCP_ASK_SEND
48 }
49 }
50 } else {
51 kcp.ts_probe = 0
52 kcp.probe_wait = 0
53 }