switch to libsodium aegis256 implementation

Signed-off-by: Adrien Gallouët <adrien@gallouet.fr>

.github/workflows/build.yml

@@ -0,0 +1,24 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest]
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Build glorytun
+      run: |
+          git submodule update --init --recursive
+          ./sodium.sh
+          make prefix=. install
+
+    - uses: actions/upload-artifact@v1
+      with:
+        name: ${{ matrix.os }}
+        path: ./bin

.gitignore

@@ -1,4 +1,4 @@
-*.o
+*.[ios]
 *.log
 *.scan
 *.cache
@@ -10,6 +10,7 @@ configure
 build-aux
 .deps
 .dirstamp
+.static
 glorytun
 build*
 VERSION

.gitmodules

@@ -1,8 +1,7 @@
-[submodule "mud"]
-	path = mud
-	url = https://github.com/angt/mud.git
-	ignore = dirty
 [submodule "argz"]
 	path = argz
 	url = https://github.com/angt/argz.git
 	ignore = dirty
+[submodule "mud"]
+	path = mud
+	url = https://git.miegl.cz/miegl/mud.git

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2015-2019, Adrien Gallouët <adrien@gallouet.fr>
+Copyright (c) 2015-2020, Adrien Gallouët <adrien@gallouet.fr>
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile

@@ -2,31 +2,39 @@ NAME    := glorytun
 VERSION := $(shell ./version.sh)
 DIST    := $(NAME)-$(VERSION)
 
-DESTDIR ?=
-CC      ?= gcc
-INSTALL ?= install
-prefix  ?= /usr
 CFLAGS  ?= -std=c11 -O2 -Wall -fstack-protector-strong
+FLAGS   := $(CFLAGS) $(LDFLAGS) $(CPPFLAGS)
+
+CC      ?= cc
+prefix  ?= /usr
+Q       := @
+
+ifneq ($(X),)
+    H = $(X)-
+    FLAGS += -static
+endif
 
-FLAGS := $(CFLAGS) $(LDFLAGS) $(CPPFLAGS)
 FLAGS += -DPACKAGE_NAME=\"$(NAME)\" -DPACKAGE_VERSION=\"$(VERSION)\"
+FLAGS += -I.static/$(X)/libsodium-stable/src/libsodium/include
+FLAGS += -L.static/$(X)/libsodium-stable/src/libsodium/.libs
 
 SRC := argz/argz.c mud/mud.c $(wildcard src/*.c)
+HDR := argz/argz.h mud/mud.h $(wildcard src/*.h)
 
-.PHONY: $(NAME)
+$(NAME): $(SRC) $(HDR)
-$(NAME):
+	$(Q)$(H)$(CC) $(FLAGS) -o $(NAME) $(SRC) -lsodium
-	@echo "Building $(NAME)"
+
-	@$(CC) $(FLAGS) -o $(NAME) $(SRC) -lsodium -lm
+$(NAME)-strip: $(NAME)
+	$(Q)cp $< $@
+	$(Q)$(H)strip -x $@
 
 .PHONY: install
-install: $(NAME)
+install: $(NAME)-strip
-	@echo "Installing $(NAME)"
+	@echo "$(DESTDIR)$(prefix)/bin/$(NAME)"
-	@$(INSTALL) -m 755 -d $(DESTDIR)$(prefix)/bin
+	$(Q)install -m 755 -d $(DESTDIR)$(prefix)/bin
-	@$(INSTALL) -m 755 -s $(NAME) $(DESTDIR)$(prefix)/bin
+	$(Q)install -m 755 $(NAME)-strip $(DESTDIR)$(prefix)/bin/$(NAME)
 
-.PHONY: dist
+.PHONY: clean
-dist:
+clean:
-	@echo "Building $(DIST).tar.gz"
+	$(Q)rm -f "$(NAME)"
-	@(git --git-dir=.git ls-files --recurse-submodules -- ':!:.*' ':!:**/.*' && echo VERSION) | ( \
+	$(Q)rm -f "$(DIST).tar.gz"
-	    tar zcf $(DIST).tar.gz -T- --transform 's:^:$(DIST)/:' || \
-	    tar zcf $(DIST).tar.gz -T- -s ':^:$(DIST)/:' ) 2>/dev/null

Makefile.am

@@ -19,21 +19,25 @@ glorytun_SOURCES = \
     src/iface.h \
     src/ip.h \
     src/keygen.c \
+    src/list.c \
     src/main.c \
     src/path.c \
     src/set.c \
     src/show.c \
     src/str.h \
     src/tun.c \
-    src/tun.h
+    src/tun.h \
+    src/version.c
 
 EXTRA_DIST = \
     LICENSE \
+    Makefile \
     README.md \
     VERSION \
     autogen.sh \
     meson.build \
     mud/LICENSE \
     mud/README.md \
+    sodium.sh \
     systemd \
     version.sh

README.md

