Use a bigger timeout when buffers are empty

Chacha20 will be automatically used if aesni is not available.

Makefile.am

@@ -16,7 +16,9 @@ glorytun_SOURCES = \
     src/tun.c \
     src/tun.h \
     src/db.c \
-    src/db.h
+    src/db.h \
+    src/state.c \
+    src/state.h
 
 EXTRA_DIST = \
     LICENSE \

README.md

@@ -1,4 +1,4 @@
-# Glorytun
+# π₁(Glorytun)=ℤ²
 
 Small, Simple and Stupid TCP VPN.
 
@@ -8,8 +8,7 @@ This code will probably format your harddisk!
 
 #### Build and Install
 
-Glorytun depends on [libsodium](https://github.com/jedisct1/libsodium) version >= 1.0.4
-and needs an AES-NI capable CPU.
+Glorytun depends on [libsodium](https://github.com/jedisct1/libsodium) version >= 1.0.4.
 
 To build and install the latest version:
 

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

@@ -6,6 +6,7 @@
 #include "option.h"
 #include "tun.h"
 #include "db.h"
+#include "state.h"
 
 #include <inttypes.h>
 #include <limits.h>
@@ -13,8 +14,8 @@
 #include <signal.h>
 #include <poll.h>
 #include <fcntl.h>
+#include <sys/socket.h>
 #include <sys/time.h>
-#include <sys/stat.h>
 
 #ifndef __FAVOR_BSD
 #define __FAVOR_BSD
@@ -39,11 +40,20 @@
 #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_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)
+
+#define GT_ABYTES    (16)
+#define GT_KEYBYTES  (32)
+
+#define MPTCP_ENABLED (26)
+
+static struct {
+    long timeout;
+    int mptcp;
+} gt;
 
 struct fdbuf {
     int fd;
@@ -53,10 +63,11 @@ struct fdbuf {
 
 struct crypto_ctx {
     struct {
-        crypto_aead_aes256gcm_state state;
-        uint8_t nonce[crypto_aead_aes256gcm_NPUBBYTES];
+        uint8_t key[512] _align_(16);
+        uint8_t nonce[16];
     } write, read;
     uint8_t skey[crypto_generichash_KEYBYTES];
+    int chacha;
 };
 
 volatile sig_atomic_t gt_close = 0;
@@ -100,6 +111,7 @@ enum sk_opt {
     sk_acceptfilter,
     sk_quickack,
     sk_user_timeout,
+    sk_mptcp,
 };
 
 static void sk_set (int fd, enum sk_opt opt, const void *val, socklen_t len)
@@ -154,6 +166,11 @@ static void sk_set (int fd, enum sk_opt opt, const void *val, socklen_t len)
         [sk_user_timeout] = { "TCP_USER_TIMEOUT",
 #ifdef TCP_USER_TIMEOUT
             1, IPPROTO_TCP, TCP_USER_TIMEOUT,
+#endif
+        },
+        [sk_mptcp] = { "MPTCP_ENABLED",
+#ifdef MPTCP_ENABLED
+            1, IPPROTO_TCP, MPTCP_ENABLED,
 #endif
         },
     };
@@ -176,6 +193,9 @@ static int sk_listen (int fd, struct addrinfo *ai)
 {
     sk_set_int(fd, sk_reuseaddr, 1);
 
+    if (gt.mptcp)
+        sk_set_int(fd, sk_mptcp, 1);
+
     if (bind(fd, ai->ai_addr, ai->ai_addrlen)==-1) {
         perror("bind");
         return -1;
@@ -187,10 +207,9 @@ static int sk_listen (int fd, struct addrinfo *ai)
     }
 
 #ifdef __linux__
-    sk_set_int(fd, sk_defer_accept, GT_TIMEOUT/1000);
+    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
 
@@ -199,10 +218,37 @@ static int sk_listen (int fd, struct addrinfo *ai)
 
 static int sk_connect (int fd, struct addrinfo *ai)
 {
+    fd_set_nonblock(fd);
+
+    if (gt.mptcp)
+        sk_set_int(fd, sk_mptcp, 1);
+
     int ret = connect(fd, ai->ai_addr, ai->ai_addrlen);
 
-    if (ret==-1 && errno==EINTR)
-        return 0;
+    if (ret==-1) {
+        if (errno==EINTR)
+            return 0;
+
+        if (errno==EINPROGRESS) {
+            struct pollfd pollfd = {
+                .fd = fd,
+                .events = POLLOUT,
+            };
+
+            if (!poll(&pollfd, 1, gt.timeout))
+                return -1;
+
+            int opt = 0;
+            socklen_t optlen = sizeof(opt);
+
+            getsockopt(fd, SOL_SOCKET, SO_ERROR, &opt, &optlen);
+
+            if (!opt)
+                return 0;
+
+            errno = opt;
+        }
+    }
 
     return ret;
 }
@@ -234,6 +280,8 @@ static int sk_accept (int fd)
     if (ret==-1 && errno!=EINTR)
         perror("accept");
 
+    fd_set_nonblock(ret);
+
     return ret;
 }
 
@@ -265,7 +313,7 @@ static char *sk_get_name (int fd)
         return NULL;
     }
 
-    const char *const strs[] = {
+    const char *strs[] = {
         host, ".", port
     };
 
@@ -387,15 +435,6 @@ static ssize_t fd_write (int fd, const void *data, size_t size)
     return ret;
 }
 
-static void state_write (int fd, const char *str)
-{
-    if (fd==-1) {
-        gt_print("state: %s", str);
-    } else {
-        fd_write(fd, str, str_len(str));
-    }
-}
-
 static size_t fd_read_all (int fd, void *data, size_t size)
 {
     size_t done = 0;
@@ -412,7 +451,7 @@ static size_t fd_read_all (int fd, void *data, size_t size)
                 .events = POLLIN,
             };
 
-            if (!poll(&pollfd, 1, GT_TIMEOUT))
+            if (!poll(&pollfd, 1, gt.timeout))
                 break;
 
             continue;
@@ -440,7 +479,7 @@ static size_t fd_write_all (int fd, const void *data, size_t size)
                 .events = POLLOUT,
             };
 
-            if (!poll(&pollfd, 1, GT_TIMEOUT))
+            if (!poll(&pollfd, 1, gt.timeout))
                 break;
 
             continue;
@@ -460,7 +499,7 @@ static int gt_encrypt (struct crypto_ctx *ctx, buffer_t *dst, buffer_t *src)
     if (!rs || !ws)
         return 0;
 
-    const size_t size = rs+crypto_aead_aes256gcm_ABYTES;
+    const size_t size = rs+GT_ABYTES;
 
     if (size+2>ws)
         return 0;
@@ -468,14 +507,25 @@ static int gt_encrypt (struct crypto_ctx *ctx, buffer_t *dst, buffer_t *src)
     dst->write[0] = 0xFF&(size>>8);
     dst->write[1] = 0xFF&(size);
 
-    crypto_aead_aes256gcm_encrypt_afternm(
-            dst->write+2, NULL,
-            src->read, rs,
-            dst->write, 2,
-            NULL, ctx->write.nonce,
-            (const crypto_aead_aes256gcm_state *)&ctx->write.state);
+    if (ctx->chacha) {
+        crypto_aead_chacha20poly1305_encrypt(
+                dst->write+2, NULL,
+                src->read, rs,
+                dst->write, 2,
+                NULL, ctx->write.nonce,
+                ctx->write.key);
 
-    sodium_increment(ctx->write.nonce, crypto_aead_aes256gcm_NPUBBYTES);
+        sodium_increment(ctx->write.nonce, crypto_aead_chacha20poly1305_NPUBBYTES);
+    } else {
+        crypto_aead_aes256gcm_encrypt_afternm(
+                dst->write+2, NULL,
+                src->read, rs,
+                dst->write, 2,
+                NULL, ctx->write.nonce,
+                (const crypto_aead_aes256gcm_state *)ctx->write.key);
+
+        sodium_increment(ctx->write.nonce, crypto_aead_aes256gcm_NPUBBYTES);
+    }
 
     src->read += rs;
     dst->write += size+2;
@@ -491,30 +541,43 @@ static int gt_decrypt (struct crypto_ctx *ctx, buffer_t *dst, buffer_t *src)
     if (!rs || !ws)
         return 0;
 
-    if (rs<=2+crypto_aead_aes256gcm_ABYTES)
+    if (rs<=2+GT_ABYTES)
         return 0;
 
     const size_t size = (src->read[0]<<8)|src->read[1];
 
-    if (size-crypto_aead_aes256gcm_ABYTES>ws)
+    if (size-GT_ABYTES>ws)
         return 0;
 
     if (size+2>rs)
         return 0;
 
-    if (crypto_aead_aes256gcm_decrypt_afternm(
-                dst->write, NULL,
-                NULL,
-                src->read+2, size,
-                src->read, 2,
-                ctx->read.nonce,
-                (const crypto_aead_aes256gcm_state *)&ctx->read.state))
-        return -1;
+    if (ctx->chacha) {
+        if (crypto_aead_chacha20poly1305_decrypt(
+                    dst->write, NULL,
+                    NULL,
+                    src->read+2, size,
+                    src->read, 2,
+                    ctx->read.nonce,
+                    ctx->read.key))
+            return -1;
 
-    sodium_increment(ctx->read.nonce, crypto_aead_aes256gcm_NPUBBYTES);
+        sodium_increment(ctx->read.nonce, crypto_aead_chacha20poly1305_NPUBBYTES);
+    } else {
+        if (crypto_aead_aes256gcm_decrypt_afternm(
+                    dst->write, NULL,
+                    NULL,
+                    src->read+2, size,
+                    src->read, 2,
+                    ctx->read.nonce,
+                    (const crypto_aead_aes256gcm_state *)ctx->read.key))
+            return -1;
+
+        sodium_increment(ctx->read.nonce, crypto_aead_aes256gcm_NPUBBYTES);
+    }
 
     src->read += size+2;
-    dst->write += size-crypto_aead_aes256gcm_ABYTES;
+    dst->write += size-GT_ABYTES;
 
     return 0;
 }
