Update mud

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: bin
+        path: ./bin

.gitignore

@@ -10,6 +10,7 @@ configure
 build-aux
 .deps
 .dirstamp
+.static
 glorytun
 build*
 VERSION

Makefile

@@ -11,7 +11,10 @@ CFLAGS  ?= -std=c11 -O2 -Wall -fstack-protector-strong
 FLAGS := $(CFLAGS) $(LDFLAGS) $(CPPFLAGS)
 FLAGS += -DPACKAGE_NAME=\"$(NAME)\" -DPACKAGE_VERSION=\"$(VERSION)\"
 
-SRC := argz/argz.c mud/mud.c $(wildcard src/*.c)
+FLAGS += -I.static/$(CROSS)/libsodium-stable/src/libsodium/include
+FLAGS += -L.static/$(CROSS)/libsodium-stable/src/libsodium/.libs
+
+SRC := argz/argz.c mud/mud.c mud/aegis256/aegis256.c $(wildcard src/*.c)
 
 .PHONY: $(NAME)
 $(NAME):

Makefile.am

@@ -9,6 +9,8 @@ glorytun_SOURCES = \
     argz/argz.h \
     mud/mud.c \
     mud/mud.h \
+    mud/aegis256/aegis256.c \
+    mud/aegis256/aegis256.h \
     src/bench.c \
     src/bind.c \
     src/common.c \

README.md

@@ -20,8 +20,8 @@ The key features of Glorytun come directly from mud:
 
    The use of UDP and [libsodium](https://github.com/jedisct1/libsodium) allows you to secure
    your communications without impacting performance.
-   Glorytun uses AES only if AES-NI is available otherwise ChaCha20 is used.
+   Glorytun uses AEGIS-256 only if AES-NI is available otherwise ChaCha20Poly1305 is used.
-   If you are not cpu bounded, you can force the use of ChaCha20 for higher security.
+   If you are not cpu bounded, you can force the use of ChaCha20Poly1305 for higher security.
    All messages are encrypted, authenticated and marked with a timestamp.
    Perfect forward secrecy is also implemented with ECDH over Curve25519.
 
@@ -75,7 +75,7 @@ Just run `glorytun` with no arguments to view the list of available commands:
 $ glorytun
 available commands:
 
-  show     show all running tunnels
+  show     show tunnel info
   bench    start a crypto bench
   bind     start a new tunnel
   set      change tunnel properties

meson.build

@@ -23,6 +23,7 @@ executable('glorytun', install: true,
   sources: [
     'argz/argz.c',
     'mud/mud.c',
+    'mud/aegis256/aegis256.c',
     'src/bench.c',
     'src/bind.c',
     'src/common.c',

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

@@ -13,9 +13,14 @@
 #endif
 
 #include "../argz/argz.h"
+#include "../mud/aegis256/aegis256.h"
 
 #define STR_S(X) (((X) > 1) ? "s" : "")
 
+#define NPUBBYTES 32
+#define KEYBYTES  32
+#define ABYTES    16
+
 static unsigned long long
 gt_now(void)
 {
@@ -65,29 +70,33 @@ gt_bench(int argc, char **argv)
     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 (!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 = calloc(1, bufsize + ABYTES);
 
     if (!buf) {
         perror("calloc");
         return 1;
     }
 
-    unsigned char npub[crypto_aead_aes256gcm_NPUBBYTES];
+    unsigned char npub[NPUBBYTES];
-    unsigned char key[crypto_aead_aes256gcm_KEYBYTES];
+    unsigned char key[KEYBYTES];
 
     randombytes_buf(npub, sizeof(npub));
     randombytes_buf(key, sizeof(key));
 
     if (term) {
         printf("\n");
-        printf("  %-10s %s\n", "bench", chacha ? "chacha20poly1305" : "aes256gcm");
+        printf("  %-10s %s\n", "bench", chacha ? "chacha20poly1305" : "aegis256");
         printf("  %-10s %s\n", "libsodium", sodium_version_string());
         printf("\n");
         printf("  %-10s 2^(-%lu)\n", "precision", precision);
@@ -108,11 +117,6 @@ gt_bench(int argc, char **argv)
         double mbps_dlt = INFINITY;
 
         while (!gt_quit && mbps_dlt > ldexp(mbps, -(int)precision)) {
-            crypto_aead_aes256gcm_state ctx;
-
-            if (!chacha)
-                crypto_aead_aes256gcm_beforenm(&ctx, key);
-
             unsigned long long now = gt_now();
             double mbps_old = mbps;
             size_t bytes = 0;
@@ -125,9 +129,8 @@ gt_bench(int argc, char **argv)
                     crypto_aead_chacha20poly1305_encrypt(
                         buf, NULL, buf, 1ULL << i, NULL, 0, NULL, npub, key);
                 } else {
-                    crypto_aead_aes256gcm_encrypt_afternm(
+                    aegis256_encrypt(
-                        buf, NULL, buf, 1ULL << i, NULL, 0, NULL, npub,
+                        buf, NULL, buf, 1ULL << i, NULL, 0, npub, key);
-                        (const crypto_aead_aes256gcm_state *)&ctx);
                 }
                 bytes += 1ULL << i;
             }

src/bind.c

@@ -18,13 +18,13 @@
 #define O_CLOEXEC 0
 #endif
 
-static void
+static int
 fd_set_nonblock(int fd)
 {
-    int ret;
-
     if (fd == -1)
-        return;
+        return 0;
+
+    int ret;
 
     do {
         ret = fcntl(fd, F_GETFL, 0);
@@ -36,8 +36,7 @@ fd_set_nonblock(int fd)
         ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
     } while (ret == -1 && errno == EINTR);
 
-    if (ret == -1)
+    return ret;
-        perror("fcntl O_NONBLOCK");
 }
 
 static int
@@ -50,7 +49,7 @@ gt_setup_secretkey(struct mud *mud, const char *keyfile)
     } while (fd == -1 && errno == EINTR);
 
     if (fd == -1) {
-        perror("open keyfile");
+        gt_log("couldn't open %s: %s\n", keyfile, strerror(errno));
         return -1;
     }
 
@@ -73,7 +72,7 @@ gt_setup_secretkey(struct mud *mud, const char *keyfile)
     close(fd);
 
     if (size != sizeof(buf)) {
-        gt_log("unable to read secret key\n");
+        gt_log("couldn't read secret key\n");
         return -1;
     }
 
@@ -96,7 +95,7 @@ gt_setup_mtu(struct mud *mud, size_t old, const char *tun_name)
         return mtu;
 
     if (iface_set_mtu(tun_name, mtu) == -1)
-        perror("tun_set_mtu");
+        gt_log("couldn't setup MTU at %zu on device %s\n", mtu, tun_name);
 
     return mtu;
 }
@@ -165,7 +164,7 @@ gt_bind(int argc, char **argv)
     }
 
     char tun_name[64];
-    const int tun_fd = tun_create(tun_name, sizeof(tun_name) - 1, dev);
+    const int tun_fd = tun_create(tun_name, sizeof(tun_name), dev);
 
     if (tun_fd == -1) {
         gt_log("couldn't create tun device\n");
@@ -174,8 +173,10 @@ gt_bind(int argc, char **argv)
 
     size_t mtu = gt_setup_mtu(mud, 0, tun_name);
 
-    if (tun_set_persist(tun_fd, persist) == -1)
+    if (tun_set_persist(tun_fd, persist) == -1) {
-        perror("tun_set_persist");
+        gt_log("couldn't %sable persist mode on device %s\n",
+                persist ? "en" : "dis", tun_name);
+    }
 
     if (peer_addr.ss_family) {
         if (mud_peer(mud, (struct sockaddr *)&peer_addr)) {
@@ -187,43 +188,76 @@ gt_bind(int argc, char **argv)
     const int ctl_fd = ctl_create(GT_RUNDIR, tun_name);
 
     if (ctl_fd == -1) {
-        perror("ctl_create");
+        gt_log("couldn't create "GT_RUNDIR"/%s: %s\n",
+                tun_name, strerror(errno));
         return 1;
     }
 
-    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);
+        fd_set_nonblock(ctl_fd)) {
+        gt_log("couldn't setup non-blocking fds\n");
+        return 1;
+    }
 
     const long pid = (long)getpid();
 
     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;
+
+    int last_fd = MAX(tun_fd, mud_fd);
+    last_fd = 1 + MAX(last_fd, ctl_fd);
 
     unsigned char buf[4096];
 
     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 (send_wait) {
+        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);
         }
 
-        FD_SET(mud_fd, &rfds);
+        if (mud_can_read) {
+            FD_CLR(mud_fd, &rfds);
+        } else {
+            FD_SET(mud_fd, &rfds);
+        }
+
         FD_SET(ctl_fd, &rfds);
 
         struct timeval tv = {
-            .tv_sec  = 0,
+            .tv_usec = 100000,
-            .tv_usec = send_wait,
         };
 
-        const int ret = select(last_fd, &rfds, NULL, NULL, send_wait > 0 ? &tv : NULL);
+        if (mud_can_read && tun_can_write) {
+            tv.tv_usec = 0;
+        } else if (tun_can_read && mud_can_write) {
+            long send_wait = mud_send_wait(mud);
+            if (send_wait >= 0)
+                tv.tv_usec = send_wait * 1000;
+        }
+
+        const int ret = select(last_fd, &rfds, &wfds, NULL, &tv);
 
         if (ret == -1) {
             if (errno == EBADF) {
@@ -233,8 +267,43 @@ 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, ic.tc);
+                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;
@@ -294,6 +363,7 @@ gt_bind(int argc, char **argv)
                         res.ret = errno;
                     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;
@@ -308,35 +378,10 @@ gt_bind(int argc, char **argv)
                 perror("recvfrom(ctl)");
             }
         }
-
-        if (FD_ISSET(mud_fd, &rfds)) {
-            const int r = mud_recv(mud, buf, sizeof(buf));
-
-            if (r > 0 && 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) {
+    if (gt_reload && tun_fd >= 0)
-        if (tun_set_persist(tun_fd, 1) == -1)
+        tun_set_persist(tun_fd, 1);
-            perror("tun_set_persist");
-    }
 
     mud_delete(mud);
     ctl_delete(ctl_fd);

src/ctl.c

@@ -2,6 +2,7 @@
 #include "ctl.h"
 #include "str.h"
 
+#include <stdio.h>
 #include <unistd.h>
 #include <dirent.h>
 #include <sys/socket.h>
@@ -12,17 +13,12 @@
 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 = EINTR;
+        errno = EBADMSG;
         return -1;
     }
 
@@ -41,17 +37,15 @@ ctl_setsun(struct sockaddr_un *dst, const char *dir, const char *file)
         .sun_family = AF_UNIX,
     };
 
-    const char *path[] = {dir, "/", file};
+    int ret = snprintf(sun.sun_path, sizeof(sun.sun_path), "%s/%s", dir, file);
-    const size_t len = sizeof(sun.sun_path) - 1;
 
-    if (str_cat(sun.sun_path, len, path, COUNT(path)) == len) {
+    if (ret <= 0 || (size_t)ret >= sizeof(sun.sun_path)) {
-        if (str_cat(NULL, len + 1, path, COUNT(path)) > len) {
+        errno = EINVAL;
-            errno = EINVAL;
+        return -1;
-            return -1;
-        }
     }
 
-    *dst = sun;
+    if (dst)
+        *dst = sun;
 
     return 0;
 }
@@ -59,39 +53,30 @@ 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)) {
-        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;
-
-        if (!bind(fd, (struct sockaddr *)&sun, sizeof(sun)))
-            return 0;
-    } else {
-        if (ctl_setsun(&sun, dir, file))
-            return -1;
-
-        unlink(sun.sun_path);
-
-        if (!bind(fd, (struct sockaddr *)&sun, sizeof(sun)))
-            return 0;
     }
 
-    return -1;
+    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)
-        return;
-
     struct sockaddr_storage ss = { 0 };
     socklen_t sslen = sizeof(ss);
 
@@ -115,9 +100,6 @@ ctl_create(const char *dir, const char *file)
 
     int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
 
-    if (fd == -1)
-        return -1;
-
     if (ctl_bind(fd, dir, file)) {
         int err = errno;
         close(fd);
@@ -139,9 +121,7 @@ ctl_connect(const char *dir, const char *file)
     }
 
     if (!file) {
-        dp = opendir(dir);
+        if (dp = opendir(dir), !dp)
-
-        if (!dp)
             return -1;
 
         struct dirent *d = NULL;
@@ -152,7 +132,7 @@ ctl_connect(const char *dir, const char *file)
 
             if (file) {
                 closedir(dp);
-                return -3;
+                return CTL_ERROR_MANY;
             }
 
             file = &d->d_name[0];
@@ -160,7 +140,7 @@ ctl_connect(const char *dir, const char *file)
 
         if (!file) {
             closedir(dp);
-            return -2;
+            return CTL_ERROR_NONE;
         }
     }
 
@@ -178,9 +158,6 @@ ctl_connect(const char *dir, const char *file)
 
     int fd = ctl_create(dir, NULL);
 
-    if (fd == -1)
-        return -1;
-
     if (connect(fd, (struct sockaddr *)&sun, sizeof(sun))) {
         int err = errno;
         ctl_delete(fd);

src/ctl.h

@@ -4,6 +4,9 @@
 
 #include <sys/socket.h>
 
+#define CTL_ERROR_NONE (-2)
+#define CTL_ERROR_MANY (-3)
+
 enum ctl_type {
     CTL_NONE = 0,
     CTL_STATE,
@@ -27,6 +30,7 @@ struct ctl_msg {
         } path;
         struct mud_path path_status;
         struct {
+            char tun_name[64];
             long pid;
             size_t mtu;
             int chacha;

src/iface.c

@@ -1,7 +1,7 @@
 #include "common.h"
 #include "iface.h"
-#include "str.h"
 
+#include <stdio.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 
@@ -17,13 +17,11 @@ iface_set_mtu(const char *dev_name, size_t mtu)
         .ifr_mtu = (int)mtu,
     };
 
-    const size_t len = sizeof(ifr.ifr_name) - 1;
+    int ret = snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", dev_name);
 
-    if (str_cpy(ifr.ifr_name, len, dev_name) == len) {
+    if (ret <= 0 || (size_t)ret >= sizeof(ifr.ifr_name)) {
-        if (str_len(dev_name, len + 1) > len) {
+        errno = EINVAL;
-            errno = EINTR;
+        return -1;
-            return -1;
-        }
     }
 
     int fd = socket(AF_INET, SOCK_DGRAM, 0);
@@ -31,7 +29,7 @@ iface_set_mtu(const char *dev_name, size_t mtu)
     if (fd == -1)
         return -1;
 
-    int ret = ioctl(fd, SIOCSIFMTU, &ifr);
+    ret = ioctl(fd, SIOCSIFMTU, &ifr);
 
     int err = errno;
     close(fd);

src/main.c

@@ -1,8 +1,11 @@
 #include "common.h"
 #include "str.h"
 
+#include <sodium.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;
@@ -46,7 +49,19 @@ gt_set_signal(void)
 static int
 gt_version(int argc, char **argv)
 {
-    printf(PACKAGE_VERSION "\n");
+    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("%s\n", sodium_version_string());
+    } else {
+        printf("%s\n", PACKAGE_VERSION);
+    }
+
     return 0;
 }
 
@@ -60,7 +75,7 @@ main(int argc, char **argv)
         char *help;
         int (*call)(int, char **);
     } cmd[] = {
-        {"show", "show all running tunnels", gt_show},
+        {"show", "show tunnel info", gt_show},
         {"bench", "start a crypto bench", gt_bench},
         {"bind", "start a new tunnel", gt_bind},
         {"set", "change tunnel properties", gt_set},

src/path.c

@@ -8,8 +8,94 @@
 
 #include "../argz/argz.h"
 
+static void
+gt_path_print_status(struct mud_path *path, int term)
+{
+    char bindstr[INET6_ADDRSTRLEN];
+    char publstr[INET6_ADDRSTRLEN];
+    char peerstr[INET6_ADDRSTRLEN];
+
+    gt_toaddr(bindstr, sizeof(bindstr),
+            (struct sockaddr *)&path->local_addr);
+    gt_toaddr(publstr, sizeof(publstr),
+            (struct sockaddr *)&path->r_addr);
+    gt_toaddr(peerstr, sizeof(peerstr),
+            (struct sockaddr *)&path->addr);
+
+    const char *statestr = NULL;
+
+    switch (path->state) {
+        case MUD_UP:     statestr = "UP";     break;
+        case MUD_BACKUP: statestr = "BACKUP"; break;
+        case MUD_DOWN:   statestr = "DOWN";   break;
+        default:         return;
+    }
+
+    const char *statusstr = path->ok ? "OK" : "DEGRADED";
+
+    printf(term ? "path %s\n"
+            "  status:   %s\n"
+            "  bind:     %s port %"PRIu16"\n"
+            "  public:   %s port %"PRIu16"\n"
+            "  peer:     %s port %"PRIu16"\n"
+            "  mtu:      %zu bytes\n"
+            "  rtt:      %.3f ms\n"
+            "  rttvar:   %.3f ms\n"
+            "  rate tx:  %"PRIu64" bytes/sec\n"
+            "  rate rx:  %"PRIu64" bytes/sec\n"
+            "  total tx: %"PRIu64" packets\n"
+            "  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 *)&path->local_addr),
+        publstr[0] ? publstr : "-",
+        gt_get_port((struct sockaddr *)&path->r_addr),
+        peerstr[0] ? peerstr : "-",
+        gt_get_port((struct sockaddr *)&path->addr),
+        path->mtu.ok,
+        (double)path->rtt.val / 1e3,
+        (double)path->rtt.var / 1e3,
+        path->rate_tx,
+        path->rate_rx,
+        path->send.total,
+        path->recv.total);
+}
+
 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_status(int fd, int state, struct sockaddr_storage *addr)
 {
     struct ctl_msg req = {
         .type = CTL_PATH_STATUS,
@@ -18,79 +104,34 @@ 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"
+    for (int i = 0; i < count; i++) {
-                      "  public:   %s port %"PRIu16"\n"
+        if ((state == MUD_EMPTY || path[i].state == state) &&
-                      "  peer:     %s port %"PRIu16"\n"
+            (!addr->ss_family || !gt_path_cmp_addr(addr, &path[i].local_addr)))
-                      "  mtu:      %zu bytes\n"
+            gt_path_print_status(&path[i], term);
-                      "  rtt:      %.3f ms\n"
+    }
-                      "  rttvar:   %.3f ms\n"
-                      "  rate tx:  %"PRIu64" bytes/sec\n"
-                      "  rate rx:  %"PRIu64" bytes/sec\n"
-                      "  total tx: %"PRIu64" packets\n"
-                      "  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;
 }
@@ -102,6 +143,9 @@ gt_path(int argc, char **argv)
 
     struct ctl_msg req = {
         .type = CTL_STATE,
+        .path = {
+            .state = MUD_EMPTY,
+        },
     }, res = {0};
 
     struct argz ratez[] = {
@@ -126,10 +170,10 @@ gt_path(int argc, char **argv)
         case -1:
             perror("path");
             break;
-        case -2:
+        case CTL_ERROR_NONE:
             gt_log("no device\n");
             break;
-        case -3:
+        case CTL_ERROR_MANY:
             gt_log("please choose a device\n");
             break;
         default:
@@ -138,24 +182,27 @@ gt_path(int argc, char **argv)
         return 1;
     }
 
-    int ret = 0;
+    int set_rate = argz_is_set(pathz, "rate");
 
-    if (!req.path.addr.ss_family) {
+    if (set_rate && !req.path.addr.ss_family) {
-        ret = gt_path_status(fd);
+        gt_log("please specify a path\n");
+        return 1;
+    }
 
-        if (ret == -2)
+    if (argz_is_set(pathz, "up")) {
-            gt_log("bad reply from server\n");
+        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;
+    }
+
+    int ret;
+
+    if (!req.path.addr.ss_family ||
+        (req.path.state == MUD_EMPTY && !set_rate)) {
+        ret = gt_path_status(fd, req.path.state, &req.path.addr);
     } 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);
     }
 

src/set.c

@@ -134,10 +134,10 @@ gt_set(int argc, char **argv)
         case -1:
             perror("set");
             break;
-        case -2:
+        case CTL_ERROR_NONE:
             gt_log("no device\n");
             break;
-        case -3:
+        case CTL_ERROR_MANY:
             gt_log("please choose a device\n");
             break;
         default:

src/show.c

@@ -12,7 +12,7 @@
 #include <unistd.h>
 
 static int
-gt_show_dev_status(int fd, const char *dev)
+gt_show_status(int fd)
 {
     struct ctl_msg res, req = {.type = CTL_STATUS};
 
@@ -32,17 +32,17 @@ 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),
@@ -50,11 +50,11 @@ gt_show_dev_status(int fd, const char *dev)
                res.status.chacha ? "chacha20poly1305" : "aes256gcm");
     } 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,7 +62,7 @@ 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),
@@ -75,30 +75,6 @@ gt_show_dev_status(int fd, const char *dev)
     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)
 {
@@ -111,27 +87,31 @@ gt_show(int argc, char **argv)
     if (argz(showz, argc, argv))
         return 1;
 
-    if (dev)
+    int fd = ctl_connect(GT_RUNDIR, dev);
-        return !!gt_show_dev(dev);
 
-    DIR *dp = opendir(GT_RUNDIR);
+    if (fd < 0) {
-
+        switch (fd) {
-    if (!dp) {
+        case -1:
-        if (errno == ENOENT)
+            perror("show");
-            return 0;
+            break;
-        perror("show");
+        case CTL_ERROR_NONE:
+            gt_log("no device\n");
+            break;
+        case CTL_ERROR_MANY:
+            gt_log("please choose a device\n");
+            break;
+        default:
+            gt_log("couldn't connect\n");
+        }
         return 1;
     }
 
-    int ret = 0;
+    int ret = gt_show_status(fd);
-    struct dirent *d = NULL;
 
-    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

@@ -31,32 +31,3 @@ str_len(const char *restrict str, size_t len)
 
     return strnlen(str, len);
 }
-
-static inline size_t
-str_cat(char *dst, size_t dst_len, const char **src, size_t count)
-{
-    if (count && !src)
-        return 0;
-
-    size_t len = 0;
-
-    for (size_t i = 0; i < count && dst_len > len; i++) {
-        size_t n = str_len(src[i], dst_len - len);
-
-        if (dst && n)
-            memmove(&dst[len], src[i], n);
-
-        len += n;
-    }
-
-    if (dst)
-        dst[len] = 0;
-
-    return len;
-}
-
-static inline size_t
-str_cpy(char *dst, size_t dst_len, const char *src)
-{
-    return str_cat(dst, dst_len, &src, 1);
-}

src/tun.c

@@ -32,9 +32,9 @@
 static int
 tun_create_by_id(char *name, size_t len, unsigned id)
 {
-    int ret = snprintf(name, len + 1, "utun%u", id);
+    int ret = snprintf(name, len, "utun%u", id);
 
-    if (ret <= 0 || ret > len) {
+    if (ret <= 0 || (size_t)ret >= len) {
         errno = EINVAL;
         return -1;
     }
@@ -44,8 +44,9 @@ tun_create_by_id(char *name, size_t len, unsigned id)
     if (fd == -1)
         return -1;
 
-    struct ctl_info ci = {0};
+    struct ctl_info ci = {
-    str_cpy(ci.ctl_name, sizeof(ci.ctl_name) - 1, UTUN_CONTROL_NAME);
+        .ctl_name = UTUN_CONTROL_NAME,
+    };
 
     if (ioctl(fd, CTLIOCGINFO, &ci)) {
         int err = errno;
@@ -92,14 +93,20 @@ 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, "%s", dev_name);
+
+    if (ret <= 0 || (size_t)ret >= len) {
+        errno = EINVAL;
+        return -1;
+    }
+
     struct ifreq ifr = {
         .ifr_flags = IFF_TUN | IFF_NO_PI,
     };
 
-    const size_t ifr_len = sizeof(ifr.ifr_name) - 1;
+    ret = snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", dev_name);
 
-    if ((len < ifr_len) ||
+    if (ret <= 0 || (size_t)ret >= sizeof(ifr.ifr_name)) {
-        (str_len(dev_name, ifr_len + 1) > ifr_len)) {
         errno = EINVAL;
         return -1;
     }
@@ -109,8 +116,6 @@ tun_create_by_name(char *name, size_t len, const char *dev_name)
     if (fd == -1)
         return -1;
 
-    str_cpy(ifr.ifr_name, ifr_len, dev_name);
-
     if (ioctl(fd, TUNSETIFF, &ifr)) {
         int err = errno;
         close(fd);
@@ -118,8 +123,6 @@ tun_create_by_name(char *name, size_t len, const char *dev_name)
         return -1;
     }
 
-    str_cpy(name, len, ifr.ifr_name);
-
     return fd;
 }
 
@@ -128,21 +131,13 @@ 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)
 {
-    char tmp[128];
+    int ret = snprintf(name, len, "/dev/%s", dev_name);
-    int ret = snprintf(tmp, sizeof(tmp), "/dev/%s", dev_name);
 
-    if (ret <= 0 || (size_t)ret >= sizeof(tmp)) {
+    if (ret <= 0 || (size_t)ret >= len) {
         errno = EINVAL;
         return -1;
     }
 
-    if (str_cpy(name, len, dev_name) == len) {
-        if (str_len(dev_name, len + 1) > len) {
-            errno = EINVAL;
-            return -1;
-        }
-    }
-
     return open(tmp, O_RDWR);
 }