The minimum value for buffer-size option is GT_PKT_MAX

Include <sys/socket.h> for AF_INET/AF_INET6 definitions

src/buffer.h

@@ -49,15 +49,18 @@ static inline size_t buffer_read_size (buffer_t *buffer)
 
 static inline void buffer_shift (buffer_t *buffer)
 {
+    if (buffer->read==buffer->data)
+        return;
+
     if (buffer->read==buffer->write) {
         buffer_format(buffer);
-    } else {
-        const uint8_t *src = PALIGN_DOWN(buffer->read);
-        const size_t size = ALIGN(buffer->write-src);
-        if (buffer->data+size<src) {
-            memcpy(buffer->data, src, size);
-            buffer->read  -= src-buffer->data;
-            buffer->write -= src-buffer->data;
-        }
+        return;
     }
+
+    const size_t size = buffer_read_size(buffer);
+
+    memmove(buffer->data, buffer->read, size);
+
+    buffer->read  = buffer->data;
+    buffer->write = buffer->data+size;
 }

src/main.c

@@ -13,6 +13,7 @@
 #include <signal.h>
 #include <poll.h>
 #include <fcntl.h>
+#include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/stat.h>
 
@@ -39,11 +40,11 @@
 #define O_CLOEXEC 0
 #endif
 
-#define GT_BUFFER_SIZE  (64*1024)
-#define GT_TIMEOUT      (5000)
-#define GT_MTU_MAX      (1500)
-#define GT_TUNR_SIZE    (0x7FFF-16)
-#define GT_TUNW_SIZE    (0x7FFF)
+#define GT_TIMEOUT   (5000)
+#define GT_MTU_MAX   (1500)
+#define GT_PKT_MAX   (32*1024)
+#define GT_TUNR_SIZE (GT_PKT_MAX-16-2)
+#define GT_TUNW_SIZE (GT_PKT_MAX)
 
 struct fdbuf {
     int fd;
@@ -189,8 +190,7 @@ static int sk_listen (int fd, struct addrinfo *ai)
 #ifdef __linux__
     sk_set_int(fd, sk_defer_accept, GT_TIMEOUT/1000);
 #else
-    char data[256] = {0};
-    str_cpy(data, "dataready", sizeof(data)-1);
+    char data[256] = "dataready";
     sk_set(fd, sk_acceptfilter, &data, sizeof(data));
 #endif
 
@@ -540,16 +540,166 @@ static inline uint16_t sum16_final (uint32_t sum)
     return ~(sum+(sum>>16));
 }
 
+struct seq_elem {
+    uint32_t seq;
+    uint32_t size;
+};
+
+struct seq_array {
+    struct seq_elem *elem;
+    uint32_t count;
+    uint32_t base;
+};
+
 struct tcp_entry {
     uint8_t key[37];
     struct {
-        uint32_t seq;
-        uint32_t ack;
-        size_t count;
-        struct timeval time;
+        struct seq_array sa;
+        size_t retrans;
     } data[2];
 };
 