@@ -540,16 +603,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 0; // 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 +810,37 @@ 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] = {0};
+    char ip1[INET6_ADDRSTRLEN] = {0};
 
-    struct tcp_entry entry;
+    uint16_t port0 = 0;
+    uint16_t port1 = 0;
 
-    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 +914,78 @@ 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;
+    }
+
+    if (tcp.th_flags&TH_ACK) {
+        if (!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;
+            }
+
+            gt_print_entry(r_entry);
+
+            r_entry->data[1-rev].sa.base = tcp.th_ack;
+            r_entry->data[rev].sa.base = tcp.th_seq;
+        } else {
+            sa_rebase(&r_entry->data[1-rev].sa, tcp.th_ack);
+        }
+    }
+
+    if (!r_entry)
+        return 0;
+
+    uint32_t size = ic->size-ic->hdr_size-tcp.th_off*4;
+
+    if (!size)
+        return 0;
+
+    if (sa_have(&r_entry->data[rev].sa, tcp.th_seq, size)) {
+        r_entry->data[rev].retrans++;
+    } else {
+        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);
@@ -729,8 +995,7 @@ static int gt_setup_secretkey (struct crypto_ctx *ctx, char *keyfile)
 
         randombytes_buf(ctx->skey, size);
         gt_tohex(buf, sizeof(buf), ctx->skey, size);
