Update mud

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

src/bench.c

@@ -65,12 +65,16 @@ 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 (!crypto_aead_aes256gcm_is_available()) {
+        if (aes) {
             gt_log("aes is not available on your platform\n");
             return 1;
         }
+        chacha = 1;
+    }
 
     unsigned char *buf = calloc(1, bufsize + crypto_aead_aes256gcm_ABYTES);
 

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;
 }
 

src/path.c

@@ -8,49 +8,30 @@
 
 #include "../argz/argz.h"
 
-static int
-gt_path_status(int fd)
+static void
+gt_path_print_status(struct mud_path *path, int term)
 {
-    struct ctl_msg req = {
-        .type = CTL_PATH_STATUS,
-    }, res = {0};
-
-    if (send(fd, &req, sizeof(struct ctl_msg), 0) == -1)
-        return -1;
-
-    int term = isatty(1);
-
-    do {
-        if (recv(fd, &res, sizeof(struct ctl_msg), 0) == -1)
-            return -1;
-
-        if (res.type != req.type)
-            return -2;
-
-        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);
+            (struct sockaddr *)&path->local_addr);
     gt_toaddr(publstr, sizeof(publstr),
-                  (struct sockaddr *)&res.path_status.r_addr);
+            (struct sockaddr *)&path->r_addr);
     gt_toaddr(peerstr, sizeof(peerstr),
-                  (struct sockaddr *)&res.path_status.addr);
+            (struct sockaddr *)&path->addr);
 
     const char *statestr = NULL;
 
-        switch (res.path_status.state) {
+    switch (path->state) {
         case MUD_UP:     statestr = "UP";     break;
         case MUD_BACKUP: statestr = "BACKUP"; break;
         case MUD_DOWN:   statestr = "DOWN";   break;
-            default:         return -2;
+        default:         return;
     }
 
-        const char *statusstr = res.path_status.ok ? "OK" : "DEGRADED";
+    const char *statusstr = path->ok ? "OK" : "DEGRADED";
 
     printf(term ? "path %s\n"
             "  status:   %s\n"
@@ -78,19 +59,53 @@ gt_path_status(int fd)
         statestr,
         statusstr,
         bindstr[0] ? bindstr : "-",
-            gt_get_port((struct sockaddr *)&res.path_status.local_addr),
+        gt_get_port((struct sockaddr *)&path->local_addr),
         publstr[0] ? publstr : "-",
-            gt_get_port((struct sockaddr *)&res.path_status.r_addr),
+        gt_get_port((struct sockaddr *)&path->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);
+        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)
+{
+    struct ctl_msg req = {
+        .type = CTL_PATH_STATUS,
+    }, res = {0};
+
+    if (send(fd, &req, sizeof(struct ctl_msg), 0) == -1)
+        return -1;
+
+    struct mud_path path[MUD_PATH_MAX];
+    int count = 0;
+
+    while (1) {
+        if (recv(fd, &res, sizeof(struct ctl_msg), 0) == -1)
+            return -1;
+
+        if (res.type != req.type)
+            return -2;
+
+        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;
+    }
+
+    int term = isatty(1);
+
+    for (int i = 0; i < count; i++)
+        gt_path_print_status(&path[i], term);
 
     return 0;
 }