+void tcp_entry_free (struct tcp_entry *te)
+{
+    free(te->data[0].sa.elem);
+    free(te->data[1].sa.elem);
+    free(te);
+}
+
+void sa_insert_elem (struct seq_array *sa, uint32_t i, uint32_t seq, uint32_t size)
+{
+    if (sa->count<i)
+        return;
+
+    if (!(sa->count&7)) {
+        struct seq_elem *tmp = realloc(sa->elem, (sa->count+8)*sizeof(struct seq_elem));
+
+        if (!tmp) {
+            gt_log("couldn't realloc!\n");
+            return;
+        }
+
+        sa->elem = tmp;
+    }
+
+    memmove(&sa->elem[i+1], &sa->elem[i], (sa->count-i)*sizeof(struct seq_elem));
+
+    sa->elem[i].seq = seq;
+    sa->elem[i].size = size;
+    sa->count++;
+}
+
+void sa_remove_elem (struct seq_array *sa, uint32_t i)
+{
+    if (sa->count<i+1)
+        return;
+
+    sa->count--;
+
+    memmove(&sa->elem[i], &sa->elem[i+1], (sa->count-i)*sizeof(struct seq_elem));
+}
+
+int sa_have (struct seq_array *sa, uint32_t seq, uint32_t size)
+{
+    uint32_t i;
+    uint32_t seqa = seq-sa->base;
+
+    for (i=0; i<sa->count; i++) {
+        uint32_t seqb = sa->elem[i].seq-sa->base;
+
+        if (seqb>=seqa) {
+            uint32_t d = seqb-seqa;
+
+            if (d>size)
+                return 0;
+        } else {
+            uint32_t d = seqa-seqb;
+
+            if (d>=sa->elem[i].size)
+                continue;
+
+            if (d+size>sa->elem[i].size) {
+                gt_print("sa_have:part\n");
+                return 1; // XXX 0
+            }
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+void sa_rebase (struct seq_array *sa, uint32_t seq)
+{
+    if (!sa->count)
+        return;
+
+    if (seq==sa->base)
+        return;
+
+    uint32_t size = seq-sa->elem[0].seq;
+
+    if (size==sa->elem[0].size) {
+        sa_remove_elem(sa, 0);
+    } else {
+        if (size>sa->elem[0].size)
+            return;
+        sa->elem[0].seq = seq;
+        sa->elem[0].size -= size;
+    }
+
+    sa->base = seq;
+}
+
+void sa_insert (struct seq_array *sa, uint32_t seq, uint32_t size)
+{
+    uint32_t i;
+    uint32_t seqa = seq-sa->base;
+
+    for (i=0; i<sa->count; i++) {
+        uint32_t seqb = sa->elem[i].seq-sa->base;
+
+        if (seqb>=seqa) {
+            uint32_t d = seqb-seqa;
+
+            if (d>size)
+                break;
+
+            sa->elem[i].seq = seq;
+
+            uint32_t new_size = sa->elem[i].size+d;
+
+            if (new_size>size) {
+                sa->elem[i].size = new_size;
+            } else {
+                sa->elem[i].size = size;
+            }
+        } else {
+            uint32_t d = seqa-seqb;
+
+            if (d>sa->elem[i].size)
+                continue;
+
+            uint32_t new_size = size+d;
+
+            if (new_size>sa->elem[i].size)
+                sa->elem[i].size = new_size;
+        }
+
+        if (i+1<sa->count) {
+            if (seqb+sa->elem[i].size==sa->elem[i+1].seq-sa->base) {
+                sa->elem[i].size += sa->elem[i+1].size;
+                sa_remove_elem(sa, i+1);
+            }
+        }
+
+        return;
+    }
+
+    sa_insert_elem(sa, i, seq, size);
+}
+
 static int tcp_entry_set_key (struct tcp_entry *te, struct ip_common *ic, uint8_t *data)
 {
     uint8_t *key = &te->key[1];
@@ -597,56 +747,36 @@ static int tcp_entry_set_key_rev (struct tcp_entry *te, struct ip_common *ic, ui
     return 0;
 }
 
-static int gt_track (uint8_t **db, struct ip_common *ic, uint8_t *data, int rev)
+static void gt_print_entry (struct tcp_entry *te)
 {
-    if (ic->proto!=IPPROTO_TCP)
-        return 0;
+    uint8_t *key = &te->key[1];
+    size_t size = te->key[0];
 
-    if (!ic->hdr_size)
-        return 1;
+    char ip0[INET6_ADDRSTRLEN];
+    char ip1[INET6_ADDRSTRLEN];
 
-    struct tcp_entry entry;
+    uint16_t port0, port1;
 
-    if (rev) {
-        tcp_entry_set_key_rev(&entry, ic, data);
-    } else {
-        tcp_entry_set_key(&entry, ic, data);
+    switch (size) {
+    case 8+4:
+        inet_ntop(AF_INET, key, ip0, sizeof(ip0));
+        inet_ntop(AF_INET, key+4, ip1, sizeof(ip1));
+        port0 = (key[8]<<8)|key[9];
+        port1 = (key[10]<<8)|key[11];
+        break;
+    case 32+4:
+        inet_ntop(AF_INET6, key,  ip0, sizeof(ip0));
+        inet_ntop(AF_INET6, key+16, ip1, sizeof(ip1));
+        port0 = (key[32]<<8)|key[33];
+        port1 = (key[34]<<8)|key[35];
+        break;
     }
 
-    struct tcphdr tcp;
-    memcpy(&tcp, &data[ic->hdr_size], sizeof(tcp));
-    tcp.th_seq = ntohl(tcp.th_seq);
-    tcp.th_ack = ntohl(tcp.th_ack);
-
-    struct tcp_entry *r_entry = (void *)db_search(db, entry.key);
-
-    if (!r_entry) {
-        r_entry = calloc(1, sizeof(entry));
-
-        if (!r_entry)
-            return 1;
-
-        memcpy(r_entry->key, entry.key, sizeof(entry.key));
-
-        if (!db_insert(db, r_entry->key)) {
-            free(r_entry);
-            return 1;
-        }
-
-        gt_print("new tcp entry\n");
-    } else {
-        gt_print("old_seq:%u\told_ack:%u\tcount:%zu\n",
-                r_entry->data[rev].seq,
-                r_entry->data[rev].ack,
-                r_entry->data[rev].count);
-    }
-
-    r_entry->data[rev].seq = tcp.th_seq;
-    r_entry->data[rev].ack = tcp.th_ack;
-    r_entry->data[rev].count++;
-    gettimeofday(&r_entry->data[rev].time, NULL);
-
-    return 0;
+    gt_print("connection:%s.%hu-%s.%hu\t"
+             "retrans:%zu, %zu\n",
+             ip0, port0, ip1, port1,
+             te->data[0].retrans,
+             te->data[1].retrans);
 }
 
 static void gt_print_hdr (struct ip_common *ic, uint8_t *data)
@@ -720,6 +850,75 @@ static void gt_print_hdr (struct ip_common *ic, uint8_t *data)
     }
 }
 
+static int gt_track (uint8_t **db, struct ip_common *ic, uint8_t *data, int rev)
+{
+    if (ic->proto!=IPPROTO_TCP)
+        return 0;
+
+    if (!ic->hdr_size)
+        return 1;
+
+    struct tcp_entry entry;
+
+    if (rev) {
+        tcp_entry_set_key_rev(&entry, ic, data);
+    } else {
+        tcp_entry_set_key(&entry, ic, data);
+    }
+
+    struct tcphdr tcp;
+    memcpy(&tcp, &data[ic->hdr_size], sizeof(tcp));
+    tcp.th_seq = ntohl(tcp.th_seq);
+    tcp.th_ack = ntohl(tcp.th_ack);
+
+    struct tcp_entry *r_entry = (void *)db_search(db, entry.key);
+
+    if (tcp.th_flags&(TH_FIN|TH_RST)) {
+        if (r_entry) {
+            gt_print_entry(r_entry);
+            db_remove(db, entry.key);
+            tcp_entry_free(r_entry);
+        }
+        return 0;
+    }
+
+    uint32_t size = ic->size-ic->hdr_size-tcp.th_off*4;
+
+    if (size && !r_entry) {
+        r_entry = calloc(1, sizeof(entry));
+
+        if (!r_entry)
+            return 0;
+
+        memcpy(r_entry->key, entry.key, sizeof(entry.key));
+
+        if (!db_insert(db, r_entry->key)) {
+            free(r_entry);
+            return 0;
+        }
+    }
+
+    if (!r_entry)
+        return 0;
+
+    if (r_entry->data[1-rev].sa.count && (tcp.th_flags&TH_ACK))
+        sa_rebase(&r_entry->data[1-rev].sa, tcp.th_ack);
+
+    if (!size)
+        return 0;
+
+    if (r_entry->data[rev].sa.count) {
+        if (sa_have(&r_entry->data[rev].sa, tcp.th_seq, size))
+            r_entry->data[rev].retrans++;
+    } else {
+        r_entry->data[rev].sa.base = tcp.th_seq;
+    }
+
+    sa_insert(&r_entry->data[rev].sa, tcp.th_seq, size);
+
+    return 0;
+}
+
 static int gt_setup_secretkey (struct crypto_ctx *ctx, char *keyfile)
 {
     const size_t size = sizeof(ctx->skey);
@@ -866,7 +1065,7 @@ int main (int argc, char **argv)
     char *congestion = NULL;
     char *statefile = NULL;
 
-    long buffer_size = GT_BUFFER_SIZE;
+    long buffer_size = GT_PKT_MAX;
 
     long ka_count = -1;
     long ka_idle = -1;
@@ -929,9 +1128,9 @@ int main (int argc, char **argv)
     const int noquickack = option_is_set(opts, "noquickack");
     const int debug = option_is_set(opts, "debug");
 
-    if (buffer_size < 2048) {
-        buffer_size = 2048;
-        gt_log("buffer size must be greater than 2048\n");
+    if (buffer_size < GT_PKT_MAX) {
+        buffer_size = GT_PKT_MAX;
+        gt_log("buffer size must be greater than or equal to %li\n", buffer_size);
     }
 
     if (!listener) {
@@ -1188,8 +1387,6 @@ int main (int argc, char **argv)
                     }
 
                     if _0_(debug) {
-                        gt_print_hdr(&ic, tun.read.write);
-
                         if (gt_track(&db, &ic, tun.read.write, 0))
                             continue;
                     }
@@ -1198,6 +1395,8 @@ int main (int argc, char **argv)
                 }
             }
 
+            buffer_shift(&sock.write);
+
             if _1_(!stop_loop)
                 gt_encrypt(&ctx, &sock.write, &tun.read);
 
@@ -1220,8 +1419,6 @@ int main (int argc, char **argv)
                 }
             }
 
-            buffer_shift(&sock.write);
-
             if (FD_ISSET(sock.fd, &rfds)) {
                 if (noquickack)
                     sk_set_int(sock.fd, sk_quickack, 0);
@@ -1257,8 +1454,6 @@ int main (int argc, char **argv)
                 }
 
                 if _0_(debug) {
-                    gt_print_hdr(&ic, tun.write.read);
-
                     if (gt_track(&db, &ic, tun.write.read, 1)) {
                         tun.write.read += ic.size;
                         continue;
@@ -1268,7 +1463,8 @@ int main (int argc, char **argv)
                 ssize_t r = tun_write(tun.fd, tun.write.read, ic.size);
 
                 if (r>0) {
-                    tun.write.read += r;
+                    if (r==ic.size)
+                        tun.write.read += r;
                 } else {
                     gt_close |= !r;
                     break;