-
-        gt_print("new secret key: %s\n", buf);
+        state("SECRETKEY", buf);
 
         return 0;
     }
@@ -766,17 +1031,16 @@ static int gt_setup_secretkey (struct crypto_ctx *ctx, char *keyfile)
 
 static int gt_setup_crypto (struct crypto_ctx *ctx, int fd, int listener)
 {
-    const uint8_t gt[] = {'G', 'T', VERSION_MAJOR, 0 };
+    const uint8_t proto[] = {'G', 'T', VERSION_MAJOR, (uint8_t)ctx->chacha };
 
     const size_t size = 96;
     const size_t hash_size = 32;
 
-    const size_t nonce_size = crypto_aead_aes256gcm_NPUBBYTES;
-    const size_t public_size = crypto_scalarmult_SCALARBYTES;
-
     uint8_t secret[crypto_scalarmult_SCALARBYTES];
     uint8_t shared[crypto_scalarmult_BYTES];
-    uint8_t key[crypto_aead_aes256gcm_KEYBYTES];
+
+    uint8_t key_r[GT_KEYBYTES];
+    uint8_t key_w[GT_KEYBYTES];
 
     uint8_t data_r[size], data_w[size];
     uint8_t auth_r[hash_size], auth_w[hash_size];
@@ -785,12 +1049,11 @@ static int gt_setup_crypto (struct crypto_ctx *ctx, int fd, int listener)
     crypto_generichash_state state;
 
     memset(data_w, 0, size);
-    randombytes_buf(data_w, nonce_size);
 
     randombytes_buf(secret, sizeof(secret));
-    crypto_scalarmult_base(&data_w[nonce_size], secret);
+    crypto_scalarmult_base(data_w, secret);
 
-    memcpy(&data_w[size-hash_size-sizeof(gt)], gt, sizeof(gt));
+    memcpy(&data_w[size-hash_size-sizeof(proto)], proto, sizeof(proto));
 
     crypto_generichash(&data_w[size-hash_size], hash_size,
             data_w, size-hash_size, ctx->skey, sizeof(ctx->skey));
@@ -801,9 +1064,12 @@ static int gt_setup_crypto (struct crypto_ctx *ctx, int fd, int listener)
     if (fd_read_all(fd, data_r, size)!=size)
         return -1;
 
-    if (memcmp(&data_r[size-hash_size-sizeof(gt)], gt, sizeof(gt)))
+    if (memcmp(&data_r[size-hash_size-sizeof(proto)], proto, 3))
         return -2;
 
+    if (data_r[size-hash_size-sizeof(proto)+3])
+        ctx->chacha = 1;
+
     crypto_generichash(hash, hash_size,
             data_r, size-hash_size, ctx->skey, sizeof(ctx->skey));
 
@@ -828,29 +1094,36 @@ static int gt_setup_crypto (struct crypto_ctx *ctx, int fd, int listener)
     if (sodium_memcmp(auth_r, hash, hash_size))
         return -2;
 
-    if (crypto_scalarmult(shared, secret, &data_r[nonce_size]))
+    if (crypto_scalarmult(shared, secret, data_r))
         return -2;
 
-    crypto_generichash_init(&state, ctx->skey, sizeof(ctx->skey), sizeof(key));
+    crypto_generichash_init(&state, ctx->skey, sizeof(ctx->skey), sizeof(key_r));
     crypto_generichash_update(&state, shared, sizeof(shared));
     crypto_generichash_update(&state, data_r, size);
     crypto_generichash_update(&state, data_w, size);
-    crypto_generichash_final(&state, key, sizeof(key));
-    crypto_aead_aes256gcm_beforenm(&ctx->read.state, key);
+    crypto_generichash_final(&state, key_r, sizeof(key_r));
 
-    crypto_generichash_init(&state, ctx->skey, sizeof(ctx->skey), sizeof(key));
+    crypto_generichash_init(&state, ctx->skey, sizeof(ctx->skey), sizeof(key_w));
     crypto_generichash_update(&state, shared, sizeof(shared));
     crypto_generichash_update(&state, data_w, size);
     crypto_generichash_update(&state, data_r, size);
-    crypto_generichash_final(&state, key, sizeof(key));
-    crypto_aead_aes256gcm_beforenm(&ctx->write.state, key);
+    crypto_generichash_final(&state, key_w, sizeof(key_w));
+
+    if (ctx->chacha) {
+        memcpy(ctx->read.key, key_r, sizeof(key_r));
+        memcpy(ctx->write.key, key_w, sizeof(key_w));
+    } else {
+        crypto_aead_aes256gcm_beforenm(&ctx->read.key, key_r);
+        crypto_aead_aes256gcm_beforenm(&ctx->write.key, key_w);
+    }
 
     sodium_memzero(secret, sizeof(secret));
     sodium_memzero(shared, sizeof(shared));
-    sodium_memzero(key, sizeof(key));
+    sodium_memzero(key_r, sizeof(key_r));
+    sodium_memzero(key_w, sizeof(key_w));
 
-    memcpy(ctx->read.nonce, data_r, nonce_size);
-    memcpy(ctx->write.nonce, data_w, nonce_size);
+    memset(ctx->read.nonce, 0, sizeof(ctx->read.nonce));
+    memset(ctx->write.nonce, 0, sizeof(ctx->write.nonce));
 
     return 0;
 }
