From 09e1a3495db2595bfd8047bbad85e65579e6ba8b Mon Sep 17 00:00:00 2001
From: skywind3000 <skywind3000@163.com>
Date: Mon, 7 May 2012 00:48:58 +0800
Subject: [PATCH] immigrant from my original project
http://code.google.com/p/ikcp
---
ikcp.c | 1182 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
ikcp.h | 379 +++++++++++++++++
test.cpp | 177 ++++++++
test.h | 241 +++++++++++
4 files changed, 1979 insertions(+)
create mode 100644 ikcp.c
create mode 100644 ikcp.h
create mode 100644 test.cpp
create mode 100644 test.h
diff --git a/ikcp.c b/ikcp.c
new file mode 100644
index 0000000..33eb18d
--- /dev/null
+++ b/ikcp.c
@@ -0,0 +1,1182 @@
+//=====================================================================
+//
+// KCP - A Better ARQ Protocol Implementation
+// skywind3000 (at) gmail.com, 2010-2011
+//
+// Features:
+// + Average RTT reduce 30% - 40% vs traditional ARQ like tcp.
+// + Maximum RTT reduce three times vs tcp.
+// + Lightweight, distributed as a single source file.
+//
+//=====================================================================
+#include "ikcp.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+
+
+//=====================================================================
+// KCP BASIC
+//=====================================================================
+const IUINT32 IKCP_RTO_NDL = 30; // no delay min rto
+const IUINT32 IKCP_RTO_MIN = 100; // normal min rto
+const IUINT32 IKCP_RTO_DEF = 200;
+const IUINT32 IKCP_RTO_MAX = 60000;
+const IUINT32 IKCP_CMD_PUSH = 81; // cmd: push data
+const IUINT32 IKCP_CMD_ACK = 82; // cmd: ack
+const IUINT32 IKCP_CMD_WASK = 83; // cmd: window probe (ask)
+const IUINT32 IKCP_CMD_WINS = 84; // cmd: window size (tell)
+const IUINT32 IKCP_ASK_SEND = 1; // need to send IKCP_CMD_WASK
+const IUINT32 IKCP_ASK_TELL = 2; // need to send IKCP_CMD_WINS
+const IUINT32 IKCP_WND_SND = 32;
+const IUINT32 IKCP_WND_RCV = 32;
+const IUINT32 IKCP_MTU_DEF = 1400;
+const IUINT32 IKCP_ACK_FAST = 3;
+const IUINT32 IKCP_INTERVAL = 100;
+const IUINT32 IKCP_OVERHEAD = 24;
+const IUINT32 IKCP_DEADLINK = 10;
+const IUINT32 IKCP_THRESH_INIT = 2;
+const IUINT32 IKCP_THRESH_MIN = 2;
+const IUINT32 IKCP_PROBE_INIT = 7000; // 7 secs to probe window size
+const IUINT32 IKCP_PROBE_LIMIT = 120000; // up to 120 secs to probe window
+
+
+//---------------------------------------------------------------------
+// encode / decode
+//---------------------------------------------------------------------
+
+/* encode 8 bits unsigned int */
+static inline char *ikcp_encode8u(char *p, unsigned char c)
+{
+ *(unsigned char*)p++ = c;
+ return p;
+}
+
+/* decode 8 bits unsigned int */
+static inline const char *ikcp_decode8u(const char *p, unsigned char *c)
+{
+ *c = *(unsigned char*)p++;
+ return p;
+}
+
+/* encode 16 bits unsigned int (lsb) */
+static inline char *ikcp_encode16u(char *p, unsigned short w)
+{
+#if IWORDS_BIG_ENDIAN
+ *(unsigned char*)(p + 0) = (w & 255);
+ *(unsigned char*)(p + 1) = (w >> 8);
+#else
+ *(unsigned short*)(p) = w;
+#endif
+ p += 2;
+ return p;
+}
+
+/* decode 16 bits unsigned int (lsb) */
+static inline const char *ikcp_decode16u(const char *p, unsigned short *w)
+{
+#if IWORDS_BIG_ENDIAN
+ *w = *(const unsigned char*)(p + 1);
+ *w = *(const unsigned char*)(p + 0) + (*w << 8);
+#else
+ *w = *(const unsigned short*)p;
+#endif
+ p += 2;
+ return p;
+}
+
+/* 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;
+}
+
+/* decode 32 bits unsigned int (lsb) */
+static inline const char *ikcp_decode32u(const char *p, IUINT32 *l)
+{
+#if IWORDS_BIG_ENDIAN
+ *l = *(const unsigned char*)(p + 3);
+ *l = *(const unsigned char*)(p + 2) + (*l << 8);
+ *l = *(const unsigned char*)(p + 1) + (*l << 8);
+ *l = *(const unsigned char*)(p + 0) + (*l << 8);
+#else
+ *l = *(const IUINT32*)p;
+#endif
+ p += 4;
+ return p;
+}
+
+static inline IUINT32 _imin_(IUINT32 a, IUINT32 b) {
+ return a <= b ? a : b;
+}
+
+static inline IUINT32 _imax_(IUINT32 a, IUINT32 b) {
+ return a >= b ? a : b;
+}
+
+static inline IUINT32 _ibound_(IUINT32 lower, IUINT32 middle, IUINT32 upper)
+{
+ return _imin_(_imax_(lower, middle), upper);
+}
+
+static inline long _itimediff(IUINT32 later, IUINT32 earlier)
+{
+ return ((IINT32)(later - earlier));
+}
+
+//---------------------------------------------------------------------
+// manage segment
+//---------------------------------------------------------------------
+typedef struct IKCPSEG IKCPSEG;
+
+static void* (*ikcp_malloc_hook)(size_t) = NULL;
+static void (*ikcp_free_hook)(void *) = NULL;
+
+// internal malloc
+static void* ikcp_malloc(size_t size) {
+ if (ikcp_malloc_hook)
+ return ikcp_malloc_hook(size);
+ return malloc(size);
+}
+
+// internal free
+static void ikcp_free(void *ptr) {
+ if (ikcp_free_hook) {
+ ikcp_free_hook(ptr);
+ } else {
+ free(ptr);
+ }
+}
+
+// redefine allocator
+void ikcp_allocator(void* (*new_malloc)(size_t), void (*new_free)(void*))
+{
+ ikcp_malloc_hook = new_malloc;
+ ikcp_free_hook = new_free;
+}
+
+// allocate a new kcp segment
+static IKCPSEG* ikcp_segment_new(ikcpcb *kcp, int size)
+{
+ return (IKCPSEG*)ikcp_malloc(sizeof(IKCPSEG) + size);
+}
+
+// delete a segment
+static void ikcp_segment_delete(ikcpcb *kcp, IKCPSEG *seg)
+{
+ ikcp_free(seg);
+}
+
+// write log
+void ikcp_log(ikcpcb *kcp, int mask, const char *fmt, ...)
+{
+ char buffer[1024];
+ va_list argptr;
+ if ((mask & kcp->logmask) == 0 || kcp->writelog == 0) return;
+ va_start(argptr, fmt);
+ vsprintf(buffer, fmt, argptr);
+ va_end(argptr);
+ kcp->writelog(buffer, kcp, kcp->user);
+}
+
+// check log mask
+static int ikcp_canlog(const ikcpcb *kcp, int mask)
+{
+ if ((mask & kcp->logmask) == 0 || kcp->writelog == NULL) return 0;
+ return 1;
+}
+
+// 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);
+}
+
+// output queue
+void ikcp_qprint(const char *name, const struct IQUEUEHEAD *head)
+{
+#if 0
+ const struct IQUEUEHEAD *p;
+ printf("<%s>: [", name);
+ for (p = head->next; p != head; p = p->next) {
+ const IKCPSEG *seg = iqueue_entry(p, const IKCPSEG, node);
+ printf("(%lu %d)", (unsigned long)seg->sn, (int)(seg->ts % 10000));
+ if (p->next != head) printf(",");
+ }
+ printf("]\n");
+#endif
+}
+
+
+//---------------------------------------------------------------------
+// create a new kcpcb
+//---------------------------------------------------------------------
+ikcpcb* ikcp_create(IUINT32 conv, void *user)
+{
+ ikcpcb *kcp = (ikcpcb*)ikcp_malloc(sizeof(struct IKCPCB));
+ if (kcp == NULL) return NULL;
+ kcp->conv = conv;
+ kcp->user = user;
+ kcp->snd_una = 0;
+ kcp->snd_nxt = 0;
+ kcp->rcv_nxt = 0;
+ kcp->ts_recent = 0;
+ kcp->ts_lastack = 0;
+ kcp->ts_probe = 0;
+ kcp->probe_wait = 0;
+ kcp->snd_wnd = IKCP_WND_SND;
+ kcp->rcv_wnd = IKCP_WND_RCV;
+ kcp->rmt_wnd = IKCP_WND_RCV;
+ kcp->cwnd = 0;
+ kcp->incr = 0;
+ kcp->probe = 0;
+ kcp->mtu = IKCP_MTU_DEF;
+ kcp->mss = kcp->mtu - IKCP_OVERHEAD;
+
+ kcp->buffer = (char*)ikcp_malloc((kcp->mtu + IKCP_OVERHEAD) * 3);
+ if (kcp->buffer == NULL) {
+ ikcp_free(kcp);
+ return NULL;
+ }
+
+ iqueue_init(&kcp->snd_queue);
+ iqueue_init(&kcp->rcv_queue);
+ iqueue_init(&kcp->snd_buf);
+ iqueue_init(&kcp->rcv_buf);
+ kcp->nrcv_buf = 0;
+ kcp->nsnd_buf = 0;
+ kcp->nrcv_que = 0;
+ kcp->nsnd_que = 0;
+ kcp->state = 0;
+ kcp->acklist = NULL;
+ kcp->ackblock = 0;
+ kcp->ackcount = 0;
+ kcp->rx_srtt = 0;
+ kcp->rx_rttval = 0;
+ kcp->rx_rto = IKCP_RTO_DEF;
+ kcp->rx_minrto = IKCP_RTO_MIN;
+ kcp->current = 0;
+ kcp->interval = IKCP_INTERVAL;
+ kcp->ts_flush = IKCP_INTERVAL;
+ kcp->nodelay = 0;
+ kcp->updated = 0;
+ kcp->logmask = 0;
+ kcp->ssthresh = IKCP_THRESH_INIT;
+ kcp->fastresend = 0;
+ kcp->nocwnd = 0;
+ kcp->xmit = 0;
+ kcp->dead_link = IKCP_DEADLINK;
+ kcp->output = NULL;
+ kcp->writelog = NULL;
+
+ return kcp;
+}
+
+
+//---------------------------------------------------------------------
+// release a new kcpcb
+//---------------------------------------------------------------------
+void ikcp_release(ikcpcb *kcp)
+{
+ assert(kcp);
+ if (kcp) {
+ IKCPSEG *seg;
+ while (!iqueue_is_empty(&kcp->snd_buf)) {
+ seg = iqueue_entry(kcp->snd_buf.next, IKCPSEG, node);
+ iqueue_del(&seg->node);
+ ikcp_segment_delete(kcp, seg);
+ }
+ while (!iqueue_is_empty(&kcp->rcv_buf)) {
+ seg = iqueue_entry(kcp->rcv_buf.next, IKCPSEG, node);
+ iqueue_del(&seg->node);
+ ikcp_segment_delete(kcp, seg);
+ }
+ while (!iqueue_is_empty(&kcp->snd_queue)) {
+ seg = iqueue_entry(kcp->snd_queue.next, IKCPSEG, node);
+ iqueue_del(&seg->node);
+ ikcp_segment_delete(kcp, seg);
+ }
+ while (!iqueue_is_empty(&kcp->rcv_queue)) {
+ seg = iqueue_entry(kcp->rcv_queue.next, IKCPSEG, node);
+ iqueue_del(&seg->node);
+ ikcp_segment_delete(kcp, seg);
+ }
+ if (kcp->buffer) {
+ ikcp_free(kcp->buffer);
+ }
+ if (kcp->acklist) {
+ ikcp_free(kcp->acklist);
+ }
+
+ kcp->nrcv_buf = 0;
+ kcp->nsnd_buf = 0;
+ kcp->nrcv_que = 0;
+ kcp->nsnd_que = 0;
+ kcp->ackcount = 0;
+ kcp->buffer = NULL;
+ kcp->acklist = NULL;
+ ikcp_free(kcp);
+ }
+}
+
+
+
+//---------------------------------------------------------------------
+// recv data
+//---------------------------------------------------------------------
+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);
+
+ // 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;
+ }
+ }
+
+ // 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;
+}
+
+
+//---------------------------------------------------------------------
+// send data
+//---------------------------------------------------------------------
+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;
+
+ 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;
+}
+
+
+//---------------------------------------------------------------------
+// send data
+//---------------------------------------------------------------------
+int ikcp_send(ikcpcb *kcp, const char *buffer, int len)
+{
+ IKCPSEG *seg;
+ int count, i;
+
+ assert(kcp->mss > 0);
+ if (len < 0) return -1;
+
+ if (len <= (int)kcp->mss) count = 1;
+ else count = (len + kcp->mss - 1) / kcp->mss;
+
+ if (count > 255) 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 = count - i - 1;
+ iqueue_init(&seg->node);
+ iqueue_add_tail(&seg->node, &kcp->snd_queue);
+ kcp->nsnd_que++;
+ if (buffer) {
+ buffer += size;
+ }
+ len -= size;
+ }
+
+ return 0;
+}
+
+
+//---------------------------------------------------------------------
+// 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_(1, 4 * kcp->rx_rttval);
+ kcp->rx_rto = _ibound_(kcp->rx_minrto, rto, IKCP_RTO_MAX);
+}
+
+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;
+ }
+}
+
+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;
+ }
+ else {
+ seg->fastack++;
+ }
+ }
+}
+
+static void ikcp_parse_una(ikcpcb *kcp, IUINT32 una)
+{
+#if 1
+ 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;
+ }
+ }
+#endif
+}
+
+
+//---------------------------------------------------------------------
+// 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++;
+}
+
+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];
+}
+
+
+//---------------------------------------------------------------------
+// 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
+}
+
+
+//---------------------------------------------------------------------
+// input data
+//---------------------------------------------------------------------
+int ikcp_input(ikcpcb *kcp, const char *data, long size)
+{
+ IUINT32 una = kcp->snd_una;
+
+ if (ikcp_canlog(kcp, IKCP_LOG_INPUT)) {
+ ikcp_log(kcp, IKCP_LOG_INPUT, "[RI] %d bytes", size);
+ }
+
+ if (data == NULL || size < 24) return 0;
+
+ while (1) {
+ IUINT32 ts, sn, len, una, conv;
+ IUINT16 wnd;
+ IUINT8 cmd, frg;
+ IKCPSEG *seg;
+
+ 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) return -2;
+
+ 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);
+
+ 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 (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);
+ }
+ }
+ 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);
+ }
+ }
+ }
+ 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;
+ if (ikcp_canlog(kcp, IKCP_LOG_IN_PROBE)) {
+ ikcp_log(kcp, IKCP_LOG_IN_PROBE, "input probe");
+ }
+ }
+ else if (cmd == IKCP_CMD_WINS) {
+ // do nothing
+ if (ikcp_canlog(kcp, IKCP_LOG_IN_WINS)) {
+ ikcp_log(kcp, IKCP_LOG_IN_WINS,
+ "input wins: %lu", (IUINT32)(wnd));
+ }
+ }
+ else {
+ return -3;
+ }
+
+ data += len;
+ size -= len;
+ }
+
+ 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;
+}
+
+
+//---------------------------------------------------------------------
+// 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;
+}
+
+static int ikcp_wnd_unused(const ikcpcb *kcp)
+{
+ if (kcp->nrcv_que < kcp->rcv_wnd) {
+ return kcp->rcv_wnd - kcp->nrcv_que;
+ }
+ return 0;
+}
+
+
+//---------------------------------------------------------------------
+// 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)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;
+
+ // probe window size (if remote window size equals zero)
+ if (kcp->rmt_wnd == 0) {
+ if (kcp->probe_wait == 0) {
+ kcp->probe_wait = IKCP_PROBE_INIT;
+ kcp->ts_probe = kcp->current + kcp->probe_wait;
+ }
+ else {
+ if (_itimediff(kcp->current, kcp->ts_probe) >= 0) {
+ if (kcp->probe_wait < IKCP_PROBE_INIT)
+ kcp->probe_wait = IKCP_PROBE_INIT;
+ kcp->probe_wait += kcp->probe_wait / 2;
+ if (kcp->probe_wait > IKCP_PROBE_LIMIT)
+ kcp->probe_wait = IKCP_PROBE_LIMIT;
+ kcp->ts_probe = kcp->current + kcp->probe_wait;
+ kcp->probe |= IKCP_ASK_SEND;
+ }
+ }
+ } else {
+ kcp->ts_probe = 0;
+ kcp->probe_wait = 0;
+ }
+
+ // flush window probing commands
+ if (kcp->probe & IKCP_ASK_SEND) {
+ seg.cmd = IKCP_CMD_WASK;
+ size = (int)(ptr - buffer);
+ if (size > (int)kcp->mtu) {
+ ikcp_output(kcp, buffer, size);
+ ptr = buffer;
+ }
+ ptr = ikcp_encode_seg(ptr, &seg);
+ }
+
+ // flush window probing commands
+ if (kcp->probe & IKCP_ASK_TELL) {
+ seg.cmd = IKCP_CMD_WINS;
+ size = (int)(ptr - buffer);
+ if (size > (int)kcp->mtu) {
+ ikcp_output(kcp, buffer, size);
+ ptr = buffer;
+ }
+ ptr = ikcp_encode_seg(ptr, &seg);
+ }
+
+ kcp->probe = 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;
+ }
+}
+
+
+//---------------------------------------------------------------------
+// input update
+//---------------------------------------------------------------------
+void ikcp_update(ikcpcb *kcp, IUINT32 current)
+{
+ IINT32 slap;
+
+ kcp->current = current;
+
+ if (kcp->updated == 0) {
+ kcp->updated = 1;
+ kcp->ts_flush = kcp->current;
+ }
+
+ slap = _itimediff(kcp->current, kcp->ts_flush);
+
+ if (slap >= 10000 || slap < -10000) {
+ kcp->ts_flush = kcp->current;
+ slap = 0;
+ }
+
+ 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);
+ }
+}
+
+
+IUINT32 ikcp_check(const ikcpcb *kcp, IUINT32 current)
+{
+ IUINT32 ts_flush = kcp->ts_flush;
+ IINT32 tm_flush = 0x7fffffff;
+ IINT32 tm_packet = 0x7fffffff;
+ IUINT32 minimal = 0;
+ struct IQUEUEHEAD *p;
+
+ if (kcp->updated == 0) {
+ return current;
+ }
+
+ if (_itimediff(current, ts_flush) >= 10000 ||
+ _itimediff(current, ts_flush) < -10000) {
+ ts_flush = current;
+ }
+
+ if (_itimediff(current, ts_flush) >= 0) {
+ return current;
+ }
+
+ tm_flush = _itimediff(ts_flush, current);
+
+ for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
+ const IKCPSEG *seg = iqueue_entry(p, const IKCPSEG, node);
+ IINT32 diff = _itimediff(seg->resendts, current);
+ if (diff <= 0) {
+ return current;
+ }
+ if (diff < tm_packet) tm_packet = diff;
+ }
+
+ minimal = (IUINT32)(tm_packet < tm_flush ? tm_packet : tm_flush);
+ if (minimal >= kcp->interval) minimal = kcp->interval;
+
+ return current + minimal;
+}
+
+
+
+int ikcp_setmtu(ikcpcb *kcp, int mtu)
+{
+ char *buffer;
+ if (mtu < 50 || mtu < (int)IKCP_OVERHEAD)
+ return -1;
+ buffer = (char*)ikcp_malloc((mtu + IKCP_OVERHEAD) * 3);
+ if (buffer == NULL)
+ return -2;
+ kcp->mtu = mtu;
+ kcp->mss = kcp->mtu - IKCP_OVERHEAD;
+ ikcp_free(kcp->buffer);
+ kcp->buffer = buffer;
+ return 0;
+}
+
+int ikcp_interval(ikcpcb *kcp, int interval)
+{
+ if (interval > 5000) interval = 5000;
+ else if (interval < 10) interval = 10;
+ kcp->interval = interval;
+ return 0;
+}
+
+int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc)
+{
+ if (nodelay >= 0) {
+ kcp->nodelay = nodelay;
+ if (nodelay) {
+ kcp->rx_minrto = IKCP_RTO_NDL;
+ }
+ else {
+ kcp->rx_minrto = IKCP_RTO_MIN;
+ }
+ }
+ if (interval >= 0) {
+ if (interval > 5000) interval = 5000;
+ else if (interval < 10) interval = 10;
+ kcp->interval = interval;
+ }
+ if (resend >= 0) {
+ kcp->fastresend = resend;
+ }
+ if (nc >= 0) {
+ kcp->nocwnd = nc;
+ }
+ return 0;
+}
+
+
+int ikcp_wndsize(ikcpcb *kcp, int sndwnd, int rcvwnd)
+{
+ if (kcp) {
+ if (sndwnd > 0) {
+ kcp->snd_wnd = sndwnd;
+ }
+ if (rcvwnd > 0) {
+ kcp->rcv_wnd = rcvwnd;
+ }
+ }
+ return 0;
+}
+
+int ikcp_waitsnd(const ikcpcb *kcp)
+{
+ return kcp->nsnd_buf + kcp->nsnd_que;
+}
+
+
diff --git a/ikcp.h b/ikcp.h
new file mode 100644
index 0000000..54d395c
--- /dev/null
+++ b/ikcp.h
@@ -0,0 +1,379 @@
+//=====================================================================
+//
+// KCP - A Better ARQ Protocol Implementation
+// skywind3000 (at) gmail.com, 2010-2011
+//
+// Features:
+// + Average RTT reduce 30% - 40% vs traditional ARQ like tcp.
+// + Maximum RTT reduce three times vs tcp.
+// + Lightweight, distributed as a single source file.
+//
+//=====================================================================
+#ifndef __IKCP_H__
+#define __IKCP_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+
+//=====================================================================
+// 32BIT INTEGER DEFINITION
+//=====================================================================
+#ifndef __INTEGER_32_BITS__
+#define __INTEGER_32_BITS__
+#if defined(_WIN64) || defined(WIN64) || defined(__amd64__) || \
+ defined(__x86_64) || defined(__x86_64__) || defined(_M_IA64) || \
+ defined(_M_AMD64)
+ typedef unsigned int ISTDUINT32;
+ typedef int ISTDINT32;
+#elif defined(_WIN32) || defined(WIN32) || defined(__i386__) || \
+ defined(__i386) || defined(_M_X86)
+ typedef unsigned long ISTDUINT32;
+ typedef long ISTDINT32;
+#elif defined(__MACOS__)
+ typedef UInt32 ISTDUINT32;
+ typedef SInt32 ISTDINT32;
+#elif defined(__APPLE__) && defined(__MACH__)
+ #include <sys/types.h>
+ typedef u_int32_t ISTDUINT32;
+ typedef int32_t ISTDINT32;
+#elif defined(__BEOS__)
+ #include <sys/inttypes.h>
+ typedef u_int32_t ISTDUINT32;
+ typedef int32_t ISTDINT32;
+#elif (defined(_MSC_VER) || defined(__BORLANDC__)) && (!defined(__MSDOS__))
+ typedef unsigned __int32 ISTDUINT32;
+ typedef __int32 ISTDINT32;
+#elif defined(__GNUC__)
+ #include <stdint.h>
+ typedef uint32_t ISTDUINT32;
+ typedef int32_t ISTDINT32;
+#else
+ typedef unsigned long ISTDUINT32;
+ typedef long ISTDINT32;
+#endif
+#endif
+
+
+//=====================================================================
+// Integer Definition
+//=====================================================================
+#ifndef __IINT8_DEFINED
+#define __IINT8_DEFINED
+typedef char IINT8;
+#endif
+
+#ifndef __IUINT8_DEFINED
+#define __IUINT8_DEFINED
+typedef unsigned char IUINT8;
+#endif
+
+#ifndef __IUINT16_DEFINED
+#define __IUINT16_DEFINED
+typedef unsigned short IUINT16;
+#endif
+
+#ifndef __IINT16_DEFINED
+#define __IINT16_DEFINED
+typedef short IINT16;
+#endif
+
+#ifndef __IINT32_DEFINED
+#define __IINT32_DEFINED
+typedef ISTDINT32 IINT32;
+#endif
+
+#ifndef __IUINT32_DEFINED
+#define __IUINT32_DEFINED
+typedef ISTDUINT32 IUINT32;
+#endif
+
+#ifndef __IINT64_DEFINED
+#define __IINT64_DEFINED
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef __int64 IINT64;
+#else
+typedef long long IINT64;
+#endif
+#endif
+
+#ifndef __IUINT64_DEFINED
+#define __IUINT64_DEFINED
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef unsigned __int64 IUINT64;
+#else
+typedef unsigned long long IUINT64;
+#endif
+#endif
+
+#ifndef INLINE
+#if defined(__GNUC__)
+
+#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+#define INLINE __inline__ __attribute__((always_inline))
+#else
+#define INLINE __inline__
+#endif
+
+#elif (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__))
+#define INLINE __inline
+#else
+#define INLINE
+#endif
+#endif
+
+#ifndef inline
+#define inline INLINE
+#endif
+
+
+//=====================================================================
+// QUEUE DEFINITION
+//=====================================================================
+#ifndef __IQUEUE_DEF__
+#define __IQUEUE_DEF__
+
+struct IQUEUEHEAD {
+ struct IQUEUEHEAD *next, *prev;
+};
+
+typedef struct IQUEUEHEAD iqueue_head;
+
+
+//---------------------------------------------------------------------
+// queue init
+//---------------------------------------------------------------------
+#define IQUEUE_HEAD_INIT(name) { &(name), &(name) }
+#define IQUEUE_HEAD(name) \
+ struct IQUEUEHEAD name = IQUEUE_HEAD_INIT(name)
+
+#define IQUEUE_INIT(ptr) ( \
+ (ptr)->next = (ptr), (ptr)->prev = (ptr))
+
+#define IOFFSETOF(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+
+#define ICONTAINEROF(ptr, type, member) ( \
+ (type*)( ((char*)((type*)ptr)) - IOFFSETOF(type, member)) )
+
+#define IQUEUE_ENTRY(ptr, type, member) ICONTAINEROF(ptr, type, member)
+
+
+//---------------------------------------------------------------------
+// queue operation
+//---------------------------------------------------------------------
+#define IQUEUE_ADD(node, head) ( \
+ (node)->prev = (head), (node)->next = (head)->next, \
+ (head)->next->prev = (node), (head)->next = (node))
+
+#define IQUEUE_ADD_TAIL(node, head) ( \
+ (node)->prev = (head)->prev, (node)->next = (head), \
+ (head)->prev->next = (node), (head)->prev = (node))
+
+#define IQUEUE_DEL_BETWEEN(p, n) ((n)->prev = (p), (p)->next = (n))
+
+#define IQUEUE_DEL(entry) (\
+ (entry)->next->prev = (entry)->prev, \
+ (entry)->prev->next = (entry)->next, \
+ (entry)->next = 0, (entry)->prev = 0)
+
+#define IQUEUE_DEL_INIT(entry) do { \
+ IQUEUE_DEL(entry); IQUEUE_INIT(entry); } while (0)
+
+#define IQUEUE_IS_EMPTY(entry) ((entry) == (entry)->next)
+
+#define iqueue_init IQUEUE_INIT
+#define iqueue_entry IQUEUE_ENTRY
+#define iqueue_add IQUEUE_ADD
+#define iqueue_add_tail IQUEUE_ADD_TAIL
+#define iqueue_del IQUEUE_DEL
+#define iqueue_del_init IQUEUE_DEL_INIT
+#define iqueue_is_empty IQUEUE_IS_EMPTY
+
+#define IQUEUE_FOREACH(iterator, head, TYPE, MEMBER) \
+ for ((iterator) = iqueue_entry((head)->next, TYPE, MEMBER); \
+ &((iterator)->MEMBER) != (head); \
+ (iterator) = iqueue_entry((iterator)->MEMBER.next, TYPE, MEMBER))
+
+#define iqueue_foreach(iterator, head, TYPE, MEMBER) \
+ IQUEUE_FOREACH(iterator, head, TYPE, MEMBER)
+
+#define iqueue_foreach_entry(pos, head) \
+ for( (pos) = (head)->next; (pos) != (head) ; (pos) = (pos)->next )
+
+
+#define __iqueue_splice(list, head) do { \
+ iqueue_head *first = (list)->next, *last = (list)->prev; \
+ iqueue_head *at = (head)->next; \
+ (first)->prev = (head), (head)->next = (first); \
+ (last)->next = (at), (at)->prev = (last); } while (0)
+
+#define iqueue_splice(list, head) do { \
+ if (!iqueue_is_empty(list)) __iqueue_splice(list, head); } while (0)
+
+#define iqueue_splice_init(list, head) do { \
+ iqueue_splice(list, head); iqueue_init(list); } while (0)
+
+
+#ifdef _MSC_VER
+#pragma warning(disable:4311)
+#pragma warning(disable:4312)
+#pragma warning(disable:4996)
+#endif
+
+#endif
+
+
+//---------------------------------------------------------------------
+// WORD ORDER
+//---------------------------------------------------------------------
+#ifndef IWORDS_BIG_ENDIAN
+ #ifdef _BIG_ENDIAN_
+ #if _BIG_ENDIAN_
+ #define IWORDS_BIG_ENDIAN 1
+ #endif
+ #endif
+ #ifndef IWORDS_BIG_ENDIAN
+ #if defined(__hppa__) || \
+ defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
+ (defined(__MIPS__) && defined(__MISPEB__)) || \
+ defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
+ defined(__sparc__)
+ #define IWORDS_BIG_ENDIAN 1
+ #endif
+ #endif
+ #ifndef IWORDS_BIG_ENDIAN
+ #define IWORDS_BIG_ENDIAN 0
+ #endif
+#endif
+
+
+
+//=====================================================================
+// 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];
+};
+
+
+//---------------------------------------------------------------------
+// IKCPCB
+//---------------------------------------------------------------------
+struct IKCPCB
+{
+ IUINT32 conv, mtu, mss, state;
+ IUINT32 snd_una, snd_nxt, rcv_nxt;
+ IUINT32 ts_recent, ts_lastack, ssthresh;
+ IINT32 rx_rttval, rx_srtt, rx_rto, rx_minrto;
+ IUINT32 snd_wnd, rcv_wnd, rmt_wnd, cwnd, probe;
+ IUINT32 current, interval, ts_flush, xmit;
+ IUINT32 nrcv_buf, nsnd_buf;
+ IUINT32 nrcv_que, nsnd_que;
+ IUINT32 nodelay, updated;
+ IUINT32 ts_probe, probe_wait;
+ IUINT32 dead_link, incr;
+ struct IQUEUEHEAD snd_queue;
+ struct IQUEUEHEAD rcv_queue;
+ struct IQUEUEHEAD snd_buf;
+ struct IQUEUEHEAD rcv_buf;
+ IUINT32 *acklist;
+ IUINT32 ackcount;
+ IUINT32 ackblock;
+ void *user;
+ char *buffer;
+ int fastresend;
+ int nocwnd;
+ int logmask;
+ int (*output)(const char *buf, int len, struct IKCPCB *kcp, void *user);
+ void (*writelog)(const char *log, struct IKCPCB *kcp, void *user);
+};
+
+
+typedef struct IKCPCB ikcpcb;
+
+#define IKCP_LOG_OUTPUT 1
+#define IKCP_LOG_INPUT 2
+#define IKCP_LOG_SEND 4
+#define IKCP_LOG_RECV 8
+#define IKCP_LOG_IN_DATA 16
+#define IKCP_LOG_IN_ACK 32
+#define IKCP_LOG_IN_PROBE 64
+#define IKCP_LOG_IN_WINS 128
+#define IKCP_LOG_OUT_DATA 256
+#define IKCP_LOG_OUT_ACK 512
+#define IKCP_LOG_OUT_PROBE 1024
+#define IKCP_LOG_OUT_WINS 2048
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//---------------------------------------------------------------------
+// interface
+//---------------------------------------------------------------------
+
+// create a new kcp control object, 'conv' must equal in two endpoint
+// from the same connection. 'user' will be passed to the output callback
+// output callback can be setup like this: 'kcp->output = my_udp_output'
+ikcpcb* ikcp_create(IUINT32 conv, void *user);
+
+// release kcp control object
+void ikcp_release(ikcpcb *kcp);
+
+int ikcp_recv(ikcpcb *kcp, char *buffer, int len);
+int ikcp_send(ikcpcb *kcp, const char *buffer, int len);
+
+// update state (call it repeatedly, every 10ms-100ms)
+// 'current' - current timestamp in millisec
+void ikcp_update(ikcpcb *kcp, IUINT32 current);
+IUINT32 ikcp_check(const ikcpcb *kcp, IUINT32 current);
+
+// when you received a low level packet (eg. UDP packet), call it
+int ikcp_input(ikcpcb *kcp, const char *data, long size);
+void ikcp_flush(ikcpcb *kcp);
+
+int ikcp_peeksize(const ikcpcb *kcp);
+
+// change MTU size, default is 14000
+int ikcp_setmtu(ikcpcb *kcp, int mtu);
+
+// set maximum window size: sndwnd=32, rcvwnd=32 by default
+int ikcp_wndsize(ikcpcb *kcp, int sndwnd, int rcvwnd);
+
+// get how many packet is waiting to be sent
+int ikcp_waitsnd(const ikcpcb *kcp);
+
+// fastest: ikcp_nodelay(kcp, 1, 20, 2, 1)
+// nodelay: 0:disable(default), 1:enable
+// interval: internal update timer interval in millisec, default is 100ms
+// resend: 0:disable fast resend(default), 1:enable fast resend
+// nc: 0:normal congestion control(default), 1:disable congestion control
+int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc);
+
+int ikcp_rcvbuf_count(const ikcpcb *kcp);
+int ikcp_sndbuf_count(const ikcpcb *kcp);
+
+void ikcp_log(ikcpcb *kcp, int mask, const char *fmt, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000..34f009d
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,177 @@
+//=====================================================================
+//
+// test.cpp - kcp ��������
+//
+// ˵����
+// gcc test.cpp -o test -lstdc++
+//
+//=====================================================================
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test.h"
+#include "ikcp.c"
+
+
+// ģ������
+LatencySimulator *vnet;
+
+// ģ�����磺ģ�ⷢ��һ�� udp��
+int udp_output(const char *buf, int len, ikcpcb *kcp, void *user)
+{
+ int id = (int)user;
+ vnet->send(id, buf, len);
+ return 0;
+}
+
+// ��������
+void test(int mode)
+{
+ // ����ģ�����磺������10%��Rtt 60ms~125ms
+ vnet = new LatencySimulator(10, 60, 125);
+
+ // ���������˵�� kcp����һ������ conv�ǻỰ��ţ�ͬһ���Ự��Ҫ��ͬ
+ // ���һ���� user�������������ݱ�ʶ
+ ikcpcb *kcp1 = ikcp_create(0x11223344, (void*)0);
+ ikcpcb *kcp2 = ikcp_create(0x11223344, (void*)1);
+
+ // ����kcp���²����������Ϊ udp_output��ģ��udp�����������
+ kcp1->output = udp_output;
+ kcp2->output = udp_output;
+
+ IUINT32 current = iclock();
+ IUINT32 slap = current + 20;
+ IUINT32 index = 0;
+ IUINT32 next = 0;
+ IINT64 sumrtt = 0;
+ int count = 0;
+ int maxrtt = 0;
+
+ // ���ô��ڴ�С��ƽ���ӳ�200ms��ÿ20ms����һ������
+ // �����ǵ������ط�����������շ�����Ϊ128
+ ikcp_wndsize(kcp1, 128, 128);
+ ikcp_wndsize(kcp2, 128, 128);
+
+ // �жϲ���������ģʽ
+ if (mode == 0) {
+ // Ĭ��ģʽ
+ ikcp_nodelay(kcp1, 0, 10, 0, 0);
+ ikcp_nodelay(kcp2, 0, 10, 0, 0);
+ }
+ else if (mode == 1) {
+ // ��ͨģʽ���ر����ص�
+ ikcp_nodelay(kcp1, 0, 10, 0, 1);
+ ikcp_nodelay(kcp2, 0, 10, 0, 1);
+ } else {
+ // ��������ģʽ
+ // �ڶ������� nodelay-�����Ժ����ɳ�����ٽ�����
+ // ���������� intervalΪ�ڲ�����ʱ�ӣ�Ĭ������Ϊ 10ms
+ // ���ĸ����� resendΪ�����ش�ָ�꣬����Ϊ2
+ // ��������� Ϊ�Ƿ���ó������أ������ֹ
+ ikcp_nodelay(kcp1, 1, 10, 2, 1);
+ ikcp_nodelay(kcp2, 1, 10, 2, 1);
+ }
+
+
+ char buffer[2000];
+ int hr;
+
+ IUINT32 ts1 = iclock();
+
+ while (1) {
+ isleep(1);
+ current = iclock();
+ ikcp_update(kcp1, iclock());
+ ikcp_update(kcp2, iclock());
+
+ // ÿ�� 20ms��kcp1��������
+ for (; current >= slap; slap += 20) {
+ *(IUINT32*)(buffer + 0) = index++;
+ *(IUINT32*)(buffer + 4) = current;
+
+ // �����ϲ�Э���
+ ikcp_send(kcp1, buffer, 8);
+ }
+
+ // �����������磺����Ƿ���udp����p1->p2
+ while (1) {
+ hr = vnet->recv(1, buffer, 2000);
+ if (hr < 0) break;
+ // ��� p2�յ�udp������Ϊ�²�Э�����뵽kcp2
+ ikcp_input(kcp2, buffer, hr);
+ }
+
+ // �����������磺����Ƿ���udp����p2->p1
+ while (1) {
+ hr = vnet->recv(0, buffer, 2000);
+ if (hr < 0) break;
+ // ��� p1�յ�udp������Ϊ�²�Э�����뵽kcp1
+ ikcp_input(kcp1, buffer, hr);
+ }
+
+ // kcp2���յ��κΰ������ػ�ȥ
+ while (1) {
+ hr = ikcp_recv(kcp2, buffer, 10);
+ // û���յ������˳�
+ if (hr < 0) break;
+ // ����յ����ͻ���
+ ikcp_send(kcp2, buffer, hr);
+ }
+
+ // kcp1�յ�kcp2�Ļ�������
+ while (1) {
+ hr = ikcp_recv(kcp1, buffer, 10);
+ // û���յ������˳�
+ if (hr < 0) break;
+ IUINT32 sn = *(IUINT32*)(buffer + 0);
+ IUINT32 ts = *(IUINT32*)(buffer + 4);
+ IUINT32 rtt = current - ts;
+
+ if (sn != next) {
+ // ����յ��İ�������
+ printf("ERROR sn %d<->%d\n", (int)count, (int)next);
+ return;
+ }
+
+ next++;
+ sumrtt += rtt;
+ count++;
+ if (rtt > maxrtt) maxrtt = rtt;
+
+ printf("[RECV] mode=%d sn=%d rtt=%d\n", mode, (int)sn, (int)rtt);
+ }
+ if (next > 1000) break;
+ }
+
+ ts1 = iclock() - ts1;
+
+ ikcp_release(kcp1);
+ ikcp_release(kcp2);
+
+ const char *names[3] = { "default", "normal", "fast" };
+ printf("%s mode result (%dms):\n", names[mode], ts1);
+ printf("avgrtt=%d maxrtt=%d\n", (int)(sumrtt / count), maxrtt);
+ printf("press enter to next ...\n");
+ char ch; scanf("%c", &ch);
+}
+
+int main()
+{
+ test(0); // Ĭ��ģʽ������ TCP������ģʽ�������ش�����������
+ test(1); // ��ͨģʽ���ر����ص�
+ test(2); // ����ģʽ�����п��ض����ҹر�����
+ return 0;
+}
+
+/*
+default mode result (20917ms):
+avgrtt=740 maxrtt=1507
+
+normal mode result (20131ms):
+avgrtt=156 maxrtt=571
+
+fast mode result (20207ms):
+avgrtt=138 maxrtt=392
+*/
+
diff --git a/test.h b/test.h
new file mode 100644
index 0000000..1c40a9b
--- /dev/null
+++ b/test.h
@@ -0,0 +1,241 @@
+#ifndef __TEST_H__
+#define __TEST_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "ikcp.h"
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#include <windows.h>
+#elif !defined(__unix)
+#define __unix
+#endif
+
+#ifdef __unix
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#endif
+
+/* get system time */
+static inline void itimeofday(long *sec, long *usec)
+{
+ #if defined(__unix)
+ struct timeval time;
+ gettimeofday(&time, NULL);
+ if (sec) *sec = time.tv_sec;
+ if (usec) *usec = time.tv_usec;
+ #else
+ static long mode = 0, addsec = 0;
+ BOOL retval;
+ static IINT64 freq = 1;
+ IINT64 qpc;
+ if (mode == 0) {
+ retval = QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
+ freq = (freq == 0)? 1 : freq;
+ retval = QueryPerformanceCounter((LARGE_INTEGER*)&qpc);
+ addsec = (long)time(NULL);
+ addsec = addsec - (long)((qpc / freq) & 0x7fffffff);
+ mode = 1;
+ }
+ retval = QueryPerformanceCounter((LARGE_INTEGER*)&qpc);
+ retval = retval * 2;
+ if (sec) *sec = (long)(qpc / freq) + addsec;
+ if (usec) *usec = (long)((qpc % freq) * 1000000 / freq);
+ #endif
+}
+
+/* get clock in millisecond 64 */
+static inline IINT64 iclock64(void)
+{
+ long s, u;
+ IINT64 value;
+ itimeofday(&s, &u);
+ value = ((IINT64)s) * 1000 + (u / 1000);
+ return value;
+}
+
+static inline IUINT32 iclock()
+{
+ return (IUINT32)(iclock64() & 0xfffffffful);
+}
+
+/* sleep in millisecond */
+static inline void isleep(unsigned long millisecond)
+{
+ #ifdef __unix /* usleep( time * 1000 ); */
+ struct timespec ts;
+ ts.tv_sec = (time_t)(millisecond / 1000);
+ ts.tv_nsec = (long)((millisecond % 1000) * 1000000);
+ /*nanosleep(&ts, NULL);*/
+ usleep((millisecond << 10) - (millisecond << 4) - (millisecond << 3));
+ #elif defined(_WIN32)
+ Sleep(millisecond);
+ #endif
+}
+
+#ifdef __cplusplus
+#include <list>
+#include <vector>
+
+// ���ӳٵ����ݰ�
+class DelayPacket
+{
+public:
+ virtual ~DelayPacket() {
+ if (_ptr) delete _ptr;
+ _ptr = NULL;
+ }
+
+ DelayPacket(int size, const void *src = NULL) {
+ _ptr = new unsigned char[size];
+ _size = size;
+ if (src) {
+ memcpy(_ptr, src, size);
+ }
+ }
+
+ unsigned char* ptr() { return _ptr; }
+ const unsigned char* ptr() const { return _ptr; }
+
+ int size() const { return _size; }
+ IUINT32 ts() const { return _ts; }
+ void setts(IUINT32 ts) { _ts = ts; }
+
+protected:
+ unsigned char *_ptr;
+ int _size;
+ IUINT32 _ts;
+};
+
+// ���ȷֲ��������
+class Random
+{
+public:
+ Random(int size) {
+ this->size = 0;
+ seeds.resize(size);
+ }
+
+ int random() {
+ int x, i;
+ if (seeds.size() == 0) return 0;
+ if (size == 0) {
+ for (i = 0; i < (int)seeds.size(); i++) {
+ seeds[i] = i;
+ }
+ size = (int)seeds.size();
+ }
+ i = rand() % size;
+ x = seeds[i];
+ seeds[i] = seeds[--size];
+ return x;
+ }
+
+protected:
+ int size;
+ std::vector<int> seeds;
+};
+
+// �����ӳ�ģ����
+class LatencySimulator
+{
+public:
+ virtual ~LatencySimulator() {
+ clear();
+ }
+
+ // lostrate: ����һ�ܶ����ʵİٷֱȣ�Ĭ�� 10%
+ // rttmin��rtt��Сֵ��Ĭ�� 60
+ // rttmax��rtt���ֵ��Ĭ�� 125
+ LatencySimulator(int lostrate = 10, int rttmin = 60, int rttmax = 125, int nmax = 1000):
+ r12(100), r21(100) {
+ current = iclock();
+ this->lostrate = lostrate / 2; // �������������������ʣ����̳���2
+ this->rttmin = rttmin / 2;
+ this->rttmax = rttmax / 2;
+ this->nmax = nmax;
+ }
+
+ // �������
+ void clear() {
+ DelayTunnel::iterator it;
+ for (it = p12.begin(); it != p12.end(); it++) {
+ delete *it;
+ }
+ for (it = p21.begin(); it != p21.end(); it++) {
+ delete *it;
+ }
+ p12.clear();
+ p21.clear();
+ }
+
+ // ��������
+ // peer - �˵�0/1����0���ͣ���1���գ���1���ʹ�0����
+ void send(int peer, const void *data, int size) {
+ if (peer == 0) {
+ if (r12.random() < lostrate) return;
+ if ((int)p12.size() >= nmax) return;
+ } else {
+ if (r21.random() < lostrate) return;
+ if ((int)p21.size() >= nmax) return;
+ }
+ DelayPacket *pkt = new DelayPacket(size, data);
+ current = iclock();
+ IUINT32 delay = rttmin;
+ if (rttmax > rttmin) delay += rand() % (rttmax - rttmin);
+ pkt->setts(current + delay);
+ if (peer == 0) {
+ p12.push_back(pkt);
+ } else {
+ p21.push_back(pkt);
+ }
+ }
+
+ // ��������
+ int recv(int peer, void *data, int maxsize) {
+ DelayTunnel::iterator it;
+ if (peer == 0) {
+ it = p21.begin();
+ if (p21.size() == 0) return -1;
+ } else {
+ it = p12.begin();
+ if (p12.size() == 0) return -1;
+ }
+ DelayPacket *pkt = *it;
+ current = iclock();
+ if (current < pkt->ts()) return -2;
+ if (maxsize < pkt->size()) return -3;
+ if (peer == 0) {
+ p21.erase(it);
+ } else {
+ p12.erase(it);
+ }
+ maxsize = pkt->size();
+ memcpy(data, pkt->ptr(), maxsize);
+ return maxsize;
+ }
+
+protected:
+ IUINT32 current;
+ int lostrate;
+ int rttmin;
+ int rttmax;
+ int nmax;
+ typedef std::list<DelayPacket*> DelayTunnel;
+ DelayTunnel p12;
+ DelayTunnel p21;
+ Random r12;
+ Random r21;
+};
+
+#endif
+
+#endif
+
+