@@ -2,6 +2,8 @@
 
 Glorytun is a small, simple and secure VPN over [mud](https://github.com/angt/mud).
 
+Please visit the [wiki](https://github.com/angt/glorytun/wiki) for how-to guides, tutorials, etc.
+
 ## Compatibility
 
 Glorytun only depends on [libsodium](https://github.com/jedisct1/libsodium) version >= 1.0.4.
@@ -11,6 +13,7 @@ Linux is the platform of choice but the code is standard so it should be easily
 It was successfully tested on OpenBSD, FreeBSD and MacOS.
 
 IPv4 and IPv6 are supported.
+On Linux you can have both at the same time by binding `::`.
 
 ## Features
 
@@ -18,18 +21,19 @@ The key features of Glorytun come directly from mud:
 
  * **Fast and highly secure**
 
-   The use of UDP and [libsodium](https://github.com/jedisct1/libsodium) allows you to secure
+   Glorytun uses a new and very fast AEAD construction called AEGIS-256 if AES-NI is available otherwise ChaCha20-Poly1305 is used.
-   your communications without impacting performance.
+   Of course, you can force the use of ChaCha20-Poly1305 for higher security.
-   Glorytun uses AES only if AES-NI is available otherwise ChaCha20 is used.
+   All messages are encrypted, authenticated and timestamped to mitigate a large set of attacks.
-   If you are not cpu bounded, you can force the use of ChaCha20 for higher security.
+   This implies that the client and the server must be synchronized, an offset of 10min is accepted by default.
-   All messages are encrypted, authenticated and marked with a timestamp.
+   Perfect forward secrecy is also implemented with ECDH over Curve25519. Keys are rotated every hours.
-   Perfect forward secrecy is also implemented with ECDH over Curve25519.
 
- * **Multipath and active failover**
+ * **Multipath and failover**
 
-   This is the main feature of Glorytun that allows to build an SD-WAN like service.
+   Connectivity is now crucial, especially in the SD-WAN world.
-   This allows a TCP connection to explore and exploit multiple links without being disconnected.
+   This feature allows a TCP connection (and all other protocols) to explore and exploit all available links without being disconnected.
-   Aggregation should work on all conventional links, only very high latency (+500ms) links are not recommended for now.
+   Aggregation should work on all conventional links.
+   Only very high latency (+500ms) links are not recommended for now.
+   Backup paths are also supported, they will be used only in case of emergency, it is useful when aggregation is not your priority.
 
  * **Traffic shaping**
 
@@ -41,93 +45,9 @@ The key features of Glorytun come directly from mud:
 
    Bad MTU configuration is a very common problem in the world of VPN.
    As it is critical, Glorytun will try to setup it correctly by guessing its value.
-   It doesn't rely on ICMP Next-hop MTU to avoid black holes.
+   It doesn't rely on Next-hop MTU to avoid ICMP black holes.
    In asymmetric situations the minimum MTU is selected.
 
-## Caveats
-
-Glorytun is strongly secure by default and protects against replay attacks,
-the clock between the client and the server must be synchronized.
-By default, an offset of 10min is accepted.
-
-## Build and Install
-
-You will need `git`, `make`, `gcc` and `libsodium`:
-
-    $ sudo apt install git make gcc libsodium-dev    # debian based
-    $ sudo yum install git make gcc libsodium-devel  # redhat based
-
-To build and install the latest release from github:
-
-    $ git clone https://github.com/angt/glorytun --recursive
-    $ cd glorytun
-    $ sudo make install
-
-This will install the binary in `/usr/bin` by default.
-
-The more classical autotools suite is also available.
-
-## Usage
-
-Just run `glorytun` with no arguments to view the list of available commands:
-
-```
-$ glorytun
-available commands:
-
-  show     show all running tunnels
-  bench    start a crypto bench
-  bind     start a new tunnel
-  set      change tunnel properties
-  keygen   generate a new secret key
-  path     manage paths
-  version  show version
-
-```
-
-Use the keyword `help` after a command to show its usage.
-
-## Mini HowTo
-
-Glorytun does not touch the configuration of its network interface (except for the MTU),
-It is up to the user to do it according to the tools available
-on his system (systemd-networkd, netifd, ...).
-This also allows a wide variety of configurations.
-
-To start a server:
-
-    # (umask 066; glorytun keygen > my_secret_key)
-    # glorytun bind 0.0.0.0 keyfile my_secret_key &
-
-You should now have an unconfigured network interface (let's say `tun0`).
-For example, the simplest setup with `ifconfig`:
-
-    # ifconfig tun0 10.0.1.1 pointopoint 10.0.1.2 up
-
-To check if the server is running, simply call `glorytun show`.
-It will show you all of the running tunnels.
-
-To start a new client, you need to get the secret key generated for the server.
-Then simply call:
-
-    # glorytun bind 0.0.0.0 to SERVER_IP keyfile my_secret_key &
-    # ifconfig tun0 10.0.1.2 pointopoint 10.0.1.1 up
-
-Now you have to setup your path, let's say you have an ADSL link that can do 1Mbit upload and 20Mbit download then call:
-
-    # glorytun path up LOCAL_IPADDR rate tx 1mbit rx 20mbit
-
-Again, to check if your path is working, you can watch its status with `glorytun path`.
-You should now be able to ping your server with `ping 10.0.1.1`.
-
-If you use systemd-networkd, you can easily setup your tunnels with the helper program `glorytun-setup`.
-
-## Thanks
-
- * @jedisct1 for all his help and the code for MacOS/BSD.
- * The team OTB (@bessa, @gregdel, @pouulet, @sduponch and @simon) for all tests and discussions.
- * OVH to support this soft :)
-
 ---
 
 For feature requests and bug reports, please create an [issue](https://github.com/angt/glorytun/issues).

configure.ac

@@ -14,7 +14,6 @@ AM_PROG_CC_C_O
 AC_PROG_CC_C99
 AC_USE_SYSTEM_EXTENSIONS
 AC_SEARCH_LIBS([socket], [socket])
-AC_SEARCH_LIBS([fmin], [m])
 AC_CHECK_LIB([rt], [clock_gettime])
 AC_CHECK_FUNCS([clock_gettime])
 PKG_CHECK_MODULES([libsodium], [libsodium >= 1.0.4])

meson.build

@@ -29,15 +29,16 @@ executable('glorytun', install: true,
     'src/ctl.c',
     'src/iface.c',
     'src/keygen.c',
+    'src/list.c',
     'src/main.c',
     'src/path.c',
     'src/set.c',
     'src/show.c',
     'src/tun.c',
+    'src/version.c',
   ],
   dependencies: [
     dependency('libsodium', version : '>=1.0.4'),
-    cc.find_library('m', required : false)
   ]
 )
 

sodium.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+mkdir -p .static
+cd .static || exit 1
+
+file=LATEST.tar.gz
+url=https://download.libsodium.org/libsodium/releases
+dir="$PWD"
+
+[ -f "$file" ] || wget -q     "$url/$file" -O "$file"
+[ -f "$file" ] || curl -SsfLO "$url/$file"
+[ -f "$file" ] || {
+	echo "Couldn't download $url/$file"
+	exit 1
+}
+
+if [ "$1" ]; then
+	mkdir -p "$1"
+	cd "$1" || exit 1
+fi
+
+rm -rf libsodium-stable
+tar zxf "$dir/$file"
+cd libsodium-stable || exit 1
+
+NPROC=$(sysctl -n hw.ncpu || nproc) 2>/dev/null
+
+./configure ${1+--host=$1} --enable-minimal --disable-dependency-tracking --enable-static --disable-shared
+make "-j$((NPROC+1))"

src/bench.c

@@ -1,148 +1,103 @@
 #include "common.h"
 
-#include <math.h>
+#include <inttypes.h>
 #include <sodium.h>
-#include <string.h>
 #include <stdio.h>
-#include <sys/time.h>
+#include <string.h>
 #include <time.h>
-#include <unistd.h>
-
-#if defined __APPLE__
-#include <mach/mach_time.h>
-#endif
 
 #include "../argz/argz.h"
 
-#define STR_S(X) (((X) > 1) ? "s" : "")
+#define NPUBBYTES 32
-
+#define KEYBYTES  32
-static unsigned long long
+#define ABYTES    16
-gt_now(void)
-{
-#if defined __APPLE__
-    static mach_timebase_info_data_t mtid;
-    if (!mtid.denom)
-        mach_timebase_info(&mtid);
-    return (mach_absolute_time() * mtid.numer / mtid.denom) / 1000ULL;
-#elif defined CLOCK_MONOTONIC
-    struct timespec tv;
-    clock_gettime(CLOCK_MONOTONIC, &tv);
-    return (unsigned long long)tv.tv_sec * 1000000ULL
-         + (unsigned long long)tv.tv_nsec / 1000ULL;
-#else
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return (unsigned long long)tv.tv_sec * 1000000ULL
-         + (unsigned long long)tv.tv_usec;
-#endif
-}
 
 int
 gt_bench(int argc, char **argv)
 {
-    unsigned long precision = 10;
-    size_t bufsize = 64 * 1024;
-    unsigned long duration = 1000;
-
     struct argz bench_argz[] = {
         {"aes|chacha", NULL, NULL, argz_option},
-        {"precision", "EXPONENT", &precision, argz_ulong},
-        {"bufsize", "BYTES", &bufsize, argz_bytes},
-        {"duration", "SECONDS", &duration, argz_time},
         {NULL}};
 
     if (argz(bench_argz, argc, argv))
         return 1;
 
-    if (duration == 0 || bufsize == 0)
-        return 0;
-
     if (sodium_init() == -1) {
         gt_log("sodium init failed\n");
         return 1;
     }
 
-    duration /= 1000;
-
     int term = isatty(1);
+    int aes = argz_is_set(bench_argz, "aes");
     int chacha = argz_is_set(bench_argz, "chacha");
 
-    if (!chacha && !crypto_aead_aes256gcm_is_available()) {
+    if (!crypto_aead_aegis256_is_available()) {
-        gt_log("aes is not available on your platform\n");
+        if (aes) {
-        return 1;
+            gt_log("aes is not available on your platform\n");
+            return 1;
+        }
+        chacha = 1;
     }
 
-    unsigned char *buf = calloc(1, bufsize + crypto_aead_aes256gcm_ABYTES);
+    unsigned char buf[1450 + ABYTES];
-
+    unsigned char npub[NPUBBYTES];
-    if (!buf) {
+    unsigned char key[KEYBYTES];
-        perror("calloc");
-        return 1;
-    }
-
-    unsigned char npub[crypto_aead_aes256gcm_NPUBBYTES];
-    unsigned char key[crypto_aead_aes256gcm_KEYBYTES];
 
+    memset(buf, 0, sizeof(buf));
     randombytes_buf(npub, sizeof(npub));
     randombytes_buf(key, sizeof(key));
 
     if (term) {
-        printf("\n");
+        printf("cipher: %s\n\n", GT_CIPHER(chacha));
-        printf("  %-10s %s\n", "bench", chacha ? "chacha20poly1305" : "aes256gcm");
+        printf("  size       min           mean            max      \n");
-        printf("  %-10s %s\n", "libsodium", sodium_version_string());
+        printf("----------------------------------------------------\n");
-        printf("\n");
-        printf("  %-10s 2^(-%lu)\n", "precision", precision);
-        printf("  %-10s %zu byte%s\n", "bufsize", bufsize, STR_S(bufsize));
-        printf("  %-10s %lu second%s\n", "duration", duration, STR_S(duration));
-        printf("\n");
-        printf("------------------------------------------------------------\n");
-        printf(" %3s %9s %14s %14s %14s\n", "2^n", "min", "avg", "max", "delta");
-        printf("------------------------------------------------------------\n");
     }
 
-    for (int i = 0; !gt_quit && bufsize >> i; i++) {
+    int64_t size = 20;
-        unsigned long long total_dt = 0ULL;
-        size_t total_bytes = 0;
-        double mbps = 0.0;
-        double mbps_min = INFINITY;
-        double mbps_max = 0.0;
-        double mbps_dlt = INFINITY;
 
-        while (!gt_quit && mbps_dlt > ldexp(mbps, -(int)precision)) {
+    for (int i = 0; !gt_quit && size <= 1450; i++) {
-            crypto_aead_aes256gcm_state ctx;
+        struct {
+            int64_t min, mean, max, n;
+        } mbps = {.n = 0};
 
-            if (!chacha)
+        int64_t bytes_max = (int64_t)1 << 24;
-                crypto_aead_aes256gcm_beforenm(&ctx, key);
 
-            unsigned long long now = gt_now();
+        while (!gt_quit && mbps.n < 10) {
-            double mbps_old = mbps;
+            int64_t bytes = 0;
-            size_t bytes = 0;
+            int64_t base = (int64_t)clock();
 
-            gt_alarm = 0;
+            while (!gt_quit && bytes <= bytes_max) {
-            alarm((unsigned int)duration);
-
-            while (!gt_quit && !gt_alarm) {
                 if (chacha) {
                     crypto_aead_chacha20poly1305_encrypt(
-                        buf, NULL, buf, 1ULL << i, NULL, 0, NULL, npub, key);
+                        buf, NULL, buf, size, NULL, 0, NULL, npub, key);
                 } else {
-                    crypto_aead_aes256gcm_encrypt_afternm(
+                    crypto_aead_aegis256_encrypt(buf, NULL, buf, size, NULL, 0, NULL, npub, key);
-                        buf, NULL, buf, 1ULL << i, NULL, 0, NULL, npub,
-                        (const crypto_aead_aes256gcm_state *)&ctx);
                 }
-                bytes += 1ULL << i;
+                bytes += size;
             }
 
-            total_dt += gt_now() - now;
+            int64_t dt = (int64_t)clock() - base;
-            total_bytes += bytes;
+            bytes_max = (bytes * (CLOCKS_PER_SEC / 3)) / dt;
+            int64_t _mbps = (8 * bytes * CLOCKS_PER_SEC) / (dt * 1000 * 1000);
 
-            mbps = ((double)total_bytes * 8.0) / (double)total_dt;
+            if (!mbps.n++) {
-            mbps_min = fmin(mbps_min, mbps);
+                mbps.min = _mbps;
-            mbps_max = fmax(mbps_max, mbps);
+                mbps.max = _mbps;
-            mbps_dlt = fabs(mbps_old - mbps);
+                mbps.mean = _mbps;
+                continue;
+            }
+
+            if (mbps.min > _mbps)
+                mbps.min = _mbps;
+
+            if (mbps.max < _mbps)
+                mbps.max = _mbps;
+
+            mbps.mean += (_mbps - mbps.mean) / mbps.n;
 
             if (term) {
-                printf("\r %3i %9.2f Mbps %9.2f Mbps %9.2f Mbps %9.2e",
+                printf("\r %5"PRIi64" %9"PRIi64" Mbps %9"PRIi64" Mbps %9"PRIi64" Mbps",
-                       i, mbps_min, mbps, mbps_max, mbps_dlt);
+                        size, mbps.min, mbps.mean, mbps.max);
                 fflush(stdout);
             }
         }
@@ -150,12 +105,12 @@ gt_bench(int argc, char **argv)
         if (term) {
             printf("\n");
         } else {
-            printf("%i %.2f %.2f %.2f\n", i, mbps_min, mbps, mbps_max);
+            printf("bench %s %"PRIi64" %"PRIi64" %"PRIi64" %"PRIi64"\n",
+                    GT_CIPHER(chacha), size, mbps.min, mbps.mean, mbps.max);
         }
-    }
 
-    printf("\n");
+        size += 2 * 5 * 13;
-    free(buf);
+    }
 
     return 0;
 }

src/bind.c

@@ -2,11 +2,9 @@
 #include "ctl.h"
 #include "iface.h"
 #include "ip.h"
-#include "str.h"
 #include "tun.h"
 
 #include <fcntl.h>
-#include <stdio.h>
 #include <sys/select.h>
 
 #include "../argz/argz.h"
@@ -91,7 +89,7 @@ gt_setup_mtu(struct mud *mud, size_t old, const char *tun_name)
 {
     size_t mtu = mud_get_mtu(mud);
 
-    if (mtu == old)
+    if (!mtu || mtu == old)
         return mtu;
 
     if (iface_set_mtu(tun_name, mtu) == -1)
@@ -103,8 +101,8 @@ gt_setup_mtu(struct mud *mud, size_t old, const char *tun_name)
 int
 gt_bind(int argc, char **argv)
 {
-    struct sockaddr_storage bind_addr = { .ss_family = AF_INET };
+    struct sockaddr_storage bind_addr = {.ss_family = AF_INET};
-    struct sockaddr_storage peer_addr = { 0 };
+    struct sockaddr_storage peer_addr = {0};
     unsigned short bind_port = 5000;
     unsigned short peer_port = bind_port;
     const char *dev = NULL;
@@ -128,7 +126,7 @@ gt_bind(int argc, char **argv)
     if (argz(bindz, argc, argv))
         return 1;
 
-    if (str_empty(keyfile)) {
+    if (EMPTY(keyfile)) {
         gt_log("a keyfile is needed!\n");
         return 1;
     }
@@ -175,7 +173,7 @@ gt_bind(int argc, char **argv)
 
     if (tun_set_persist(tun_fd, persist) == -1) {
         gt_log("couldn't %sable persist mode on device %s\n",
-                persist ? "en" : "dis", tun_name);
+               persist ? "en" : "dis", tun_name);
     }
 
     if (peer_addr.ss_family) {
@@ -185,16 +183,21 @@ gt_bind(int argc, char **argv)
         }
     }
 
-    const int ctl_fd = ctl_create(GT_RUNDIR, tun_name);
+    const int ctl_fd = ctl_create(tun_name);
 
     if (ctl_fd == -1) {
-        gt_log("couldn't create "GT_RUNDIR"/%s: %s\n",
+        char dir[64];
-                tun_name, strerror(errno));
+        if (ctl_rundir(dir, sizeof(dir))) {
+            gt_log("couldn't create %s/%s: %s\n",
+                   dir, tun_name, strerror(errno));
+        } else {
+            gt_log("couldn't find a writable run/tmp directory\n");
+        }
         return 1;
     }
 
-    if (fd_set_nonblock(tun_fd) ||
+    if (//fd_set_nonblock(tun_fd) ||
-        fd_set_nonblock(mud_fd) ||
+        //fd_set_nonblock(mud_fd) ||
         fd_set_nonblock(ctl_fd)) {
         gt_log("couldn't setup non-blocking fds\n");
         return 1;
@@ -204,31 +207,43 @@ gt_bind(int argc, char **argv)
 
     gt_log("running on device %s as pid %li\n", tun_name, pid);
 
-    fd_set rfds;
+    fd_set rfds, wfds;
     FD_ZERO(&rfds);
+    FD_ZERO(&wfds);
 
-    const int last_fd = 1 + MAX(tun_fd, MAX(mud_fd, ctl_fd));
+    int tun_can_read = 0;
+    int tun_can_write = 0;
+    int mud_can_read = 0;
+    int mud_can_write = 0;
 
-    unsigned char buf[4096];
+    int last_fd = MAX(tun_fd, mud_fd);
+    last_fd = 1 + MAX(last_fd, ctl_fd);
+
+    __attribute__((aligned(16)))
+        unsigned char buf[1500];
 
     while (!gt_quit) {
-        long send_wait = mud_send_wait(mud);
+        if (tun_can_write) FD_CLR(tun_fd, &wfds); else FD_SET(tun_fd, &wfds);
+        if (mud_can_write) FD_CLR(mud_fd, &wfds); else FD_SET(mud_fd, &wfds);
+        if (tun_can_read)  FD_CLR(tun_fd, &rfds); else FD_SET(tun_fd, &rfds);
+        if (mud_can_read)  FD_CLR(mud_fd, &rfds); else FD_SET(mud_fd, &rfds);
 
-        if (send_wait) {
-            FD_CLR(tun_fd, &rfds);
-        } else {
-            FD_SET(tun_fd, &rfds);
-        }
-
-        FD_SET(mud_fd, &rfds);
         FD_SET(ctl_fd, &rfds);
 
-        struct timeval tv = {
+        struct timeval tv = {0};
-            .tv_sec  = 0,
+        int update = mud_update(mud);
-            .tv_usec = send_wait,
-        };
 
-        const int ret = select(last_fd, &rfds, NULL, NULL, send_wait > 0 ? &tv : NULL);
+        if (update >= 0) {
+            if (mud_can_read && tun_can_write) {
+            } else if (tun_can_read && mud_can_write) {
+                if (update)
+                    tv.tv_usec = 1000;
+            } else {
+                tv.tv_usec = 100000;
+            }
+        }
+
+        const int ret = select(last_fd, &rfds, &wfds, NULL, update < 0 ? NULL : &tv);
 
         if (ret == -1) {
             if (errno == EBADF) {
@@ -238,8 +253,36 @@ gt_bind(int argc, char **argv)
             continue;
         }
 
+        if (FD_ISSET(tun_fd, &rfds)) tun_can_read  = 1;
+        if (FD_ISSET(tun_fd, &wfds)) tun_can_write = 1;
+        if (FD_ISSET(mud_fd, &rfds)) mud_can_read  = 1;
+        if (FD_ISSET(mud_fd, &wfds)) mud_can_write = 1;
+
         mtu = gt_setup_mtu(mud, mtu, tun_name);
 
+        if (tun_can_read && mud_can_write && !mud_send_wait(mud)) {
+            struct ip_common ic;
+            int r = tun_read(tun_fd, buf, sizeof(buf));
+
+            if (r > 0 && !ip_get_common(&ic, buf, r)) {
+                mud_send(mud, buf, (size_t)r);
+                mud_can_write = 0;
+            }
+
+            tun_can_read = 0;
+        }
+
+        if (mud_can_read && tun_can_write) {
+            int r = mud_recv(mud, buf, sizeof(buf));
+
+            if (r > 0 && ip_is_valid(buf, r)) {
+                tun_write(tun_fd, buf, (size_t)r);
+                tun_can_write = 0;
+            }
+
+            mud_can_read = 0;
+        }
+
         if (FD_ISSET(ctl_fd, &rfds)) {
             struct ctl_msg req, res = {.reply = 1};
             struct sockaddr_storage ss;
@@ -256,55 +299,52 @@ gt_bind(int argc, char **argv)
                     break;
                 case CTL_STATE:
                     if (mud_set_state(mud, (struct sockaddr *)&req.path.addr,
-                                      req.path.state, req.path.rate_tx, req.path.rate_rx))
+                                      req.path.state,
+                                      req.path.rate_tx,
+                                      req.path.rate_rx,
+                                      req.path.beat,
+                                      req.path.fixed_rate,
+                                      req.path.loss_limit))
                         res.ret = errno;
                     break;
-                case CTL_PATH_STATUS:
+                case CTL_CONF:
-                    {
+                    if (mud_set_conf(mud, &req.conf))
-                        unsigned count = 0;
-                        struct mud_path *paths = mud_get_paths(mud, &count);
-
-                        if (!paths) {
-                            res.ret = errno;
-                            break;
-                        }
-
-                        res.ret = EAGAIN;
-
-                        for (unsigned i = 0; i < count; i++) {
-                            memcpy(&res.path_status, &paths[i], sizeof(struct mud_path));
-                            if (sendto(ctl_fd, &res, sizeof(res), 0,
-                                       (const struct sockaddr *)&ss, sl) == -1)
-                                perror("sendto(ctl)");
-                        }
-
-                        free(paths);
-                        res.ret = 0;
-                    }
-                    break;
-                case CTL_MTU:
-                    mud_set_mtu(mud, req.mtu);
-                    res.mtu = mtu = gt_setup_mtu(mud, mtu, tun_name);
-                    break;
-                case CTL_TC:
-                    if (mud_set_tc(mud, req.tc))
-                        res.ret = errno;
-                    break;
-                case CTL_KXTIMEOUT:
-                    if (mud_set_keyx_timeout(mud, req.ms))
-                        res.ret = errno;
-                    break;
-                case CTL_TIMETOLERANCE:
-                    if (mud_set_time_tolerance(mud, req.ms))
                         res.ret = errno;
+                    res.conf = req.conf;
                     break;
                 case CTL_STATUS:
+                    memcpy(res.status.tun_name, tun_name, sizeof(tun_name)); // XXX
                     res.status.pid = pid;
                     res.status.mtu = mtu;
                     res.status.chacha = chacha;
                     res.status.bind = bind_addr;
                     res.status.peer = peer_addr;
                     break;
+                case CTL_PATH_STATUS: {
+                    unsigned count = 0;
+                    struct mud_path *paths = mud_get_paths(mud, &count);
+
+                    if (!paths) {
+                        res.ret = errno;
+                        break;
+                    }
+
+                    res.ret = EAGAIN;
+
+                    for (unsigned i = 0; i < count; i++) {
+                        memcpy(&res.path_status, &paths[i], sizeof(struct mud_path));
+                        if (sendto(ctl_fd, &res, sizeof(res), 0,
+                                   (const struct sockaddr *)&ss, sl) == -1)
+                            perror("sendto(ctl)");
+                    }
+
+                    free(paths);
+                    res.ret = 0;
+                } break;
+                case CTL_BAD:
+                    if (mud_get_bad(mud, &res.bad))
+                        res.ret = errno;
+                    break;
                 }
                 if (sendto(ctl_fd, &res, sizeof(res), 0,
                            (const struct sockaddr *)&ss, sl) == -1)
@@ -313,36 +353,6 @@ gt_bind(int argc, char **argv)
                 perror("recvfrom(ctl)");
             }
         }
-
-        if (FD_ISSET(mud_fd, &rfds))  {
-            int n = 1000;
-
-            while (n--) {
-                const int r = mud_recv(mud, buf, sizeof(buf));
-
-                if (r <= 0)
-                    break;
-
-                if (ip_is_valid(buf, r))
-                    tun_write(tun_fd, buf, (size_t)r);
-            }
-        }
-
-        if (FD_ISSET(tun_fd, &rfds) && !mud_send_wait(mud)) {
-            struct ip_common ic;
-            const int r = tun_read(tun_fd, buf, sizeof(buf));
-
-            if (r > 0 && !ip_get_common(&ic, buf, r)) {
-             // TODO: disable hash for now
-             // unsigned char hash[crypto_shorthash_BYTES];
-             // crypto_shorthash(hash, (const unsigned char *)&ic, sizeof(ic), hashkey);
-
-                unsigned h = 0;
-             // memcpy(&h, hash, sizeof(h));
-
-                mud_send(mud, buf, (size_t)r, (h << 8) | ic.tc);
-            }
-        }
     }
 
     if (gt_reload && tun_fd >= 0)

src/common.c

@@ -114,3 +114,79 @@ gt_toaddr(char *str, size_t size, struct sockaddr *sa)
     errno = EAFNOSUPPORT;
     return -1;
 }
+
+int
+gt_totime(char *str, size_t size, unsigned long long t)
+{
+    if (!str || size < 4) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (!t) {
+        memcpy(str, "now", 4);
+        return 0;
+    }
+
+    struct {
+        unsigned long long v;
+        unsigned long long n;
+        char *name;
+    } u[] = {
+        {0, 1000, "ms"},
+        {0,   60,  "s"},
+        {0,   60,  "m"},
+        {0,   24,  "h"},
+        {0,    0,  "d"},
+    };
+
+    size_t len = 0;
+    unsigned i = 0;
+
+    while (u[i].n) {
+        u[i].v = t % u[i].n;
+        t /= u[i].n;
+        i++;
+    }
+
+    u[i++].v = t;
+
+    while (i--)
+        if (u[i].v) {
+            int ret = snprintf(str + len, size - len, "%llu%s", u[i].v, u[i].name);
+            if (ret <= 0 || (size_t)ret >= size - len) {
+                errno = EINVAL;
+                return -1;
+            }
+            len += ret;
+        }
+
+    return 0;
+}
+
+int
+gt_torate(char *str, size_t size, unsigned long long r)
+{
+    if (!str || size < 5) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    unsigned k = 0;
+
+    while (r && k < 4 && !(r % 1000)) {
+        r /= 1000;
+        k++;
+    }
+
+    int ret = snprintf(str, size, "%llu%sbit%s", r,
+                       &"\0\0k\0M\0G\0T"[k << 1],
+                       &"s"[r <= 1]);
+
+    if (ret <= 0 || (size_t)ret >= size) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    return 0;
+}

src/common.h

@@ -4,14 +4,17 @@
 #define _GNU_SOURCE
 #endif
 
-#include <stdlib.h>
+#include <errno.h>
+#include <signal.h>
 #include <stdint.h>
+#include <stdlib.h>
+#include <stddef.h>
 #include <string.h>
 #include <unistd.h>
-#include <signal.h>
-#include <errno.h>
 
 #include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
 
 #ifndef PACKAGE_NAME
 #define PACKAGE_NAME "glorytun"
@@ -21,56 +24,51 @@
 #define PACKAGE_VERSION "0.0.0"
 #endif
 
-#ifndef GT_RUNDIR
+#define COUNT(x) (sizeof(x) / sizeof(x[0]))
-#define GT_RUNDIR "/run/" PACKAGE_NAME
-#endif
 
-#define COUNT(x)       (sizeof(x)/sizeof(x[0]))
+#define _1_(x) (__builtin_expect((x), 1))
+#define _0_(x) (__builtin_expect((x), 0))
+#define CLZ(x) (__builtin_clz(x))
 
-#define ALIGN_SIZE     (1<<4)
+#define _printf_(A, B) __attribute__((format(printf, A, B)))
-#define ALIGN_MASK     (ALIGN_SIZE-1)
+#define _noreturn_     __attribute__((noreturn))
-
+#define _unused_       __attribute__((unused))
-#define ALIGN(x)       (((x)+ALIGN_MASK)&~ALIGN_MASK)
+#define _pure_         __attribute__((pure))
-#define ALIGN_DOWN(x)  ((x)&~ALIGN_MASK)
+#define _const_        __attribute__((const))
-
+#define _align_(...)   __attribute__((aligned(__VA_ARGS__)))
-#define PALIGN(x)      ((void *)ALIGN((size_t)(x)))
-#define PALIGN_DOWN(x) ((void *)ALIGN_DOWN((size_t)(x)))
-
-#define _1_(x)         (__builtin_expect((x), 1))
-#define _0_(x)         (__builtin_expect((x), 0))
-
-#define CLZ(x)         (__builtin_clz(x))
-
-#define _printf_(A,B)  __attribute__ ((format(printf,A,B)))
-#define _noreturn_     __attribute__ ((noreturn))
-#define _unused_       __attribute__ ((unused))
-#define _pure_         __attribute__ ((pure))
-#define _const_        __attribute__ ((const))
-#define _align_(...)   __attribute__ ((aligned(__VA_ARGS__)))
 
 #undef MAX
-#define MAX(x,y) ({ __typeof__(x) X=(x); __typeof__(y) Y=(y); X > Y ? X : Y; })
+#define MAX(x, y) ({ __typeof__(x) X=(x); __typeof__(y) Y=(y); X > Y ? X : Y; })
 
 #undef MIN
-#define MIN(x,y) ({ __typeof__(x) X=(x); __typeof__(y) Y=(y); X < Y ? X : Y; })
+#define MIN(x, y) ({ __typeof__(x) X=(x); __typeof__(y) Y=(y); X < Y ? X : Y; })
+
+#define EMPTY(x) ({ __typeof__(x) X=(x); !X || !X[0]; })
+
+#define GT_CIPHER(x) ((x) ? "chacha20poly1305" : "aegis256")
 
 extern volatile sig_atomic_t gt_alarm;
 extern volatile sig_atomic_t gt_reload;
 extern volatile sig_atomic_t gt_quit;
 
-int  gt_print (const char *, ...) _printf_(1,2);
+int  gt_print (const char *, ...) _printf_(1, 2);
-void gt_log   (const char *, ...) _printf_(1,2);
+void gt_log   (const char *, ...) _printf_(1, 2);
 
 int gt_tohex   (char *, size_t, const uint8_t *, size_t);
 int gt_fromhex (uint8_t *, size_t, const char *, size_t);
 
 void     gt_set_port (struct sockaddr *, uint16_t);
 uint16_t gt_get_port (struct sockaddr *);
-int      gt_toaddr   (char *, size_t, struct sockaddr *);
 
-int gt_show   (int, char **);
+int gt_toaddr (char *, size_t, struct sockaddr *);
-int gt_bind   (int, char **);
+int gt_totime (char *, size_t, unsigned long long);
-int gt_path   (int, char **);
+int gt_torate (char *, size_t, unsigned long long);
-int gt_keygen (int, char **);
+
-int gt_bench  (int, char **);
+int gt_list    (int, char **);
-int gt_set    (int, char **);
+int gt_show    (int, char **);
+int gt_bind    (int, char **);
+int gt_path    (int, char **);
+int gt_keygen  (int, char **);
+int gt_bench   (int, char **);
+int gt_set     (int, char **);
+int gt_version (int, char **);

src/ctl.c

@@ -1,29 +1,54 @@
-#include "common.h"
 #include "ctl.h"
-#include "str.h"
+#include "common.h"
 
-#include <stdio.h>
-#include <unistd.h>
 #include <dirent.h>
-#include <sys/socket.h>
+#include <libgen.h>
-#include <sys/types.h>
+#include <stdio.h>
 #include <sys/stat.h>
 #include <sys/un.h>
 
+char *
+ctl_rundir(char *dst, size_t size)
+{
+    if (dst && size)
+        dst[0] = 0;
+
+    const char *fmt[] = {
+        "/run/user/%u/" PACKAGE_NAME,
+        "/run/"         PACKAGE_NAME ".%u",
+        "/var/run/"     PACKAGE_NAME ".%u",
+        "/tmp/"         PACKAGE_NAME ".%u",
+    };
+
+    for (unsigned i = 0; i < COUNT(fmt); i++) {
+        char path[128];
+        int ret = snprintf(dst, size, fmt[i], geteuid());
+
+        if ((ret <= 0) ||
+            ((size_t)ret >= size) ||
+            ((size_t)ret >= sizeof(path)))
+            continue;
+
+        memcpy(path, dst, (size_t)ret + 1);
+        char *p = dirname(path);
+
+        if (p && !access(p, W_OK))
+            return dst;
+    }
+
+    errno = EPERM;
+    return NULL;
+}
+
 int
 ctl_reply(int fd, struct ctl_msg *res, struct ctl_msg *req)
 {
-    if (fd == -1) {
-        errno = EINVAL;
-        return -1;
-    }
-
     if ((send(fd, req, sizeof(struct ctl_msg), 0) == -1) ||
         (recv(fd, res, sizeof(struct ctl_msg), 0) == -1))
         return -1;
 
     if (res->type != req->type || !res->reply) {
-        errno = EINVAL;
+        errno = EBADMSG;
         return -1;
     }
 
@@ -58,34 +83,31 @@ ctl_setsun(struct sockaddr_un *dst, const char *dir, const char *file)
 static int
 ctl_bind(int fd, const char *dir, const char *file)
 {
+    char name[10] = {[0] = '.'};
     struct sockaddr_un sun;
 
-    if (str_empty(file)) {
+    if (EMPTY(file)) {
-        char name[10] = { [0] = '.' };
         unsigned pid = (unsigned)getpid();
 
         for (size_t i = 1; i < sizeof(name) - 1; i++, pid >>= 4)
             name[i] = "uncopyrightables"[pid & 15];
 
-        if (ctl_setsun(&sun, dir, name))
+        file = name;
-            return -1;
-    } else {
-        if (ctl_setsun(&sun, dir, file))
-            return -1;
-
-        unlink(sun.sun_path);
     }
 
+    if (ctl_setsun(&sun, dir, file))
+        return -1;
+
+    if (unlink(sun.sun_path) && errno != ENOENT)
+        return -1;
+
     return bind(fd, (struct sockaddr *)&sun, sizeof(sun));
 }
 
 void
 ctl_delete(int fd)
 {
-    if (fd == -1)
+    struct sockaddr_storage ss = {0};
-        return;
-
-    struct sockaddr_storage ss = { 0 };
     socklen_t sslen = sizeof(ss);
 
     if ((getsockname(fd, (struct sockaddr *)&ss, &sslen) == 0) &&
@@ -96,21 +118,18 @@ ctl_delete(int fd)
 }
 
 int
-ctl_create(const char *dir, const char *file)
+ctl_create(const char *file)
 {
-    if (str_empty(dir)) {
+    char dir[64];
-        errno = EINVAL;
+
+    if (!ctl_rundir(dir, sizeof(dir)))
         return -1;
-    }
 
     if (mkdir(dir, 0700) == -1 && errno != EEXIST)
         return -1;
 
     int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
 
-    if (fd == -1)
-        return -1;
-
     if (ctl_bind(fd, dir, file)) {
         int err = errno;
         close(fd);
@@ -122,20 +141,17 @@ ctl_create(const char *dir, const char *file)
 }
 
 int
-ctl_connect(const char *dir, const char *file)
+ctl_connect(const char *file)
 {
+    char dir[64];
     DIR *dp = NULL;
 
-    if (str_empty(dir)) {
+    if (!ctl_rundir(dir, sizeof(dir)))
-        errno = EINVAL;
         return -1;
-    }
 
     if (!file) {
-        dp = opendir(dir);
+        if (dp = opendir(dir), !dp)
-
+            return CTL_ERROR_NONE;
-        if (!dp)
-            return -1;
 
         struct dirent *d = NULL;
 
@@ -145,7 +161,7 @@ ctl_connect(const char *dir, const char *file)
 
             if (file) {
                 closedir(dp);
-                return -3;
+                return CTL_ERROR_MANY;
             }
 
             file = &d->d_name[0];
@@ -153,7 +169,7 @@ ctl_connect(const char *dir, const char *file)
 
         if (!file) {
             closedir(dp);
-            return -2;
+            return CTL_ERROR_NONE;
         }
     }
 
@@ -169,12 +185,10 @@ ctl_connect(const char *dir, const char *file)
     if (ret)
         return -1;
 
-    int fd = ctl_create(dir, NULL);
+    int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
 
-    if (fd == -1)
+    if (ctl_bind(fd, dir, NULL) ||
-        return -1;
+        connect(fd, (struct sockaddr *)&sun, sizeof(sun))) {
-
-    if (connect(fd, (struct sockaddr *)&sun, sizeof(sun))) {
         int err = errno;
         ctl_delete(fd);
         errno = err;
@@ -183,3 +197,23 @@ ctl_connect(const char *dir, const char *file)
 
     return fd;
 }
+
+void
+ctl_explain_connect(int ret)
+{
+    switch (ret) {
+        case 0:
+            break;
+        case CTL_ERROR_MANY:
+            gt_log("please select a tunnel\n");
+            break;
+        case CTL_ERROR_NONE:
+            gt_log("no active tunnel\n");
+            break;
+        default:
+            gt_log("unknown error\n"); /* FALLTHRU */
+        case -1:
+            if (errno)
+                perror("connect");
+    }
+}

src/ctl.h

@@ -4,15 +4,16 @@
 
 #include <sys/socket.h>
 
+#define CTL_ERROR_NONE (-2)
+#define CTL_ERROR_MANY (-3)
+
 enum ctl_type {
     CTL_NONE = 0,
     CTL_STATE,
+    CTL_CONF,
     CTL_STATUS,
-    CTL_MTU,
-    CTL_TC,
-    CTL_KXTIMEOUT,
-    CTL_TIMETOLERANCE,
     CTL_PATH_STATUS,
+    CTL_BAD,
 };
 
 struct ctl_msg {
@@ -24,22 +25,28 @@ struct ctl_msg {
             enum mud_state state;
             unsigned long rate_tx;
             unsigned long rate_rx;
+            unsigned long beat;
+            unsigned char fixed_rate;
+            unsigned char loss_limit;
         } path;
-        struct mud_path path_status;
         struct {
+            char tun_name[64];
             long pid;
             size_t mtu;
             int chacha;
             struct sockaddr_storage bind;
             struct sockaddr_storage peer;
         } status;
-        size_t mtu;
+        struct mud_conf conf;
-        int tc;
+        struct mud_path path_status;
-        unsigned long ms;
+        struct mud_bad bad;
     };
 };
 
-int  ctl_create  (const char *, const char *);
+char *ctl_rundir  (char *, size_t);
-int  ctl_connect (const char *, const char *);
+int   ctl_create  (const char *);
-int  ctl_reply   (int, struct ctl_msg *, struct ctl_msg *);
+int   ctl_connect (const char *);
-void ctl_delete  (int);
+int   ctl_reply   (int, struct ctl_msg *, struct ctl_msg *);
+void  ctl_delete  (int);
+
+void ctl_explain_connect (int);

src/iface.c

@@ -1,8 +1,8 @@
-#include "common.h"
 #include "iface.h"
+#include "common.h"
 
-#include <stdio.h>
 #include <net/if.h>
+#include <stdio.h>
 #include <sys/ioctl.h>
 
 int

src/iface.h

@@ -1,3 +1,5 @@
 #pragma once
 
+#include <stddef.h>
+
 int iface_set_mtu (const char *, size_t);

src/list.c

@@ -0,0 +1,47 @@
+#include "common.h"
+#include "ctl.h"
+
+#include "../argz/argz.h"
+
+#include <dirent.h>
+#include <stdio.h>
+
+int
+gt_list(int argc, char **argv)
+{
+    struct argz showz[] = {
+        {"list", NULL, NULL, argz_option},
+        {NULL}};
+
+    if (argz(showz, argc, argv))
+        return 1;
+
+    char dir[64];
+
+    if (!ctl_rundir(dir, sizeof(dir)))
+        return 0;
+
+    DIR *dp = opendir(dir);
+
+    if (!dp)
+        return 0;
+
+    struct dirent *d = NULL;
+
+    while (d = readdir(dp), d) {
+        if (d->d_name[0] == '.')
+            continue;
+
+        int fd = ctl_connect(d->d_name);
+
+        if (fd < 0)
+            continue;
+
+        printf("%s\n", d->d_name);
+        close(fd);
+    }
+
+    closedir(dp);
+
+    return 0;
+}

src/main.c

@@ -1,8 +1,9 @@
 #include "common.h"
-#include "str.h"
 
 #include <stdio.h>
 
+#include "../argz/argz.h"
+
 volatile sig_atomic_t gt_alarm;
 volatile sig_atomic_t gt_reload;
 volatile sig_atomic_t gt_quit;
@@ -43,13 +44,6 @@ gt_set_signal(void)
     sigaction(SIGUSR2, &sa, NULL);
 }
 
-static int
-gt_version(int argc, char **argv)
-{
-    printf(PACKAGE_VERSION "\n");
-    return 0;
-}
-
 int
 main(int argc, char **argv)
 {
@@ -60,7 +54,8 @@ main(int argc, char **argv)
         char *help;
         int (*call)(int, char **);
     } cmd[] = {
-        {"show", "show all running tunnels", gt_show},
+        {"list", "list all tunnels", gt_list},
+        {"show", "show tunnel information", gt_show},
         {"bench", "start a crypto bench", gt_bench},
         {"bind", "start a new tunnel", gt_bind},
         {"set", "change tunnel properties", gt_set},
@@ -71,7 +66,7 @@ main(int argc, char **argv)
 
     if (argv[1]) {
         for (int k = 0; cmd[k].name; k++) {
-            if (!str_cmp(cmd[k].name, argv[1]))
+            if (!strcmp(cmd[k].name, argv[1]))
                 return cmd[k].call(argc - 1, argv + 1);
         }
     }
@@ -81,10 +76,10 @@ main(int argc, char **argv)
     int len = 0;
 
     for (int k = 0; cmd[k].name; k++)
-        len = MAX(len, (int)str_len(cmd[k].name, 32));
+        len = MAX(len, (int)strlen(cmd[k].name));
 
     for (int k = 0; cmd[k].name; k++)
-        printf("  %-*s  %s\n", len, cmd[k].name, cmd[k].help);
+        printf("    %-*s    %s\n", len, cmd[k].name, cmd[k].help);
 
     printf("\n");
 

src/path.c

@@ -1,15 +1,71 @@
 #include "common.h"
 #include "ctl.h"
-#include "str.h"
 
 #include <stdio.h>
-#include <sys/socket.h>
-#include <unistd.h>
 
 #include "../argz/argz.h"
 
+static void
+gt_path_print(struct mud_path *path, int term)
+{
+    const char *statestr = NULL;
+    char bindstr[INET6_ADDRSTRLEN];
+    char beatstr[32];
+    char txstr[32], rxstr[32];
+
+    switch (path->state) {
+        case MUD_UP:     statestr = "up";     break;
+        case MUD_BACKUP: statestr = "backup"; break;
+        case MUD_DOWN:   statestr = "down";   break;
+        default:         return;
+    }
+
+    if (gt_toaddr(bindstr, sizeof(bindstr),
+                  (struct sockaddr *)&path->local_addr))
+        return;
+
+    if (gt_totime(beatstr, sizeof(beatstr), path->conf.beat / 1000))
+        return;
+
+    if (gt_torate(txstr, sizeof(txstr), path->conf.tx_max_rate * 8))
+        return;
+
+    if (gt_torate(rxstr, sizeof(rxstr), path->conf.rx_max_rate * 8))
+        return;
+
+    printf(term ? "path %s %s losslimit %u%% beat %s "
+                  "rate %s tx %s rx %s\n"
+                : "path %s %s %u %s %s %s %s\n",
+            statestr, bindstr,
+            path->conf.loss_limit * 100U / 255U,
+            beatstr,
+            path->conf.fixed_rate ? "fixed" : "auto",
+            txstr, rxstr);
+}
+
 static int
-gt_path_status(int fd)
+gt_path_cmp_addr(struct sockaddr_storage *a, struct sockaddr_storage *b)
+{
+    if (a->ss_family != b->ss_family)
+        return 1;
+
+    if (a->ss_family == AF_INET) {
+        struct sockaddr_in *A = (struct sockaddr_in *)a;
+        struct sockaddr_in *B = (struct sockaddr_in *)b;
+        return ((memcmp(&A->sin_addr, &B->sin_addr, sizeof(A->sin_addr))));
+    }
+
+    if (a->ss_family == AF_INET6) {
+        struct sockaddr_in6 *A = (struct sockaddr_in6 *)a;
+        struct sockaddr_in6 *B = (struct sockaddr_in6 *)b;
+        return ((memcmp(&A->sin6_addr, &B->sin6_addr, sizeof(A->sin6_addr))));
+    }
+
+    return 1;
+}
+
+static int
+gt_path_print_all(int fd, enum mud_state state, struct sockaddr_storage *addr)
 {
     struct ctl_msg req = {
         .type = CTL_PATH_STATUS,
@@ -18,79 +74,39 @@ gt_path_status(int fd)
     if (send(fd, &req, sizeof(struct ctl_msg), 0) == -1)
         return -1;
 
-    int term = isatty(1);
+    struct mud_path path[MUD_PATH_MAX];
+    int count = 0;
 
-    do {
+    while (1) {
         if (recv(fd, &res, sizeof(struct ctl_msg), 0) == -1)
             return -1;
 
-        if (res.type != req.type)
+        if (res.type != req.type) {
-            return -2;
+            errno = EBADMSG;
-
+            return -1;
-        if (!res.ret)
-            return 0;
-
-        char bindstr[INET6_ADDRSTRLEN];
-        char publstr[INET6_ADDRSTRLEN];
-        char peerstr[INET6_ADDRSTRLEN];
-
-        gt_toaddr(bindstr, sizeof(bindstr),
-                  (struct sockaddr *)&res.path_status.local_addr);
-        gt_toaddr(publstr, sizeof(publstr),
-                  (struct sockaddr *)&res.path_status.r_addr);
-        gt_toaddr(peerstr, sizeof(peerstr),
-                  (struct sockaddr *)&res.path_status.addr);
-
-        const char *statestr = NULL;
-
-        switch (res.path_status.state) {
-            case MUD_UP:     statestr = "UP";     break;
-            case MUD_BACKUP: statestr = "BACKUP"; break;
-            case MUD_DOWN:   statestr = "DOWN";   break;
-            default:         return -2;
         }
 
-        const char *statusstr = res.path_status.ok ? "OK" : "DEGRADED";
+        if (res.ret == EAGAIN) {
+            memcpy(&path[count], &res.path_status, sizeof(struct mud_path));
+            count++;
+        } else if (res.ret) {
+            errno = res.ret;
+            return -1;
+        } else break;
+    }
 
-        printf(term ? "path %s\n"
+    int term = isatty(1);
-                      "  status:   %s\n"
+
-                      "  bind:     %s port %"PRIu16"\n"
+    if (!term)
-                      "  public:   %s port %"PRIu16"\n"
+        printf("# STATE ADDR LOSSLIMIT BEAT RATE TX RX\n");
-                      "  peer:     %s port %"PRIu16"\n"
+
-                      "  mtu:      %zu bytes\n"
+    for (int i = 0; i < count; i++) {
-                      "  rtt:      %.3f ms\n"
+        if (state && path[i].state != state)
-                      "  rttvar:   %.3f ms\n"
+            continue;
-                      "  rate tx:  %"PRIu64" bytes/sec\n"
+        if (addr->ss_family && gt_path_cmp_addr(addr, &path[i].local_addr))
-                      "  rate rx:  %"PRIu64" bytes/sec\n"
+            continue;
-                      "  total tx: %"PRIu64" packets\n"
+        gt_path_print(&path[i], term);
-                      "  total rx: %"PRIu64" packets\n"
+    }
-                    : "path %s %s"
-                      " %s %"PRIu16
-                      " %s %"PRIu16
-                      " %s %"PRIu16
-                      " %zu"
-                      " %.3f %.3f"
-                      " %"PRIu64
-                      " %"PRIu64
-                      " %"PRIu64
-                      " %"PRIu64
-                      "\n",
-            statestr,
-            statusstr,
-            bindstr[0] ? bindstr : "-",
-            gt_get_port((struct sockaddr *)&res.path_status.local_addr),
-            publstr[0] ? publstr : "-",
-            gt_get_port((struct sockaddr *)&res.path_status.r_addr),
-            peerstr[0] ? peerstr : "-",
-            gt_get_port((struct sockaddr *)&res.path_status.addr),
-            res.path_status.mtu.ok,
-            (double)res.path_status.rtt.val / 1e3,
-            (double)res.path_status.rtt.var / 1e3,
-            res.path_status.rate_tx,
-            res.path_status.rate_rx,
-            res.path_status.send.total,
-            res.path_status.recv.total);
-    } while (res.ret == EAGAIN);
 
     return 0;
 }
@@ -99,12 +115,17 @@ int
 gt_path(int argc, char **argv)
 {
     const char *dev = NULL;
+    unsigned int loss_limit = 0;
 
     struct ctl_msg req = {
         .type = CTL_STATE,
+        .path = {
+            .state = MUD_EMPTY,
+        },
     }, res = {0};
 
     struct argz ratez[] = {
+        {"fixed|auto", NULL, NULL, argz_option},
         {"tx", "BYTES/SEC", &req.path.rate_tx, argz_bytes},
         {"rx", "BYTES/SEC", &req.path.rate_rx, argz_bytes},
         {NULL}};
@@ -114,50 +135,53 @@ gt_path(int argc, char **argv)
         {"dev", "NAME", &dev, argz_str},
         {"up|backup|down", NULL, NULL, argz_option},
         {"rate", NULL, &ratez, argz_option},
+        {"beat", "SECONDS", &req.path.beat, argz_time},
+        {"losslimit", "PERCENT", &loss_limit, argz_percent},
         {NULL}};
 
     if (argz(pathz, argc, argv))
         return 1;
 
-    int fd = ctl_connect(GT_RUNDIR, dev);
+    int fd = ctl_connect(dev);
 
     if (fd < 0) {
-        switch (fd) {
+        ctl_explain_connect(fd);
-        case -1:
-            perror("path");
-            break;
-        case -2:
-            gt_log("no device\n");
-            break;
-        case -3:
-            gt_log("please choose a device\n");
-            break;
-        default:
-            gt_log("couldn't connect\n");
-        }
         return 1;
     }
 
+    int set = argz_is_set(pathz, "rate")
+           || argz_is_set(pathz, "beat")
+           || argz_is_set(pathz, "losslimit");
+
+    if (set && !req.path.addr.ss_family) {
+        gt_log("please specify a path\n");
+        return 1;
+    }
+
+    if (argz_is_set(pathz, "up")) {
+        req.path.state = MUD_UP;
+    } else if (argz_is_set(pathz, "backup")) {
+        req.path.state = MUD_BACKUP;
+    } else if (argz_is_set(pathz, "down")) {
+        req.path.state = MUD_DOWN;
+    }
+
+    if (loss_limit)
+        req.path.loss_limit = loss_limit * 255 / 100;
+
+    if (argz_is_set(ratez, "fixed")) {
+        req.path.fixed_rate = 3;
+    } else if (argz_is_set(ratez, "auto")) {
+        req.path.fixed_rate = 1;
+    }
+
     int ret = 0;
 
-    if (!req.path.addr.ss_family) {
+    if (req.path.addr.ss_family && (req.path.state || set))
-        ret = gt_path_status(fd);
-
-        if (ret == -2)
-            gt_log("bad reply from server\n");
-    } else {
-        req.path.state = MUD_EMPTY;
-
-        if (argz_is_set(pathz, "up")) {
-            req.path.state = MUD_UP;
-        } else if (argz_is_set(pathz, "backup")) {
-            req.path.state = MUD_BACKUP;
-        } else if (argz_is_set(pathz, "down")) {
-            req.path.state = MUD_DOWN;
-        }
-
         ret = ctl_reply(fd, &res, &req);
-    }
+
+    if (!ret)
+        ret = gt_path_print_all(fd, req.path.state, &req.path.addr);
 
     if (ret == -1)
         perror("path");

src/set.c

@@ -1,86 +1,10 @@
 #include "common.h"
 #include "ctl.h"
-#include "str.h"
 
 #include <stdio.h>
-#include <sys/socket.h>
 
 #include "../argz/argz.h"
 
-static int
-gt_set_mtu(int fd, size_t mtu)
-{
-    struct ctl_msg res, req = {
-        .type = CTL_MTU,
-        .mtu = mtu,
-    };
-
-    int ret = ctl_reply(fd, &res, &req);
-
-    if (ret) {
-        perror("set mtu");
-        return 1;
-    }
-
-    printf("mtu set to %zu\n", res.mtu);
-
-    return 0;
-}
-
-static int
-gt_set_kxtimeout(int fd, unsigned long ms)
-{
-    struct ctl_msg res, req = {
-        .type = CTL_KXTIMEOUT,
-        .ms = ms,
-    };
-
-    int ret = ctl_reply(fd, &res, &req);
-
-    if (ret) {
-        perror("set kxtimeout");
-        return 1;
-    }
-
-    return 0;
-}
-
-static int
-gt_set_timetolerance(int fd, unsigned long ms)
-{
-    struct ctl_msg res, req = {
-        .type = CTL_TIMETOLERANCE,
-        .ms = ms,
-    };
-
-    int ret = ctl_reply(fd, &res, &req);
-
-    if (ret) {
-        perror("set timetolerance");
-        return 1;
-    }
-
-    return 0;
-}
-
-static int
-gt_set_tc(int fd, int tc)
-{
-    struct ctl_msg res, req = {
-        .type = CTL_TC,
-        .tc = tc,
-    };
-
-    int ret = ctl_reply(fd, &res, &req);
-
-    if (ret) {
-        perror("set tc");
-        return 1;
-    }
-
-    return 0;
-}
-
 static int
 gt_argz_tc(void *data, int argc, char **argv)
 {
@@ -111,56 +35,55 @@ int
 gt_set(int argc, char **argv)
 {
     const char *dev = NULL;
-    size_t mtu;
-    int tc;
     unsigned long kxtimeout;
     unsigned long timetolerance;
+    unsigned long keepalive;
+    int tc;
 
     struct argz pathz[] = {
         {"dev", "NAME", &dev, argz_str},
-        {"mtu", "BYTES", &mtu, argz_bytes},
         {"tc", "CS|AF|EF", &tc, gt_argz_tc},
         {"kxtimeout", "SECONDS", &kxtimeout, argz_time},
         {"timetolerance", "SECONDS", &timetolerance, argz_time},
+        {"keepalive", "SECONDS", &keepalive, argz_time},
         {NULL}};
 
     if (argz(pathz, argc, argv))
         return 1;
 
-    int fd = ctl_connect(GT_RUNDIR, dev);
+    struct ctl_msg req = {
+        .type = CTL_CONF,
+        .conf = {
+            .tc = tc ? (tc << 1) | 1 : 0,
+            .kxtimeout = kxtimeout * UINT64_C(1000),
+            .timetolerance = timetolerance * UINT64_C(1000),
+            .keepalive = keepalive * UINT64_C(1000),
+        },
+    }, res = {0};
+
+    int fd = ctl_connect(dev);
 
     if (fd < 0) {
-        switch (fd) {
+        ctl_explain_connect(fd);
-        case -1:
-            perror("set");
-            break;
-        case -2:
-            gt_log("no device\n");
-            break;
-        case -3:
-            gt_log("please choose a device\n");
-            break;
-        default:
-            gt_log("couldn't connect\n");
-        }
         return 1;
     }
 
-    int ret = 0;
+    int ret = ctl_reply(fd, &res, &req);
 
-    if (argz_is_set(pathz, "mtu"))
+    char t0[32];
-        ret |= gt_set_mtu(fd, mtu);
+    char t1[32];
+    char t2[32];
 
-    if (argz_is_set(pathz, "tc"))
+    gt_totime(t0, sizeof(t0), res.conf.kxtimeout / 1000);
-        ret |= gt_set_tc(fd, tc);
+    gt_totime(t1, sizeof(t1), res.conf.timetolerance / 1000);
+    gt_totime(t2, sizeof(t2), res.conf.keepalive / 1000);
 
-    if (argz_is_set(pathz, "kxtimeout"))
+    printf("set kxtimeout %s timetolerance %s keepalive %s tc %i\n", t0, t1, t2, res.conf.tc);
-        ret |= gt_set_kxtimeout(fd, kxtimeout);
 
-    if (argz_is_set(pathz, "timetolerance"))
+    if (ret)
-        ret |= gt_set_timetolerance(fd, timetolerance);
+        perror("set");
 
     ctl_delete(fd);
 
-    return ret;
+    return !!ret;
 }

src/show.c

@@ -1,18 +1,53 @@
 #include "common.h"
 #include "ctl.h"
-#include "str.h"
 
 #include "../argz/argz.h"
 
 #include <stdio.h>
-#include <sys/socket.h>
+
-#include <dirent.h>
+static void
-#include <sys/un.h>
+gt_show_bad_line(int term, char *name, uint64_t count,
-#include <arpa/inet.h>
+                 struct sockaddr_storage *ss)
-#include <unistd.h>
+{
+    if (!count)
+        return;
+
+    char addr[INET6_ADDRSTRLEN];
+    gt_toaddr(addr, sizeof(addr), (struct sockaddr *)ss);
+
+    printf(term ? "%s:\n"
+                  "  count: %"PRIu64"\n"
+                  "  last:  %s port %"PRIu16"\n"
+                : "%s"
+                  " %"PRIu64
+                  " %s %"PRIu16
+                  "\n",
+           name, count, addr[0] ? addr : "-",
+           gt_get_port((struct sockaddr *)ss));
+}
 
 static int
-gt_show_dev_status(int fd, const char *dev)
+gt_show_bad(int fd)
+{
+    struct ctl_msg res, req = {.type = CTL_BAD};
+
+    if (ctl_reply(fd, &res, &req))
+        return -1;
+
+    int term = isatty(1);
+
+    gt_show_bad_line(term, "decrypt",
+            res.bad.decrypt.count, &res.bad.decrypt.addr);
+    gt_show_bad_line(term, "difftime",
+            res.bad.difftime.count, &res.bad.difftime.addr);
+    gt_show_bad_line(term, "keyx",
+            res.bad.keyx.count, &res.bad.keyx.addr);
+
+    return 0;
+}
+
+static int
+gt_show_status(int fd)
 {
     struct ctl_msg res, req = {.type = CTL_STATUS};
 
@@ -32,29 +67,29 @@ gt_show_dev_status(int fd, const char *dev)
 
     if (server) {
         printf(term ? "server %s:\n"
-                      "  pid:       %li\n"
+                      "  pid:    %li\n"
-                      "  bind:      %s port %"PRIu16"\n"
+                      "  bind:   %s port %"PRIu16"\n"
-                      "  mtu:       %zu\n"
+                      "  mtu:    %zu\n"
-                      "  cipher:    %s\n"
+                      "  cipher: %s\n"
                     : "server %s"
                       " %li"
                       " %s %"PRIu16
                       " %zu"
                       " %s"
                       "\n",
-               dev,
+               res.status.tun_name,
                res.status.pid,
                bindstr[0] ? bindstr : "-",
                gt_get_port((struct sockaddr *)&res.status.bind),
                res.status.mtu,
-               res.status.chacha ? "chacha20poly1305" : "aes256gcm");
+               GT_CIPHER(res.status.chacha));
     } else {
         printf(term ? "client %s:\n"
-                      "  pid:       %li\n"
+                      "  pid:    %li\n"
-                      "  bind:      %s port %"PRIu16"\n"
+                      "  bind:   %s port %"PRIu16"\n"
-                      "  peer:      %s port %"PRIu16"\n"
+                      "  peer:   %s port %"PRIu16"\n"
-                      "  mtu:       %zu\n"
+                      "  mtu:    %zu\n"
-                      "  cipher:    %s\n"
+                      "  cipher: %s\n"
                     : "client %s"
                       " %li"
                       " %s %"PRIu16
@@ -62,43 +97,19 @@ gt_show_dev_status(int fd, const char *dev)
                       " %zu"
                       " %s"
                       "\n",
-               dev,
+               res.status.tun_name,
                res.status.pid,
                bindstr[0] ? bindstr : "-",
                gt_get_port((struct sockaddr *)&res.status.bind),
                peerstr[0] ? peerstr : "-",
                gt_get_port((struct sockaddr *)&res.status.peer),
                res.status.mtu,
-               res.status.chacha ? "chacha20poly1305" : "aes256gcm");
+               GT_CIPHER(res.status.chacha));
     }
 
     return 0;
 }
 
-static int
-gt_show_dev(const char *dev)
-{
-    int fd = ctl_connect(GT_RUNDIR, dev);
-
-    if (fd < 0) {
-        if (fd == -1)
-            perror("show");
-        return -1;
-    }
-
-    int ret = gt_show_dev_status(fd, dev);
-
-    if (ret == -1)
-        perror(dev);
-
-    if (ret == -2)
-        gt_log("%s: bad reply from server\n", dev);
-
-    ctl_delete(fd);
-
-    return ret;
-}
-
 int
 gt_show(int argc, char **argv)
 {
@@ -106,32 +117,27 @@ gt_show(int argc, char **argv)
 
     struct argz showz[] = {
         {"dev", "NAME", &dev, argz_str},
+        {"bad", NULL, NULL, argz_option},
         {NULL}};
 
     if (argz(showz, argc, argv))
         return 1;
 
-    if (dev)
+    int fd = ctl_connect(dev);
-        return !!gt_show_dev(dev);
 
-    DIR *dp = opendir(GT_RUNDIR);
+    if (fd < 0) {
-
+        ctl_explain_connect(fd);
-    if (!dp) {
-        if (errno == ENOENT)
-            return 0;
-        perror("show");
         return 1;
     }
 
-    int ret = 0;
+    int ret = argz_is_set(showz, "bad")
-    struct dirent *d = NULL;
+            ? gt_show_bad(fd)
+            : gt_show_status(fd);
 
-    while (d = readdir(dp), d) {
+    if (ret == -1)
-        if (d->d_name[0] != '.')
+        perror("show");
-            ret |= !!gt_show_dev(d->d_name);
-    }
 
-    closedir(dp);
+    ctl_delete(fd);
 
-    return ret;
+    return !!ret;
 }

src/str.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include "common.h"
-
-_pure_ static inline int
-str_empty(const char *restrict str)
-{
-    return !str || !str[0];
-}
-
-_pure_ static inline size_t
-str_cmp(const char *restrict sa, const char *restrict sb)
-{
-    if (!sa || !sb)
-        return 1;
-
-    size_t i = 0;
-
-    while (sa[i] == sb[i])
-        if (!sa[i++])
-            return 0;
-
-    return i + 1;
-}
-
-_pure_ static inline size_t
-str_len(const char *restrict str, size_t len)
-{
-    if (!str)
-        return 0;
-
-    return strnlen(str, len);
-}

src/tun.c

@@ -1,14 +1,13 @@
+#include "tun.h"
 #include "common.h"
 #include "ip.h"
-#include "str.h"
-#include "tun.h"
 
 #include <fcntl.h>
+#include <net/if.h>
 #include <stdio.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
-#include <net/if.h>
 
 #ifdef __linux__
 #define IFF_TUN 0x0001
@@ -131,13 +130,21 @@ tun_create_by_name(char *name, size_t len, const char *dev_name)
 static int
 tun_create_by_name(char *name, size_t len, const char *dev_name)
 {
-    int ret = snprintf(name, len, "/dev/%s", dev_name);
+    int ret = snprintf(name, len, "%s", dev_name);
 
     if (ret <= 0 || (size_t)ret >= len) {
         errno = EINVAL;
         return -1;
     }
 
+    char tmp[64];
+    ret = snprintf(tmp, sizeof(tmp), "/dev/%s", dev_name);
+
+    if (ret <= 0 || (size_t)ret >= sizeof(tmp)) {
+        errno = EINVAL;
+        return -1;
+    }
+
     return open(tmp, O_RDWR);
 }
 
@@ -164,7 +171,7 @@ tun_create(char *name, size_t len, const char *dev_name)
 {
     int fd = -1;
 
-    if (str_empty(dev_name)) {
+    if (EMPTY(dev_name)) {
         for (unsigned id = 0; id < 32 && fd == -1; id++)
             fd = tun_create_by_id(name, len, id);
     } else {

src/tun.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stddef.h>
+
 int tun_create      (char *, size_t, const char *);
 int tun_read        (int, void *, size_t);
 int tun_write       (int, const void *, size_t);

src/version.c

@@ -0,0 +1,27 @@
+#include "common.h"
+
+#include <sodium.h>
+
+#include "../argz/argz.h"
+
+int
+gt_version(int argc, char **argv)
+{
+    struct argz version_argz[] = {
+        {"libsodium", NULL, NULL, argz_option},
+        {NULL}};
+
+    if (argz(version_argz, argc, argv))
+        return 1;
+
+    if (argz_is_set(version_argz, "libsodium")) {
+        printf("%i.%i (%s)\n",
+               sodium_library_version_major(),
+               sodium_library_version_minor(),
+               sodium_version_string());
+    } else {
+        printf("%s\n", PACKAGE_VERSION);
+    }
+
+    return 0;
+}