@@ -866,7 +1139,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;
@@ -877,7 +1150,7 @@ int main (int argc, char **argv)
     long retry_const = 0;
     long retry_limit = 1000000;
 
-    long user_timeout = 0;
+    gt.timeout = 5000;
 
     struct option ka_opts[] = {
         { "count",    &ka_count,    option_long },
@@ -907,9 +1180,10 @@ int main (int argc, char **argv)
         { "buffer-size", &buffer_size,  option_long   },
         { "noquickack",  NULL,          option_option },
         { "retry",       &retry_opts,   option_option },
-        { "daemon",      NULL,          option_option },
         { "statefile",   &statefile,    option_str    },
-        { "timeout",     &user_timeout, option_long   },
+        { "timeout",     &gt.timeout,   option_long   },
+        { "chacha20",    NULL,          option_option },
+        { "mptcp",       NULL,          option_option },
         { "debug",       NULL,          option_option },
         { "version",     NULL,          option_option },
         { NULL },
@@ -929,9 +1203,13 @@ 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");
+    int chacha = option_is_set(opts, "chacha20");
+
+    gt.mptcp = option_is_set(opts, "mptcp");
+
+    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) {
@@ -944,8 +1222,8 @@ int main (int argc, char **argv)
             retry_count = 0;
     }
 
