1841 lines
51 KiB
C#
1841 lines
51 KiB
C#
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using DotNetty.Buffers;
|
||
using fec;
|
||
using Object = System.Object;
|
||
|
||
namespace base_kcp
|
||
{
|
||
public class Kcp
|
||
{
|
||
/**
|
||
* no delay min rto
|
||
*/
|
||
public const int IKCP_RTO_NDL = 30;
|
||
|
||
/**
|
||
* normal min rto
|
||
*/
|
||
public const int IKCP_RTO_MIN = 100;
|
||
|
||
public const int IKCP_RTO_DEF = 200;
|
||
|
||
public const int IKCP_RTO_MAX = 60000;
|
||
|
||
/**
|
||
* cmd: push data
|
||
*/
|
||
public const byte IKCP_CMD_PUSH = 81;
|
||
|
||
/**
|
||
* cmd: ack
|
||
*/
|
||
public const byte IKCP_CMD_ACK = 82;
|
||
|
||
/**
|
||
* cmd: window probe (ask)
|
||
* 询问对方当前剩余窗口大小 请求
|
||
*/
|
||
public const byte IKCP_CMD_WASK = 83;
|
||
|
||
/**
|
||
* cmd: window size (tell)
|
||
* 返回本地当前剩余窗口大小
|
||
*/
|
||
public const byte IKCP_CMD_WINS = 84;
|
||
|
||
/**
|
||
* need to send IKCP_CMD_WASK
|
||
*/
|
||
public const int IKCP_ASK_SEND = 1;
|
||
|
||
/**
|
||
* need to send IKCP_CMD_WINS
|
||
*/
|
||
public const int IKCP_ASK_TELL = 2;
|
||
|
||
public const int IKCP_WND_SND = 32;
|
||
|
||
public const int IKCP_WND_RCV = 32;
|
||
|
||
public const int IKCP_MTU_DEF = 1400;
|
||
|
||
public const int IKCP_INTERVAL = 100;
|
||
|
||
public int IKCP_OVERHEAD = 24;
|
||
|
||
public const int IKCP_DEADLINK = 20;
|
||
|
||
public const int IKCP_THRESH_INIT = 2;
|
||
|
||
public const int IKCP_THRESH_MIN = 2;
|
||
|
||
/**
|
||
* 7 secs to probe window size
|
||
*/
|
||
public const int IKCP_PROBE_INIT = 7000;
|
||
|
||
/**
|
||
* up to 120 secs to probe window
|
||
*/
|
||
public const int IKCP_PROBE_LIMIT = 120000;
|
||
|
||
public const int IKCP_SN_OFFSET = 12;
|
||
|
||
|
||
private int ackMaskSize = 0;
|
||
|
||
/**会话id**/
|
||
private int conv;
|
||
|
||
/**最大传输单元**/
|
||
private int mtu = IKCP_MTU_DEF;
|
||
|
||
/**最大分节大小 mtu减去头等部分**/
|
||
private int mss = 0;
|
||
|
||
/**状态**/
|
||
private int state;
|
||
|
||
/**已发送但未确认**/
|
||
private long sndUna;
|
||
|
||
/**下次发送下标**/
|
||
private long sndNxt;
|
||
|
||
/**下次接收下标**/
|
||
private long rcvNxt;
|
||
|
||
/**上次ack时间**/
|
||
private long tsLastack;
|
||
|
||
/**慢启动门限**/
|
||
private int ssthresh = IKCP_THRESH_INIT;
|
||
|
||
/**RTT(Round Trip Time)**/
|
||
private int rxRttval;
|
||
|
||
/**SRTT平滑RTT*/
|
||
private int rxSrtt;
|
||
|
||
/**RTO重传超时*/
|
||
private int rxRto = IKCP_RTO_DEF;
|
||
|
||
/**MinRTO最小重传超时*/
|
||
private int rxMinrto = IKCP_RTO_MIN;
|
||
|
||
/**发送窗口**/
|
||
private int sndWnd = IKCP_WND_SND;
|
||
|
||
/**接收窗口**/
|
||
private int rcvWnd = IKCP_WND_RCV;
|
||
|
||
/**当前对端可接收窗口**/
|
||
private int rmtWnd = IKCP_WND_RCV;
|
||
|
||
/**拥塞控制窗口**/
|
||
private int cwnd;
|
||
|
||
/**探测标志位**/
|
||
private int probe;
|
||
|
||
///**当前时间**/
|
||
//private long current;
|
||
/**间隔**/
|
||
private int interval = IKCP_INTERVAL;
|
||
|
||
/**发送**/
|
||
private long tsFlush = IKCP_INTERVAL;
|
||
|
||
/**是否无延迟 0不启用；1启用**/
|
||
private bool nodelay;
|
||
|
||
/**状态是否已更新**/
|
||
private bool updated;
|
||
|
||
/**探测时间**/
|
||
private long tsProbe;
|
||
|
||
/**探测等待**/
|
||
private int probeWait;
|
||
|
||
/**死连接 重传达到该值时认为连接是断开的**/
|
||
private int deadLink = IKCP_DEADLINK;
|
||
|
||
/**拥塞控制增量**/
|
||
private int incr;
|
||
|
||
/**收到包立即回ack**/
|
||
private bool ackNoDelay;
|
||
|
||
/**待发送窗口窗口**/
|
||
private Queue<Segment> sndQueue = new Queue<Segment>();
|
||
|
||
/**收到后有序的队列**/
|
||
private LinkedList<Segment> rcvQueue = new LinkedList<Segment>();
|
||
|
||
/**发送后待确认的队列**/
|
||
public LinkedList<Segment> sndBuf = new LinkedList<Segment>();
|
||
|
||
/**收到的消息 无序的**/
|
||
private LinkedList<Segment> rcvBuf = new LinkedList<Segment>();
|
||
|
||
private long[] acklist = new long[8];
|
||
|
||
private int ackcount;
|
||
|
||
private Object user;
|
||
|
||
/**是否快速重传 默认0关闭，可以设置2（2次ACK跨越将会直接重传）**/
|
||
private int fastresend;
|
||
|
||
/**是否关闭拥塞控制窗口**/
|
||
private bool nocwnd;
|
||
|
||
/**是否流传输**/
|
||
private bool stream;
|
||
|
||
/**头部预留长度 为fec checksum准备**/
|
||
private int reserved;
|
||
|
||
private KcpOutput output;
|
||
|
||
private IByteBufferAllocator byteBufAllocator = PooledByteBufferAllocator.Default;
|
||
|
||
/**ack二进制标识**/
|
||
private long ackMask;
|
||
private long lastRcvNxt;
|
||
|
||
|
||
private static long long2Uint(long n)
|
||
{
|
||
return n & 0x00000000FFFFFFFFL;
|
||
}
|
||
|
||
private static int ibound(int lower, int middle, int upper)
|
||
{
|
||
return Math.Min(Math.Max(lower, middle), upper);
|
||
}
|
||
|
||
private static int itimediff(long later, long earlier)
|
||
{
|
||
return (int) (later - earlier);
|
||
}
|
||
|
||
private static void outPut(IByteBuffer data, Kcp kcp)
|
||
{
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} [RO] {} bytes", kcp, data.readableBytes());
|
||
// }
|
||
if (data.ReadableBytes == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
kcp.output.outPut(data, kcp);
|
||
}
|
||
|
||
|
||
private static void encodeSeg(IByteBuffer buf, Segment seg)
|
||
{
|
||
int offset = buf.WriterIndex;
|
||
|
||
buf.WriteIntLE(seg.Conv);
|
||
buf.WriteByte(seg.Cmd);
|
||
buf.WriteByte(seg.Frg);
|
||
buf.WriteShortLE(seg.Wnd);
|
||
buf.WriteIntLE((int) seg.Ts);
|
||
buf.WriteIntLE((int) seg.Sn);
|
||
buf.WriteIntLE((int) seg.Una);
|
||
buf.WriteIntLE(seg.Data.ReadableBytes);
|
||
switch (seg.AckMaskSize)
|
||
{
|
||
case 8:
|
||
buf.WriteByte((int) seg.AckMask);
|
||
break;
|
||
case 16:
|
||
buf.WriteShortLE((int) seg.AckMask);
|
||
break;
|
||
case 32:
|
||
buf.WriteIntLE((int) seg.AckMask);
|
||
break;
|
||
case 64:
|
||
buf.WriteLongLE(seg.AckMask);
|
||
break;
|
||
}
|
||
|
||
Snmp.snmp.OutSegs++;
|
||
}
|
||
|
||
public Kcp(int conv, KcpOutput output)
|
||
{
|
||
this.conv = conv;
|
||
this.output = output;
|
||
this.mss = mtu - IKCP_OVERHEAD;
|
||
}
|
||
|
||
public void release()
|
||
{
|
||
release(sndBuf);
|
||
release(rcvBuf);
|
||
release(sndQueue);
|
||
release(rcvQueue);
|
||
}
|
||
|
||
private void release(ICollection segQueue)
|
||
{
|
||
foreach (Segment seg in segQueue)
|
||
{
|
||
seg.recycle(true);
|
||
}
|
||
}
|
||
|
||
private IByteBuffer createFlushByteBuf()
|
||
{
|
||
return byteBufAllocator.DirectBuffer(this.mtu);
|
||
}
|
||
|
||
public IByteBuffer mergeRecv()
|
||
{
|
||
if (rcvQueue.Count == 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
int peek = peekSize();
|
||
|
||
if (peek < 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
|
||
bool recover = rcvQueue.Count >= rcvWnd;
|
||
|
||
IByteBuffer byteBuf = null;
|
||
|
||
// merge fragment
|
||
int len = 0;
|
||
|
||
var itr = rcvQueue.First;
|
||
while (itr != null)
|
||
{
|
||
Segment seg = itr.Value;
|
||
var next = itr.Next;
|
||
rcvQueue.Remove(itr);
|
||
itr = next;
|
||
|
||
len += seg.Data.ReadableBytes;
|
||
int fragment = seg.Frg;
|
||
if (byteBuf == null)
|
||
{
|
||
if (fragment == 0)
|
||
{
|
||
byteBuf = seg.Data;
|
||
seg.recycle(false);
|
||
break;
|
||
}
|
||
|
||
byteBuf = byteBufAllocator.DirectBuffer(len);
|
||
}
|
||
|
||
byteBuf.WriteBytes(seg.Data);
|
||
seg.recycle(true);
|
||
if (fragment == 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
// move available data from rcv_buf -> rcv_queue
|
||
moveRcvData();
|
||
// fast recover
|
||
if (rcvQueue.Count < rcvWnd && recover)
|
||
{
|
||
// ready to send back IKCP_CMD_WINS in ikcp_flush
|
||
// tell remote my window size
|
||
probe |= IKCP_ASK_TELL;
|
||
}
|
||
|
||
return byteBuf;
|
||
}
|
||
|
||
|
||
/**
|
||
* 1，判断是否有完整的包，如果有就抛给下一层
|
||
* 2，整理消息接收队列，判断下一个包是否已经收到 收到放入rcvQueue
|
||
* 3，判断接收窗口剩余是否改变，如果改变记录需要通知
|
||
* @param bufList
|
||
* @return
|
||
*/
|
||
public int recv(List<IByteBuffer> bufList)
|
||
{
|
||
if (rcvQueue.Count == 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
int peek = peekSize();
|
||
|
||
if (peek < 0)
|
||
{
|
||
return -2;
|
||
}
|
||
|
||
//接收队列长度大于接收窗口？比如接收窗口是32个包，目前已经满32个包了，需要在恢复的时候告诉对方
|
||
bool recover = rcvQueue.Count >= rcvWnd;
|
||
|
||
// merge fragment
|
||
int len = 0;
|
||
|
||
|
||
var itr = rcvQueue.First;
|
||
|
||
while (itr != null)
|
||
{
|
||
Segment seg = itr.Value;
|
||
var next = itr.Next;
|
||
rcvQueue.Remove(itr);
|
||
itr = next;
|
||
|
||
len += seg.Data.ReadableBytes;
|
||
bufList.Add(seg.Data);
|
||
|
||
int fragment = seg.Frg;
|
||
|
||
seg.recycle(false);
|
||
|
||
if (fragment == 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
// move available data from rcv_buf -> rcv_queue
|
||
moveRcvData();
|
||
|
||
// fast recover接收队列长度小于接收窗口，说明还可以接数据，已经恢复了，在下次发包的时候告诉对方本方的窗口
|
||
if (rcvQueue.Count < rcvWnd && recover)
|
||
{
|
||
// ready to send back IKCP_CMD_WINS in ikcp_flush
|
||
// tell remote my window size
|
||
probe |= IKCP_ASK_TELL;
|
||
}
|
||
|
||
return len;
|
||
}
|
||
|
||
|
||
/**
|
||
* check the size of next message in the recv queue
|
||
* 检查接收队列里面是否有完整的一个包，如果有返回该包的字节长度
|
||
* @return -1 没有完整包， >0 一个完整包所含字节
|
||
*/
|
||
public int peekSize()
|
||
{
|
||
if (rcvQueue.Count == 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
Segment seg = rcvQueue.First();
|
||
//第一个包是一条应用层消息的最后一个分包？一条消息只有一个包的情况？
|
||
if (seg.Frg == 0)
|
||
{
|
||
return seg.Data.ReadableBytes;
|
||
}
|
||
|
||
//接收队列长度小于应用层消息分包数量？接收队列空间不够用于接收完整的一个消息？
|
||
if (rcvQueue.Count < seg.Frg + 1)
|
||
{
|
||
// Some segments have not arrived yet
|
||
return -1;
|
||
}
|
||
|
||
int len = 0;
|
||
var itr = rcvQueue.First;
|
||
while (itr != null)
|
||
{
|
||
var s = itr.Value;
|
||
len += s.Data.ReadableBytes;
|
||
if (s.Frg == 0)
|
||
{
|
||
break;
|
||
}
|
||
|
||
itr = itr.Next;
|
||
}
|
||
|
||
return len;
|
||
}
|
||
|
||
|
||
/**
|
||
* 判断一条消息是否完整收全了
|
||
* @return
|
||
*/
|
||
public bool canRecv()
|
||
{
|
||
if (rcvQueue.Count == 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Segment seg = rcvQueue.First();
|
||
if (seg.Frg == 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (rcvQueue.Count < seg.Frg + 1)
|
||
{
|
||
// Some segments have not arrived yet
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
public int send(IByteBuffer buf)
|
||
{
|
||
int len = buf.ReadableBytes;
|
||
if (len == 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
// append to previous segment in streaming mode (if possible)
|
||
if (stream)
|
||
{
|
||
if (sndQueue.Count > 0)
|
||
{
|
||
Segment last = sndQueue.Last();
|
||
IByteBuffer lastData = last.Data;
|
||
int lastLen = lastData.ReadableBytes;
|
||
if (lastLen < mss)
|
||
{
|
||
int capacity = mss - lastLen;
|
||
int extend = len < capacity ? len : capacity;
|
||
if (lastData.MaxWritableBytes < extend)
|
||
{
|
||
// extend
|
||
IByteBuffer newBuf = byteBufAllocator.DirectBuffer(lastLen + extend);
|
||
newBuf.WriteBytes(lastData);
|
||
lastData.Release();
|
||
lastData = last.Data = newBuf;
|
||
}
|
||
|
||
lastData.WriteBytes(buf, extend);
|
||
|
||
len = buf.ReadableBytes;
|
||
if (len == 0)
|
||
{
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
int count;
|
||
if (len <= mss)
|
||
{
|
||
count = 1;
|
||
}
|
||
else
|
||
{
|
||
count = (len + mss - 1) / mss;
|
||
}
|
||
|
||
if (count > 255)
|
||
{
|
||
// Maybe don't need the conditon in stream mode
|
||
return -2;
|
||
}
|
||
|
||
if (count == 0)
|
||
{
|
||
// impossible
|
||
count = 1;
|
||
}
|
||
|
||
// segment
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
int size = len > mss ? mss : len;
|
||
Segment seg = Segment.createSegment(buf.ReadRetainedSlice(size));
|
||
seg.Frg = (short) (stream ? 0 : count - i - 1);
|
||
sndQueue.Enqueue(seg);
|
||
// sndQueue.add(seg);
|
||
len = buf.ReadableBytes;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* update ack.
|
||
* parse ack根据RTT计算SRTT和RTO即重传超时
|
||
* @param rtt
|
||
*/
|
||
private void updateAck(int rtt)
|
||
{
|
||
if (rxSrtt == 0)
|
||
{
|
||
rxSrtt = rtt;
|
||
rxRttval = rtt >> 2;
|
||
}
|
||
else
|
||
{
|
||
int delta = rtt - rxSrtt;
|
||
rxSrtt += delta >> 3;
|
||
delta = Math.Abs(delta);
|
||
if (rtt < rxSrtt - rxRttval)
|
||
{
|
||
rxRttval += (delta - rxRttval) >> 5;
|
||
}
|
||
else
|
||
{
|
||
rxRttval += (delta - rxRttval) >> 2;
|
||
}
|
||
|
||
//int delta = rtt - rxSrtt;
|
||
//if (delta < 0) {
|
||
// delta = -delta;
|
||
//}
|
||
//rxRttval = (3 * rxRttval + delta) / 4;
|
||
//rxSrtt = (7 * rxSrtt + rtt) / 8;
|
||
//if (rxSrtt < 1) {
|
||
// rxSrtt = 1;
|
||
//}
|
||
}
|
||
|
||
int rto = rxSrtt + Math.Max(interval, rxRttval << 2);
|
||
rxRto = ibound(rxMinrto, rto, IKCP_RTO_MAX);
|
||
}
|
||
|
||
private void shrinkBuf()
|
||
{
|
||
if (sndBuf.Count > 0)
|
||
{
|
||
Segment seg = sndBuf.First();
|
||
sndUna = seg.Sn;
|
||
}
|
||
else
|
||
{
|
||
sndUna = sndNxt;
|
||
}
|
||
}
|
||
|
||
private void parseAck(long sn)
|
||
{
|
||
if (itimediff(sn, sndUna) < 0 || itimediff(sn, sndNxt) >= 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var itr = sndBuf.First;
|
||
while (itr != null)
|
||
{
|
||
var next = itr.Next;
|
||
Segment seg = itr.Value;
|
||
if (sn == seg.Sn)
|
||
{
|
||
sndBuf.Remove(itr);
|
||
seg.recycle(true);
|
||
break;
|
||
}
|
||
|
||
if (itimediff(sn, seg.Sn) < 0)
|
||
{
|
||
break;
|
||
}
|
||
|
||
itr = next;
|
||
}
|
||
}
|
||
|
||
private void parseUna(long una)
|
||
{
|
||
var itr = sndBuf.First;
|
||
while (itr != null)
|
||
{
|
||
var next = itr.Next;
|
||
Segment seg = itr.Value;
|
||
if (itimediff(una, seg.Sn) > 0)
|
||
{
|
||
sndBuf.Remove(itr);
|
||
seg.recycle(true);
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
|
||
itr = next;
|
||
}
|
||
}
|
||
|
||
private void parseAckMask(long una, long ackMask)
|
||
{
|
||
if (ackMask == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var itr = sndBuf.First;
|
||
while (itr != null)
|
||
{
|
||
var next = itr.Next;
|
||
Segment seg = itr.Value;
|
||
int index = (int) (seg.Sn - una - 1);
|
||
if (index < 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (index >= ackMaskSize)
|
||
break;
|
||
long mask = ackMask & 1 << index;
|
||
if (mask != 0)
|
||
{
|
||
sndBuf.Remove(itr);
|
||
seg.recycle(true);
|
||
}
|
||
|
||
itr = next;
|
||
}
|
||
}
|
||
|
||
|
||
private void parseFastack(long sn, long ts)
|
||
{
|
||
if (itimediff(sn, sndUna) < 0 || itimediff(sn, sndNxt) >= 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (var seg in sndBuf)
|
||
{
|
||
if (itimediff(sn, seg.Sn) < 0)
|
||
{
|
||
break;
|
||
//根据时间判断 在当前包时间之前的包才能被认定是需要快速重传的
|
||
}
|
||
else if (sn != seg.Sn && itimediff(seg.Ts, ts) <= 0)
|
||
{
|
||
seg.Fastack++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
private void ackPush(long sn, long ts)
|
||
{
|
||
int newSize = 2 * (ackcount + 1);
|
||
|
||
if (newSize > acklist.Count())
|
||
{
|
||
int newCapacity = acklist.Count() << 1; // double capacity
|
||
|
||
// if (newCapacity < 0) {
|
||
// throw new OutOfMemoryError();
|
||
// }
|
||
|
||
long[] newArray = new long[newCapacity];
|
||
Array.Copy(acklist, 0, newArray, 0, acklist.Count());
|
||
this.acklist = newArray;
|
||
}
|
||
|
||
acklist[2 * ackcount] = sn;
|
||
acklist[2 * ackcount + 1] = ts;
|
||
ackcount++;
|
||
}
|
||
|
||
private bool parseData(Segment newSeg)
|
||
{
|
||
long sn = newSeg.Sn;
|
||
|
||
if (itimediff(sn, rcvNxt + rcvWnd) >= 0 || itimediff(sn, rcvNxt) < 0)
|
||
{
|
||
newSeg.recycle(true);
|
||
return true;
|
||
}
|
||
|
||
bool repeat = false;
|
||
bool findPos = false;
|
||
|
||
var last = rcvBuf.Last;
|
||
while (last != null)
|
||
{
|
||
var front = last.Previous;
|
||
Segment seg = last.Value;
|
||
if (seg.Sn == sn)
|
||
{
|
||
repeat = true;
|
||
//Snmp.snmp.RepeatSegs.incrementAndGet();
|
||
break;
|
||
}
|
||
|
||
if (itimediff(sn, seg.Sn) > 0)
|
||
{
|
||
findPos = true;
|
||
break;
|
||
}
|
||
|
||
if (front == null)
|
||
{
|
||
break;
|
||
}
|
||
|
||
last = front;
|
||
}
|
||
|
||
if (repeat)
|
||
{
|
||
newSeg.recycle(true);
|
||
}
|
||
else if (last == null)
|
||
{
|
||
rcvBuf.AddLast(newSeg);
|
||
}
|
||
else if(findPos)
|
||
{
|
||
rcvBuf.AddAfter(last, newSeg);
|
||
}
|
||
else
|
||
{
|
||
rcvBuf.AddFirst(newSeg);
|
||
}
|
||
|
||
// var firstSn = rcvBuf.First.Value.Sn;
|
||
// foreach (var segment in rcvBuf)
|
||
// {
|
||
// if (segment.Sn == firstSn)
|
||
// continue;
|
||
// firstSn++;
|
||
// if (firstSn != segment.Sn)
|
||
// {
|
||
// Console.WriteLine();
|
||
// }
|
||
//
|
||
//
|
||
// }
|
||
|
||
|
||
|
||
// move available data from rcv_buf -> rcv_queue
|
||
moveRcvData(); // Invoke the method only if the segment is not repeat?
|
||
return repeat;
|
||
}
|
||
|
||
private void moveRcvData()
|
||
{
|
||
var itr = rcvBuf.First;
|
||
while (itr != null)
|
||
{
|
||
var next = itr.Next;
|
||
Segment seg = itr.Value;
|
||
if (seg.Sn == rcvNxt && rcvQueue.Count < rcvWnd)
|
||
{
|
||
rcvBuf.Remove(itr);
|
||
rcvQueue.AddLast(seg);
|
||
rcvNxt++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
|
||
itr = next;
|
||
}
|
||
}
|
||
|
||
|
||
public int input(IByteBuffer data, bool regular, long current)
|
||
{
|
||
long oldSndUna = sndUna;
|
||
if (data == null || data.ReadableBytes < IKCP_OVERHEAD)
|
||
{
|
||
return -1;
|
||
}
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} [RI] {} bytes", this, data.readableBytes());
|
||
// }
|
||
|
||
|
||
long latest = 0; // latest packet
|
||
bool flag = false;
|
||
int inSegs = 0;
|
||
|
||
|
||
long uintCurrent = long2Uint(current);
|
||
|
||
while (true)
|
||
{
|
||
int conv, len, wnd;
|
||
long ts, sn, una, ackMask;
|
||
byte cmd;
|
||
short frg;
|
||
Segment seg;
|
||
|
||
if (data.ReadableBytes < IKCP_OVERHEAD)
|
||
{
|
||
break;
|
||
}
|
||
|
||
conv = data.ReadIntLE();
|
||
if (conv != this.conv)
|
||
{
|
||
return -4;
|
||
}
|
||
|
||
cmd = data.ReadByte();
|
||
frg = data.ReadByte();
|
||
wnd = data.ReadUnsignedShortLE();
|
||
ts = data.ReadUnsignedIntLE();
|
||
sn = data.ReadUnsignedIntLE();
|
||
una = data.ReadUnsignedIntLE();
|
||
len = data.ReadIntLE();
|
||
|
||
|
||
switch (ackMaskSize)
|
||
{
|
||
case 8:
|
||
ackMask = data.ReadByte();
|
||
break;
|
||
case 16:
|
||
ackMask = data.ReadUnsignedShortLE();
|
||
break;
|
||
case 32:
|
||
ackMask = data.ReadUnsignedIntLE();
|
||
break;
|
||
case 64:
|
||
//TODO need unsignedLongLe
|
||
ackMask = data.ReadLongLE();
|
||
break;
|
||
default:
|
||
ackMask = 0;
|
||
break;
|
||
}
|
||
|
||
;
|
||
|
||
|
||
if (data.ReadableBytes < len)
|
||
{
|
||
return -2;
|
||
}
|
||
|
||
if (cmd != IKCP_CMD_PUSH && cmd != IKCP_CMD_ACK && cmd != IKCP_CMD_WASK && cmd != IKCP_CMD_WINS)
|
||
{
|
||
return -3;
|
||
}
|
||
|
||
//最后收到的来计算远程窗口大小
|
||
if (regular)
|
||
{
|
||
this.rmtWnd = wnd; //更新远端窗口大小删除已确认的包，una以前的包对方都收到了，可以把本地小于una的都删除掉
|
||
}
|
||
|
||
//this.rmtWnd = wnd;
|
||
parseUna(una);
|
||
shrinkBuf();
|
||
|
||
|
||
bool readed = false;
|
||
switch (cmd)
|
||
{
|
||
case IKCP_CMD_ACK:
|
||
{
|
||
parseAck(sn);
|
||
parseFastack(sn, ts);
|
||
flag = true;
|
||
latest = ts;
|
||
int rtt = itimediff(uintCurrent, ts);
|
||
// Debug.Log(GetHashCode()+" input ack: sn="+sn+", rtt="+rtt+", rto="+rxRto+",regular="+regular);
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} input ack: sn={}, rtt={}, rto={} ,regular={}", this, sn, rtt, rxRto,regular);
|
||
// }
|
||
break;
|
||
}
|
||
case IKCP_CMD_PUSH:
|
||
{
|
||
bool repeat = true;
|
||
if (itimediff(sn, rcvNxt + rcvWnd) < 0)
|
||
{
|
||
ackPush(sn, ts);
|
||
if (itimediff(sn, rcvNxt) >= 0)
|
||
{
|
||
if (len > 0)
|
||
{
|
||
seg = Segment.createSegment(data.ReadRetainedSlice(len));
|
||
readed = true;
|
||
}
|
||
else
|
||
{
|
||
seg = Segment.createSegment(byteBufAllocator, 0);
|
||
}
|
||
|
||
seg.Conv = conv;
|
||
seg.Cmd = cmd;
|
||
seg.Frg = frg;
|
||
seg.Wnd = wnd;
|
||
seg.Ts = ts;
|
||
seg.Sn = sn;
|
||
seg.Una = una;
|
||
repeat = parseData(seg);
|
||
}
|
||
}
|
||
|
||
if (regular && repeat)
|
||
{
|
||
Snmp.snmp.RepeatSegs++;
|
||
}
|
||
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} input push: sn={}, una={}, ts={},regular={}", this, sn, una, ts,regular);
|
||
// }
|
||
|
||
// Console.WriteLine(GetHashCode()+" input push: sn="+sn+", una="+una+", ts="+ts+",regular="+regular);
|
||
break;
|
||
}
|
||
case IKCP_CMD_WASK:
|
||
{
|
||
// ready to send back IKCP_CMD_WINS in ikcp_flush
|
||
// tell remote my window size
|
||
probe |= IKCP_ASK_TELL;
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} input ask", this);
|
||
// }
|
||
break;
|
||
}
|
||
case IKCP_CMD_WINS:
|
||
{
|
||
// do nothing
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} input tell: {}", this, wnd);
|
||
// }
|
||
break;
|
||
}
|
||
default:
|
||
return -3;
|
||
}
|
||
|
||
parseAckMask(una, ackMask);
|
||
|
||
if (!readed)
|
||
{
|
||
data.SkipBytes(len);
|
||
}
|
||
|
||
inSegs++;
|
||
}
|
||
|
||
// if (data.ReadableBytes > 0)
|
||
// {
|
||
// Console.WriteLine("ReadableBytes"+data.ReadableBytes);
|
||
// }
|
||
|
||
Snmp.snmp.InSegs += inSegs;
|
||
|
||
if (flag && regular)
|
||
{
|
||
int rtt = itimediff(uintCurrent, latest);
|
||
if (rtt >= 0)
|
||
{
|
||
updateAck(rtt); //收到ack包，根据ack包的时间计算srtt和rto
|
||
}
|
||
}
|
||
|
||
if (!nocwnd)
|
||
{
|
||
if (itimediff(sndUna, oldSndUna) > 0)
|
||
{
|
||
if (cwnd < rmtWnd)
|
||
{
|
||
int mss = this.mss;
|
||
if (cwnd < ssthresh)
|
||
{
|
||
cwnd++;
|
||
incr += mss;
|
||
}
|
||
else
|
||
{
|
||
if (incr < mss)
|
||
{
|
||
incr = mss;
|
||
}
|
||
|
||
incr += (mss * mss) / incr + (mss / 16);
|
||
if ((cwnd + 1) * mss <= incr)
|
||
{
|
||
cwnd++;
|
||
}
|
||
}
|
||
|
||
if (cwnd > rmtWnd)
|
||
{
|
||
cwnd = rmtWnd;
|
||
incr = rmtWnd * mss;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if (ackNoDelay && ackcount > 0)
|
||
{
|
||
// ack immediately
|
||
flush(true, current);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
private int wndUnused()
|
||
{
|
||
if (rcvQueue.Count < rcvWnd)
|
||
{
|
||
return rcvWnd - rcvQueue.Count;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
private IByteBuffer makeSpace(IByteBuffer buffer, int space)
|
||
{
|
||
if (buffer.ReadableBytes + space > mtu)
|
||
{
|
||
outPut(buffer, this);
|
||
buffer = createFlushByteBuf();
|
||
buffer.SetWriterIndex(reserved);
|
||
}
|
||
|
||
return buffer;
|
||
}
|
||
|
||
private void flushBuffer(IByteBuffer buffer)
|
||
{
|
||
if (buffer.ReadableBytes > reserved)
|
||
{
|
||
outPut(buffer, this);
|
||
return;
|
||
}
|
||
|
||
buffer.Release();
|
||
}
|
||
|
||
|
||
private readonly long startTicks = DateTime.Now.Ticks;
|
||
|
||
public long currentMs()
|
||
{
|
||
long currentTicks = DateTime.Now.Ticks;
|
||
return (currentTicks - startTicks) / TimeSpan.TicksPerMillisecond;
|
||
}
|
||
|
||
/**
|
||
* ikcp_flush
|
||
*/
|
||
public long flush(bool ackOnly, long current)
|
||
{
|
||
// 'ikcp_update' haven't been called.
|
||
//if (!updated) {
|
||
// return;
|
||
//}
|
||
|
||
//long current = this.current;
|
||
//long uintCurrent = long2Uint(current);
|
||
|
||
Segment seg = Segment.createSegment(byteBufAllocator, 0);
|
||
seg.Conv = conv;
|
||
seg.Cmd = IKCP_CMD_ACK;
|
||
seg.AckMaskSize = this.ackMaskSize;
|
||
seg.Wnd = wndUnused(); //可接收数量
|
||
seg.Una = rcvNxt; //已接收数量，下次要接收的包的sn，这sn之前的包都已经收到
|
||
|
||
IByteBuffer buffer = createFlushByteBuf();
|
||
buffer.SetWriterIndex(reserved);
|
||
|
||
|
||
//计算ackMask
|
||
int count = ackcount;
|
||
|
||
if (lastRcvNxt != rcvNxt)
|
||
{
|
||
ackMask = 0;
|
||
lastRcvNxt = rcvNxt;
|
||
}
|
||
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
long sn = acklist[i * 2];
|
||
if (sn < rcvNxt)
|
||
continue;
|
||
int index = (int) (sn - rcvNxt - 1);
|
||
if (index >= ackMaskSize)
|
||
break;
|
||
if (index >= 0)
|
||
{
|
||
ackMask |= 1 << index;
|
||
}
|
||
}
|
||
|
||
seg.AckMask = ackMask;
|
||
|
||
|
||
// flush acknowledges有收到的包需要确认，则发确认包
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
buffer = makeSpace(buffer, IKCP_OVERHEAD);
|
||
long sn = acklist[i * 2];
|
||
if (sn >= rcvNxt || count - 1 == i)
|
||
{
|
||
seg.Sn = sn;
|
||
seg.Ts = acklist[i * 2 + 1];
|
||
encodeSeg(buffer, seg);
|
||
|
||
// Console.WriteLine(GetHashCode()+"flush ack: sn="+seg.Sn+", ts="+seg.Ts+" ,count="+count+" Una"+seg.Una);
|
||
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} flush ack: sn={}, ts={} ,count={}", this, seg.sn, seg.ts,count);
|
||
// }
|
||
}
|
||
}
|
||
|
||
ackcount = 0;
|
||
|
||
|
||
if (ackOnly)
|
||
{
|
||
flushBuffer(buffer);
|
||
seg.recycle(true);
|
||
return interval;
|
||
}
|
||
|
||
// probe window size (if remote window size equals zero)
|
||
//拥堵控制 如果对方可接受窗口大小为0 需要询问对方窗口大小
|
||
if (rmtWnd == 0)
|
||
{
|
||
current = currentMs();
|
||
if (probeWait == 0)
|
||
{
|
||
probeWait = IKCP_PROBE_INIT;
|
||
tsProbe = current + probeWait;
|
||
}
|
||
else
|
||
{
|
||
if (itimediff(current, tsProbe) >= 0)
|
||
{
|
||
if (probeWait < IKCP_PROBE_INIT)
|
||
{
|
||
probeWait = IKCP_PROBE_INIT;
|
||
}
|
||
|
||
probeWait += probeWait / 2;
|
||
if (probeWait > IKCP_PROBE_LIMIT)
|
||
{
|
||
probeWait = IKCP_PROBE_LIMIT;
|
||
}
|
||
|
||
tsProbe = current + probeWait;
|
||
probe |= IKCP_ASK_SEND;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
tsProbe = 0;
|
||
probeWait = 0;
|
||
}
|
||
|
||
// flush window probing commands
|
||
if ((probe & IKCP_ASK_SEND) != 0)
|
||
{
|
||
seg.Cmd = IKCP_CMD_WASK;
|
||
buffer = makeSpace(buffer, IKCP_OVERHEAD);
|
||
encodeSeg(buffer, seg);
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} flush ask", this);
|
||
// }
|
||
}
|
||
|
||
// flush window probing commands
|
||
if ((probe & IKCP_ASK_TELL) != 0)
|
||
{
|
||
seg.Cmd = IKCP_CMD_WINS;
|
||
buffer = makeSpace(buffer, IKCP_OVERHEAD);
|
||
encodeSeg(buffer, seg);
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} flush tell: wnd={}", this, seg.wnd);
|
||
// }
|
||
}
|
||
|
||
probe = 0;
|
||
|
||
// calculate window size
|
||
int cwnd0 = Math.Min(sndWnd, rmtWnd);
|
||
if (!nocwnd)
|
||
{
|
||
cwnd0 = Math.Min(this.cwnd, cwnd0);
|
||
}
|
||
|
||
int newSegsCount = 0;
|
||
// move data from snd_queue to snd_buf
|
||
while (itimediff(sndNxt, sndUna + cwnd0) < 0)
|
||
{
|
||
if (sndQueue.Count == 0)
|
||
{
|
||
break;
|
||
}
|
||
var newSeg = sndQueue.Dequeue();
|
||
newSeg.Conv = conv;
|
||
newSeg.Cmd = IKCP_CMD_PUSH;
|
||
newSeg.Sn = sndNxt;
|
||
sndBuf.AddLast(newSeg);
|
||
// sndBuf.AddLast(newSeg);
|
||
sndNxt++;
|
||
newSegsCount++;
|
||
}
|
||
|
||
// calculate resent
|
||
int resent = fastresend > 0 ? fastresend : 0x7fffffff;
|
||
|
||
// flush data segments
|
||
current = currentMs();
|
||
int change = 0;
|
||
bool lost = false;
|
||
int lostSegs = 0, fastRetransSegs = 0, earlyRetransSegs = 0;
|
||
long minrto = interval;
|
||
var itr = sndBuf.First;
|
||
|
||
while (itr != null)
|
||
{
|
||
var next = itr.Next;
|
||
Segment segment = itr.Value;
|
||
itr = next;
|
||
|
||
bool needsend = false;
|
||
if (segment.Xmit == 0)
|
||
{
|
||
needsend = true;
|
||
segment.Rto = rxRto;
|
||
segment.Resendts = current + segment.Rto;
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} flush data: sn={}, resendts={}", this, segment.sn, (segment.resendts - current));
|
||
// }
|
||
}
|
||
else if (segment.Fastack >= resent)
|
||
{
|
||
needsend = true;
|
||
segment.Fastack = 0;
|
||
segment.Rto = rxRto;
|
||
segment.Resendts = current + segment.Rto;
|
||
change++;
|
||
fastRetransSegs++;
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} fastresend. sn={}, xmit={}, resendts={} ", this, segment.sn, segment.xmit, (segment
|
||
// .resendts - current));
|
||
// }
|
||
}
|
||
else if (segment.Fastack > 0 && newSegsCount == 0)
|
||
{
|
||
// early retransmit
|
||
needsend = true;
|
||
segment.Fastack = 0;
|
||
segment.Rto = rxRto;
|
||
segment.Resendts = current + segment.Rto;
|
||
change++;
|
||
earlyRetransSegs++;
|
||
}
|
||
else if (itimediff(current, segment.Resendts) >= 0)
|
||
{
|
||
needsend = true;
|
||
if (!nodelay)
|
||
{
|
||
segment.Rto += rxRto;
|
||
}
|
||
else
|
||
{
|
||
segment.Rto += rxRto / 2;
|
||
}
|
||
|
||
segment.Fastack = 0;
|
||
segment.Resendts = current + segment.Rto;
|
||
lost = true;
|
||
lostSegs++;
|
||
// if (log.isDebugEnabled()) {
|
||
// log.debug("{} resend. sn={}, xmit={}, resendts={}", this, segment.sn, segment.xmit, (segment
|
||
// .resendts - current));
|
||
// }
|
||
}
|
||
|
||
|
||
if (needsend)
|
||
{
|
||
segment.Xmit++;
|
||
segment.Ts = long2Uint(current);
|
||
segment.Wnd = seg.Wnd;
|
||
segment.Una = rcvNxt;
|
||
segment.AckMaskSize = this.ackMaskSize;
|
||
segment.AckMask = ackMask;
|
||
|
||
IByteBuffer segData = segment.Data;
|
||
int segLen = segData.ReadableBytes;
|
||
int need = IKCP_OVERHEAD + segLen;
|
||
buffer = makeSpace(buffer, need);
|
||
|
||
//if (buffer.readableBytes() + need > mtu) {
|
||
// output(buffer, this);
|
||
// buffer = createFlushByteBuf();
|
||
//}
|
||
|
||
encodeSeg(buffer, segment);
|
||
|
||
if (segLen > 0)
|
||
{
|
||
// don't increases data's readerIndex, because the data may be resend.
|
||
buffer.WriteBytes(segData, segData.ReaderIndex, segLen);
|
||
}
|
||
|
||
if (segment.Xmit >= deadLink)
|
||
{
|
||
state = -1;
|
||
}
|
||
|
||
// get the nearest rto
|
||
long rto = itimediff(segment.Resendts, current);
|
||
if (rto > 0 && rto < minrto)
|
||
{
|
||
minrto = rto;
|
||
}
|
||
}
|
||
}
|
||
|
||
// flash remain segments
|
||
flushBuffer(buffer);
|
||
seg.recycle(true);
|
||
|
||
int sum = lostSegs;
|
||
if (lostSegs > 0)
|
||
{
|
||
Snmp.snmp.LostSegs += lostSegs;
|
||
}
|
||
|
||
if (fastRetransSegs > 0)
|
||
{
|
||
Snmp.snmp.FastRetransSegs += fastRetransSegs;
|
||
sum += fastRetransSegs;
|
||
}
|
||
|
||
if (earlyRetransSegs > 0)
|
||
{
|
||
Snmp.snmp.EarlyRetransSegs += earlyRetransSegs;
|
||
sum += earlyRetransSegs;
|
||
}
|
||
|
||
if (sum > 0)
|
||
{
|
||
Snmp.snmp.RetransSegs += sum;
|
||
}
|
||
|
||
// update ssthresh
|
||
if (!nocwnd)
|
||
{
|
||
if (change > 0)
|
||
{
|
||
int inflight = (int) (sndNxt - sndUna);
|
||
ssthresh = inflight / 2;
|
||
if (ssthresh < IKCP_THRESH_MIN)
|
||
{
|
||
ssthresh = IKCP_THRESH_MIN;
|
||
}
|
||
|
||
cwnd = ssthresh + resent;
|
||
incr = cwnd * mss;
|
||
}
|
||
|
||
if (lost)
|
||
{
|
||
ssthresh = cwnd0 / 2;
|
||
if (ssthresh < IKCP_THRESH_MIN)
|
||
{
|
||
ssthresh = IKCP_THRESH_MIN;
|
||
}
|
||
|
||
cwnd = 1;
|
||
incr = mss;
|
||
}
|
||
|
||
if (cwnd < 1)
|
||
{
|
||
cwnd = 1;
|
||
incr = mss;
|
||
}
|
||
}
|
||
|
||
return minrto;
|
||
}
|
||
|
||
|
||
/**
|
||
* update getState (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.
|
||
*
|
||
* @param current
|
||
*/
|
||
public void update(long current)
|
||
{
|
||
if (!updated)
|
||
{
|
||
updated = true;
|
||
tsFlush = current;
|
||
}
|
||
|
||
int slap = itimediff(current, tsFlush);
|
||
|
||
if (slap >= 10000 || slap < -10000)
|
||
{
|
||
tsFlush = current;
|
||
slap = 0;
|
||
}
|
||
|
||
/*if (slap >= 0) {
|
||
tsFlush += setInterval;
|
||
if (itimediff(this.current, tsFlush) >= 0) {
|
||
tsFlush = this.current + setInterval;
|
||
}
|
||
flush();
|
||
}*/
|
||
|
||
if (slap >= 0)
|
||
{
|
||
tsFlush += interval;
|
||
if (itimediff(current, tsFlush) >= 0)
|
||
{
|
||
tsFlush = current + interval;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
tsFlush = current + interval;
|
||
}
|
||
|
||
flush(false, current);
|
||
}
|
||
|
||
/**
|
||
* Determine when should you invoke ikcp_update:
|
||
* returns when you should invoke ikcp_update in millisec, if there
|
||
* is no ikcp_input/_send calling. you can call ikcp_update in that
|
||
* time, instead of call update repeatly.
|
||
* Important to reduce unnacessary ikcp_update invoking. use it to
|
||
* schedule ikcp_update (eg. implementing an epoll-like mechanism,
|
||
* or optimize ikcp_update when handling massive kcp connections)
|
||
*
|
||
* @param current
|
||
* @return
|
||
*/
|
||
public long check(long current)
|
||
{
|
||
if (!updated)
|
||
{
|
||
return current;
|
||
}
|
||
|
||
long tsFlush = this.tsFlush;
|
||
int slap = itimediff(current, tsFlush);
|
||
if (slap >= 10000 || slap < -10000)
|
||
{
|
||
tsFlush = current;
|
||
slap = 0;
|
||
}
|
||
|
||
if (slap >= 0)
|
||
{
|
||
return current;
|
||
}
|
||
|
||
int tmFlush = itimediff(tsFlush, current);
|
||
int tmPacket = 0x7fffffff;
|
||
|
||
foreach (var seg in sndBuf)
|
||
{
|
||
int diff = itimediff(seg.Resendts, current);
|
||
if (diff <= 0)
|
||
{
|
||
return current;
|
||
}
|
||
|
||
if (diff < tmPacket)
|
||
{
|
||
tmPacket = diff;
|
||
}
|
||
}
|
||
|
||
|
||
int minimal = tmPacket < tmFlush ? tmPacket : tmFlush;
|
||
if (minimal >= interval)
|
||
{
|
||
minimal = interval;
|
||
}
|
||
|
||
return current + minimal;
|
||
}
|
||
|
||
|
||
public bool checkFlush()
|
||
{
|
||
if (ackcount > 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (probe != 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (sndBuf.Count > 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (sndQueue.Count > 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
public int setMtu(int mtu)
|
||
{
|
||
if (mtu < IKCP_OVERHEAD || mtu < 50)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (reserved >= mtu - IKCP_OVERHEAD || reserved < 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
this.mtu = mtu;
|
||
this.mss = mtu - IKCP_OVERHEAD - reserved;
|
||
return 0;
|
||
}
|
||
|
||
|
||
public int setInterval(int interval)
|
||
{
|
||
if (interval > 5000)
|
||
{
|
||
interval = 5000;
|
||
}
|
||
else if (interval < 10)
|
||
{
|
||
interval = 10;
|
||
}
|
||
|
||
this.interval = interval;
|
||
|
||
return 0;
|
||
}
|
||
|
||
public int initNodelay(bool nodelay, int interval, int resend, bool nc)
|
||
{
|
||
this.nodelay = nodelay;
|
||
if (nodelay)
|
||
{
|
||
this.rxMinrto = IKCP_RTO_NDL;
|
||
}
|
||
else
|
||
{
|
||
this.rxMinrto = IKCP_RTO_MIN;
|
||
}
|
||
|
||
if (interval >= 0)
|
||
{
|
||
if (interval > 5000)
|
||
{
|
||
interval = 5000;
|
||
}
|
||
else if (interval < 10)
|
||
{
|
||
interval = 10;
|
||
}
|
||
|
||
this.interval = interval;
|
||
}
|
||
|
||
if (resend >= 0)
|
||
{
|
||
fastresend = resend;
|
||
}
|
||
|
||
this.nocwnd = nc;
|
||
|
||
return 0;
|
||
}
|
||
|
||
public int waitSnd()
|
||
{
|
||
return this.sndBuf.Count + this.sndQueue.Count;
|
||
}
|
||
|
||
public void SetNodelay(bool nodelay)
|
||
{
|
||
this.nodelay = nodelay;
|
||
if (nodelay)
|
||
{
|
||
this.rxMinrto = IKCP_RTO_NDL;
|
||
}
|
||
else
|
||
{
|
||
this.rxMinrto = IKCP_RTO_MIN;
|
||
}
|
||
}
|
||
|
||
|
||
public void setAckMaskSize(int ackMaskSize)
|
||
{
|
||
this.ackMaskSize = ackMaskSize;
|
||
this.IKCP_OVERHEAD += (ackMaskSize / 8);
|
||
this.mss = mtu - IKCP_OVERHEAD - reserved;
|
||
}
|
||
|
||
public void setReserved(int reserved)
|
||
{
|
||
this.reserved = reserved;
|
||
this.mss = mtu - IKCP_OVERHEAD - reserved;
|
||
}
|
||
|
||
|
||
public int Conv
|
||
{
|
||
get => conv;
|
||
set => conv = value;
|
||
}
|
||
|
||
public int Mtu
|
||
{
|
||
get => mtu;
|
||
set => mtu = value;
|
||
}
|
||
|
||
public int Mss
|
||
{
|
||
get => mss;
|
||
set => mss = value;
|
||
}
|
||
|
||
public long SndUna
|
||
{
|
||
get => sndUna;
|
||
set => sndUna = value;
|
||
}
|
||
|
||
public long SndNxt
|
||
{
|
||
get => sndNxt;
|
||
set => sndNxt = value;
|
||
}
|
||
|
||
public long RcvNxt
|
||
{
|
||
get => rcvNxt;
|
||
set => rcvNxt = value;
|
||
}
|
||
|
||
public bool AckNoDelay
|
||
{
|
||
get => ackNoDelay;
|
||
set => ackNoDelay = value;
|
||
}
|
||
|
||
public object User
|
||
{
|
||
get => user;
|
||
set => user = value;
|
||
}
|
||
|
||
public int Fastresend
|
||
{
|
||
get => fastresend;
|
||
set => fastresend = value;
|
||
}
|
||
|
||
public bool Nocwnd
|
||
{
|
||
get => nocwnd;
|
||
set => nocwnd = value;
|
||
}
|
||
|
||
public bool Stream
|
||
{
|
||
get => stream;
|
||
set => stream = value;
|
||
}
|
||
|
||
public int RcvWnd
|
||
{
|
||
get => rcvWnd;
|
||
set => rcvWnd = value;
|
||
}
|
||
|
||
public int SndWnd
|
||
{
|
||
get => sndWnd;
|
||
set => sndWnd = value;
|
||
}
|
||
|
||
public int RxMinrto
|
||
{
|
||
get => rxMinrto;
|
||
set => rxMinrto = value;
|
||
}
|
||
|
||
public KcpOutput Output
|
||
{
|
||
get => output;
|
||
set => output = value;
|
||
}
|
||
|
||
public int Interval
|
||
{
|
||
get => interval;
|
||
set => interval = value;
|
||
}
|
||
|
||
public bool Nodelay
|
||
{
|
||
get => nodelay;
|
||
set => nodelay = value;
|
||
}
|
||
|
||
public int DeadLink
|
||
{
|
||
get => deadLink;
|
||
set => deadLink = value;
|
||
}
|
||
|
||
public IByteBufferAllocator ByteBufAllocator
|
||
{
|
||
get => byteBufAllocator;
|
||
set => byteBufAllocator = value;
|
||
}
|
||
|
||
public int State
|
||
{
|
||
get => state;
|
||
set => state = value;
|
||
}
|
||
}
|
||
} |