-    if (statefile && statefile[0]!='/') {
-        gt_log("statefile must be an absolute path\n");
+    if (gt.timeout<=0 || gt.timeout>INT_MAX) {
+        gt_log("bad timeout\n");
         return 1;
     }
 
@@ -954,9 +1232,9 @@ int main (int argc, char **argv)
         return 1;
     }
 
-    if (!crypto_aead_aes256gcm_is_available()) {
+    if (!chacha && !crypto_aead_aes256gcm_is_available()) {
         gt_na("AES-256-GCM");
-        return 1;
+        chacha = 1;
     }
 
     struct addrinfo *ai = ai_create(host, port, listener);
@@ -964,10 +1242,15 @@ int main (int argc, char **argv)
     if (!ai)
         return 1;
 
+    if (state_init(statefile))
+        return 1;
+
     struct fdbuf tun  = { .fd = -1 };
     struct fdbuf sock = { .fd = -1 };
 
-    tun.fd = tun_create(dev, option_is_set(opts, "multiqueue"));
+    char *tun_name = NULL;
+
+    tun.fd = tun_create(dev, &tun_name, option_is_set(opts, "multiqueue"));
 
     if (tun.fd==-1) {
         gt_log("couldn't create tun device\n");
@@ -996,50 +1279,10 @@ int main (int argc, char **argv)
     if (gt_setup_secretkey(&ctx, keyfile))
         return 1;
 
-    if (option_is_set(opts, "daemon")) {
-        switch (fork()) {
-        case -1:
-            perror("fork");
-            return 1;
-        case 0:
-            if (setsid()==-1)
-                perror("setsid");
-            break;
-        default:
-            _exit(0);
-        }
-
-        chdir("/");
-    }
-
-    int state_fd = -1;
-
-    if (statefile) {
-        state_fd = open(statefile, O_WRONLY);
-
-        if (state_fd==-1) {
-            if (errno!=EINTR)
-                perror("open statefile");
-            return 1;
-        }
-
-        struct stat st = {0};
-
-        if (fstat(state_fd, &st)==-1) {
-            perror("stat statefile");
-            return 1;
-        }
-
-        if (!S_ISFIFO(st.st_mode)) {
-            gt_log("`%s' is not a fifo\n", statefile);
-            return 1;
-        }
-    }
-
     long retry = 0;
     uint8_t *db = NULL;
 
-    state_write(state_fd, "INITIALIZED\n");
+    state("INITIALIZED", tun_name);
 
     while (!gt_close) {
         if (retry_count>=0 && retry>=retry_count+1) {
@@ -1075,8 +1318,6 @@ int main (int argc, char **argv)
 
         gt_log("%s: connected\n", sockname);
 
-        fd_set_nonblock(sock.fd);
-
         sk_set_int(sock.fd, sk_nodelay, !delay);
         sk_set_int(sock.fd, sk_keepalive, keepalive);
 
@@ -1091,11 +1332,11 @@ int main (int argc, char **argv)
                 sk_set_int(sock.fd, sk_keepintvl, ka_interval);
         }
 
-        if (user_timeout>0 && user_timeout<=INT_MAX)
-            sk_set_int(sock.fd, sk_user_timeout, user_timeout);
-
+        sk_set_int(sock.fd, sk_user_timeout, gt.timeout);
         sk_set(sock.fd, sk_congestion, congestion, str_len(congestion));
 
+        ctx.chacha = chacha;
+
         switch (gt_setup_crypto(&ctx, sock.fd, listener)) {
         case -2:
             gt_log("%s: key exchange could not be verified!\n", sockname);
@@ -1109,7 +1350,7 @@ int main (int argc, char **argv)
 
         retry = 0;
 
-        state_write(state_fd, "STARTED\n");
+        state("STARTED", sockname);
 
         fd_set rfds;
         FD_ZERO(&rfds);
@@ -1147,9 +1388,12 @@ int main (int argc, char **argv)
             }
 
             struct timeval timeout = {
-                .tv_usec = 1000,
+                .tv_usec = 100000,
             };
 
+            if (buffer_read_size(&sock.write))
+                timeout.tv_usec = 1000;
+
             if _0_(select(sock.fd+1, &rfds, NULL, NULL, &timeout)==-1) {
                 if (errno==EINTR)
                     continue;
@@ -1188,8 +1432,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 +1440,8 @@ int main (int argc, char **argv)
                 }
             }
 
+            buffer_shift(&sock.write);
+
             if _1_(!stop_loop)
                 gt_encrypt(&ctx, &sock.write, &tun.read);
 
@@ -1220,8 +1464,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);
@@ -1236,14 +1478,14 @@ int main (int argc, char **argv)
                 }
             }
 
+            buffer_shift(&tun.write);
+
+            if _0_(gt_decrypt(&ctx, &tun.write, &sock.read)) {
+                gt_log("%s: message could not be verified!\n", sockname);
+                goto restart;
+            }
+
             while (1) {
-                buffer_shift(&tun.write);
-
-                if _0_(gt_decrypt(&ctx, &tun.write, &sock.read)) {
-                    gt_log("%s: message could not be verified!\n", sockname);
-                    goto restart;
-                }
-
                 size_t size = buffer_read_size(&tun.write);
 
                 if (!size)
@@ -1257,8 +1499,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 +1508,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;
@@ -1277,17 +1518,17 @@ int main (int argc, char **argv)
         }
 
     restart:
-        if (sockname) {
-            free(sockname);
-            sockname = NULL;
-        }
-
         if (sock.fd!=-1) {
             close(sock.fd);
             sock.fd = -1;
         }
 
-        state_write(state_fd, "STOPPED\n");
+        state("STOPPED", sockname);
+
+        if (sockname) {
+            free(sockname);
+            sockname = NULL;
+        }
     }
 
     freeaddrinfo(ai);

src/state.c

@@ -0,0 +1,61 @@
+#include "common.h"
+
+#include "state.h"
+#include "str.h"
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+static int state_fd = -1;
+
+int state_init (const char *filename)
+{
+    if (str_empty(filename))
+        return 0;
+
+    state_fd = open(filename, O_WRONLY);
+
+    if (state_fd==-1) {
+        if (errno!=EINTR)
+            perror("open");
+        return -1;
+    }
+
+    struct stat st = {0};
+
+    if (fstat(state_fd, &st)==-1) {
+        perror("fstat");
+        close(state_fd);
+        state_fd = -1;
+        return -1;
+    }
+
+    if (!S_ISFIFO(st.st_mode)) {
+        gt_log("`%s' is not a fifo\n", filename);
+        close(state_fd);
+        state_fd = -1;
+        return -1;
+    }
+
+    return 0;
+}
+
+void state (const char *state, const char *info)
+{
+    if (str_empty(state))
+        return;
+
+    const char *strs[] = { state, " ", info, "\n" };
+    char *str = str_cat(strs, COUNT(strs));
+
+    if (!str)
+        return;
+
+    if (state_fd==-1) {
+        gt_print("%s", str);
+    } else {
+        if (write(state_fd, str, str_len(str))==-1 && errno!=EINTR)
+            perror("write");
+    }
+}

src/state.h

@@ -0,0 +1,4 @@
+#pragma once
+
+int  state_init (const char *);
+void state      (const char *, const char *);

src/str.h

@@ -47,7 +47,7 @@ static inline size_t str_len (const char *restrict str)
     return strlen(str);
 }
 
-static inline char *str_cat (const char *const strs[], size_t count)
+static inline char *str_cat (const char **strs, size_t count)
 {
     size_t size = 1;
 

src/tun.c

@@ -131,9 +131,9 @@ static int tun_create_by_id (char *name, size_t size, unsigned id, int mq)
 
 #endif
 
-int tun_create (char *dev_name, int mq)
+int tun_create (char *dev_name, char **ret_name, int mq)
 {
-    char name[64];
+    char name[64] = {0};
     int fd = -1;
 
 #ifndef IFF_MULTI_QUEUE
@@ -148,8 +148,8 @@ int tun_create (char *dev_name, int mq)
         fd = tun_create_by_name(name, sizeof(name), dev_name, mq);
     }
 
-    if (fd!=-1)
-        gt_print("tun name: %s\n", name);
+    if (fd!=-1 && ret_name)
+        *ret_name = strdup(name);
 
     return fd;
 }

src/tun.h

@@ -2,6 +2,6 @@
 
 #include <unistd.h>
 
-int     tun_create (char *, int);
+int     tun_create (char *, char **, int);
 ssize_t tun_read   (int, void *, size_t);
 ssize_t tun_write  (int, const void *, size_t);

version.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-[ -z "${VERSION}" ] && VERSION=`git describe --tags --always 2>/dev/null` \
+[ -z "${VERSION}" ] && VERSION=`git describe --tags --match='v[0-9].*' 2>/dev/null` \
                     && VERSION=${VERSION#v}
 
 [ -z "${VERSION}" ] && VERSION=`cat VERSION 2>/dev/null`