Don't forget BSD..

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

src/bench.c

@@ -105,7 +105,7 @@ gt_bench(int argc, char **argv)
         double mbps_max = 0.0;
         double mbps_dlt = INFINITY;
 
-        while (!gt_quit && mbps_dlt > ldexp(mbps, -precision)) {
+        while (!gt_quit && mbps_dlt > ldexp(mbps, -(int)precision)) {
             crypto_aead_aes256gcm_state ctx;
 
             if (!chacha)

src/bind.c

@@ -192,7 +192,7 @@ gt_bind(int argc, char **argv)
         }
     }
 
-    int ctl_fd = ctl_create("/run/" PACKAGE_NAME, tun_name);
+    int ctl_fd = ctl_create(GT_RUNDIR, tun_name);
 
     if (ctl_fd == -1) {
         perror("ctl_create");
@@ -257,17 +257,18 @@ gt_bind(int argc, char **argv)
                         res.ret = EAGAIN;
 
                         for (unsigned i = 0; i < count; i++) {
-                            if (i && sendto(ctl_fd, &res, sizeof(res), 0,
+                            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)");
-                            memcpy(&res.path_status, &paths[i], sizeof(struct mud_path));
                         }
 
+                        free(paths);
                         res.ret = 0;
                     }
                     break;
                 case CTL_MTU:
-                    mud_set_mtu(mud, (size_t)req.mtu);
+                    mud_set_mtu(mud, req.mtu);
                     mtu = gt_setup_mtu(mud, tun_name);
                     res.mtu = mtu;
                     break;
@@ -275,12 +276,16 @@ gt_bind(int argc, char **argv)
                     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_TIMEOUT:
-                    if (mud_set_send_timeout(mud, req.timeout))
+                    if (mud_set_send_timeout(mud, req.ms))
                         res.ret = errno;
                     break;
                 case CTL_TIMETOLERANCE:
-                    if (mud_set_time_tolerance(mud, req.timetolerance))
+                    if (mud_set_time_tolerance(mud, req.ms))
                         res.ret = errno;
                     break;
                 case CTL_STATUS:
@@ -299,88 +304,33 @@ gt_bind(int argc, char **argv)
         }
 
         if (FD_ISSET(tun_fd, &rfds)) {
-            size_t size = 0;
-
-            while (bufsize - size >= mtu) {
-                const int r = tun_read(tun_fd, &buf[size], bufsize - size);
-
-                if (r <= 0 || r > mtu)
-                    break;
-
             struct ip_common ic;
+            const int r = tun_read(tun_fd, buf, bufsize);
 
-                if (ip_get_common(&ic, &buf[size], r) || ic.size != r)
+            if (r <= 0) {
-                    break;
+                if (r == -1 && errno != EAGAIN)
-
+                    perror("tun_read");
-                size += r;
+            } else if ((!ip_get_common(&ic, buf, r)) &&
-            }
+                       (mud_send(mud, buf, r, ic.tc) == -1)) {
-
-            size_t p = 0;
-
-            while (p < size) {
-                size_t q = p;
-                int tc = 0;
-
-                while (q < size) {
-                    struct ip_common ic;
-
-                    if ((ip_get_common(&ic, &buf[q], size - q)) ||
-                        (ic.size > size - q))
-                        break;
-
-                    if (q + ic.size > p + mtu)
-                        break;
-
-                    q += ic.size;
-
-                    if (tc < (ic.tc & 0xFC))
-                        tc = ic.tc & 0xFC;
-                }
-
-                if (p >= q)
-                    break;
-
-                int r = mud_send(mud, &buf[p], q - p, tc);
-
-                if (r == -1) {
                 if (errno == EMSGSIZE) {
                     mtu = gt_setup_mtu(mud, tun_name);
                 } else if (errno != EAGAIN) {
                     perror("mud_send");
                 }
             }
-
-                p = q;
-            }
         }
 
         if (FD_ISSET(mud_fd, &rfds)) {
-            size_t size = 0;
+            struct ip_common ic;
-
+            const int r = mud_recv(mud, buf, bufsize);
-            while (bufsize - size >= mtu) {
-                const int r = mud_recv(mud, &buf[size], bufsize - size);
 
             if (r <= 0) {
                 if (r == -1 && errno != EAGAIN)
                     perror("mud_recv");
-                    break;
+            } else if ((!ip_get_common(&ic, buf, r)) &&
-                }
+                       (tun_write(tun_fd, buf, r) == -1)) {
-
+                if (errno != EAGAIN)
-                size += r;
+                    perror("tun_write");
-            }
-
-            size_t p = 0;
-
-            while (p < size) {
-                struct ip_common ic;
-
-                if ((ip_get_common(&ic, &buf[p], size - p)) ||
-                    (ic.size > size - p))
-                    break;
-
-                tun_write(tun_fd, &buf[p], ic.size);
-
-                p += ic.size;
             }
         }
     }
@@ -390,7 +340,9 @@ gt_bind(int argc, char **argv)
             perror("tun_set_persist");
     }
 
+    mud_delete(mud);
     ctl_delete(ctl_fd);
+    free(buf);
 
     return 0;
 }

src/common.c

@@ -99,6 +99,9 @@ gt_get_port(struct sockaddr *sa)
 int
 gt_toaddr(char *str, size_t size, struct sockaddr *sa)
 {
+    if (str)
+        str[0] = 0;
+
     switch (sa->sa_family) {
     case AF_INET:
         return -!inet_ntop(AF_INET,
@@ -108,5 +111,6 @@ gt_toaddr(char *str, size_t size, struct sockaddr *sa)
                            &((struct sockaddr_in6 *)sa)->sin6_addr, str, size);
     }
 
+    errno = EAFNOSUPPORT;
     return -1;
 }

src/common.h

@@ -21,6 +21,10 @@
 #define PACKAGE_VERSION "0.0.0"
 #endif
 
+#ifndef GT_RUNDIR
+#define GT_RUNDIR "/run/" PACKAGE_NAME
+#endif
+
 #define COUNT(x)       (sizeof(x)/sizeof(x[0]))
 
 #define ALIGN_SIZE     (1<<4)

src/ctl.c

@@ -133,13 +133,15 @@ ctl_create(const char *dir, const char *file)
 int
 ctl_connect(const char *dir, const char *file)
 {
+    DIR *dp = NULL;
+
     if (str_empty(dir)) {
         errno = EINVAL;
         return -1;
     }
 
     if (!file) {
-        DIR *dp = opendir(dir);
+        dp = opendir(dir);
 
         if (!dp)
             return -1;
@@ -151,20 +153,30 @@ ctl_connect(const char *dir, const char *file)
                 continue;
 
             if (file) {
-                closedir(dp);
+                file = NULL;
-                errno = ENOENT;
+                break;
-                return -1;
             }
 
             file = &d->d_name[0];
         }
 
+        if (!file) {
             closedir(dp);
+            errno = ENOENT;
+            return -1;
+        }
     }
 
     struct sockaddr_un sun;
+    const int ret = ctl_setsun(&sun, dir, file);
 
-    if (ctl_setsun(&sun, dir, file))
+    if (dp) {
+        int err = errno;
+        closedir(dp);
+        errno = err;
+    }
+
+    if (ret)
         return -1;
 
     int fd = ctl_create(dir, NULL);

src/ctl.h

@@ -10,6 +10,7 @@ enum ctl_type {
     CTL_STATUS,
     CTL_MTU,
     CTL_TC,
+    CTL_KXTIMEOUT,
     CTL_TIMEOUT,
     CTL_TIMETOLERANCE,
     CTL_PATH_STATUS,
@@ -30,10 +31,9 @@ struct ctl_msg {
             struct sockaddr_storage bind;
             struct sockaddr_storage peer;
         } status;
-        int mtu;
+        size_t mtu;
         int tc;
-        unsigned long timeout;
+        unsigned long ms;
-        unsigned long timetolerance;
     };
 };
 

src/ip.h

@@ -3,32 +3,16 @@
 #include <stdint.h>
 
 struct ip_common {
-    uint8_t version;
     uint8_t tc;
     uint8_t proto;
-    uint8_t hdr_size;
-    uint16_t size;
 };
 
-_pure_ static inline uint8_t
+static inline uint8_t
-ip_get_version(const uint8_t *data, size_t size)
+ip_get_version(const uint8_t *data)
 {
-    if (size < 20)
-        return 0;
-
     return data[0] >> 4;
 }
 
-static inline uint32_t
-ip_read32(const uint8_t *src)
-{
-    uint32_t ret = src[3];
-    ret |= ((uint32_t)src[2]) << 8;
-    ret |= ((uint32_t)src[1]) << 16;
-    ret |= ((uint32_t)src[0]) << 24;
-    return ret;
-}
-
 static inline uint16_t
 ip_read16(const uint8_t *src)
 {
@@ -37,45 +21,22 @@ ip_read16(const uint8_t *src)
     return ret;
 }
 
-static inline size_t
-ip_get_mtu(struct ip_common *ic, const uint8_t *data, size_t size)
-{
-    if (ic->hdr_size <= 0 || ic->hdr_size + 8 > size)
-        return 0;
-
-    const uint8_t *p = &data[ic->hdr_size];
-
-    if (ic->version == 4 && ic->proto == 1 && p[0] == 3)
-        return ip_read16(&p[6]);
-
-    // not tested..
-    // if (ic->version == 6 && ic->proto == 58 && p[0] == 2)
-    //    return ip_read32(&p[4]);
-
-    return 0;
-}
-
 static inline int
 ip_get_common(struct ip_common *ic, const uint8_t *data, size_t size)
 {
-    ic->version = ip_get_version(data, size);
+    if (size < 20)
+        return 1;
 
-    switch (ic->version) {
+    switch (ip_get_version(data)) {
     case 4:
         ic->tc = data[1];
         ic->proto = data[9];
-        ic->hdr_size = (data[0] & 0xF) << 2;
+        return size != ip_read16(&data[2]);
-        ic->size = ip_read16(&data[2]);
-        if (ic->size >= 20)
-            return 0;
-        break;
     case 6:
         ic->tc = ((data[0] & 0xF) << 4) | (data[1] >> 4);
         ic->proto = data[6];
-        ic->hdr_size = 40;
+        return size != ip_read16(&data[4]) + 40;
-        ic->size = ip_read16(&data[4]) + 40;
-        return 0;
     }
 
-    return -1;
+    return 1;
 }

src/path.c

@@ -21,15 +21,23 @@ gt_path_status(int fd)
         if (recv(fd, &res, sizeof(struct ctl_msg), 0) == -1)
             return -1;
 
-        char bindstr[INET6_ADDRSTRLEN] = {0};
+        if (res.type != req.type)
-        char peerstr[INET6_ADDRSTRLEN] = {0};
-
-        if (gt_toaddr(bindstr, sizeof(bindstr),
-                      (struct sockaddr *)&res.path_status.local_addr) ||
-            gt_toaddr(peerstr, sizeof(peerstr),
-                      (struct sockaddr *)&res.path_status.addr))
             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);
+        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) {
@@ -40,13 +48,20 @@ gt_path_status(int fd)
         }
 
         printf("path %s\n"
-               "  bind:  %s\n"
+               "  bind:   %s port %"PRIu16"\n"
+               "  public: %s port %"PRIu16"\n"
                "  peer:   %s port %"PRIu16"\n"
-               "  rtt:   %.3f\n",
+               "  mtu:    %zu bytes\n"
-               statestr, bindstr, peerstr,
+               "  rtt:    %.3f ms\n",
+               statestr,
+               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 + 28U,     /* ip+udp hdr */
                res.path_status.rtt/(double)1e3);
-
     } while (res.ret == EAGAIN);
 
     return 0;
@@ -70,7 +85,7 @@ gt_path(int argc, char **argv)
     if (argz(pathz, argc, argv))
         return 1;
 
-    int fd = ctl_connect("/run/" PACKAGE_NAME, dev);
+    int fd = ctl_connect(GT_RUNDIR, dev);
 
     if (fd == -1) {
         perror("path");

src/set.c

@@ -22,17 +22,35 @@ gt_set_mtu(int fd, size_t mtu)
         return 1;
     }
 
-    printf("mtu set to %i\n", res.mtu);
+    printf("mtu set to %zu\n", res.mtu);
 
     return 0;
 }
 
 static int
-gt_set_timeout(int fd, unsigned long timeout)
+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_timeout(int fd, unsigned long ms)
 {
     struct ctl_msg res, req = {
         .type = CTL_TIMEOUT,
-        .timeout = timeout,
+        .ms = ms,
     };
 
     int ret = ctl_reply(fd, &res, &req);
@@ -46,11 +64,11 @@ gt_set_timeout(int fd, unsigned long timeout)
 }
 
 static int
-gt_set_timetolerance(int fd, unsigned long timetolerance)
+gt_set_timetolerance(int fd, unsigned long ms)
 {
     struct ctl_msg res, req = {
         .type = CTL_TIMETOLERANCE,
-        .timetolerance = timetolerance,
+        .ms = ms,
     };
 
     int ret = ctl_reply(fd, &res, &req);
@@ -113,13 +131,15 @@ gt_set(int argc, char **argv)
     const char *dev = NULL;
     size_t mtu;
     int tc;
-    unsigned long timetolerance;
+    unsigned long kxtimeout;
     unsigned long timeout;
+    unsigned long timetolerance;
 
     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},
         {"timeout", "SECONDS", &timeout, argz_time},
         {"timetolerance", "SECONDS", &timetolerance, argz_time},
         {NULL}};
@@ -127,7 +147,7 @@ gt_set(int argc, char **argv)
     if (argz(pathz, argc, argv))
         return 1;
 
-    int fd = ctl_connect("/run/" PACKAGE_NAME, dev);
+    int fd = ctl_connect(GT_RUNDIR, dev);
 
     if (fd == -1) {
         perror("set");
@@ -142,6 +162,9 @@ gt_set(int argc, char **argv)
     if (argz_is_set(pathz, "tc"))
         ret |= gt_set_tc(fd, tc);
 
+    if (argz_is_set(pathz, "kxtimeout"))
+        ret |= gt_set_kxtimeout(fd, kxtimeout);
+
     if (argz_is_set(pathz, "timeout"))
         ret |= gt_set_timeout(fd, timeout);
 

src/show.c

@@ -18,12 +18,11 @@ gt_show_dev_status(int fd, const char *dev)
     if (ctl_reply(fd, &res, &req))
         return -1;
 
-    char bindstr[INET6_ADDRSTRLEN] = {0};
+    char bindstr[INET6_ADDRSTRLEN];
-    char peerstr[INET6_ADDRSTRLEN] = {0};
+    char peerstr[INET6_ADDRSTRLEN];
 
-    if (gt_toaddr(bindstr, sizeof(bindstr),
+    gt_toaddr(bindstr, sizeof(bindstr),
-                  (struct sockaddr *)&res.status.bind))
+              (struct sockaddr *)&res.status.bind);
-        return -2;
 
     int server = gt_toaddr(peerstr, sizeof(peerstr),
                            (struct sockaddr *)&res.status.peer);
@@ -34,7 +33,8 @@ gt_show_dev_status(int fd, const char *dev)
                "  mtu:       %zu\n"
                "  cipher:    %s\n",
                dev,
-               bindstr, gt_get_port((struct sockaddr *)&res.status.bind),
+               bindstr[0] ? bindstr : "-",
+               gt_get_port((struct sockaddr *)&res.status.bind),
                res.status.mtu,
                res.status.chacha ? "chacha20poly1305" : "aes256gcm");
     } else {
@@ -44,8 +44,10 @@ gt_show_dev_status(int fd, const char *dev)
                "  mtu:       %zu\n"
                "  cipher:    %s\n",
                dev,
-               bindstr, gt_get_port((struct sockaddr *)&res.status.bind),
+               bindstr[0] ? bindstr : "-",
-               peerstr, gt_get_port((struct sockaddr *)&res.status.peer),
+               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");
     }
@@ -56,7 +58,7 @@ gt_show_dev_status(int fd, const char *dev)
 static int
 gt_show_dev(const char *dev)
 {
-    int fd = ctl_connect("/run/" PACKAGE_NAME, dev);
+    int fd = ctl_connect(GT_RUNDIR, dev);
 
     if (fd == -1) {
         perror(dev);
@@ -93,7 +95,7 @@ gt_show(int argc, char **argv)
         return 0;
     }
 
-    DIR *dp = opendir("/run/" PACKAGE_NAME);
+    DIR *dp = opendir(GT_RUNDIR);
 
     if (!dp) {
         if (errno == ENOENT)

src/tun.c

@@ -224,7 +224,7 @@ tun_write(int fd, const void *data, size_t size)
 #ifdef GT_BSD_TUN
     uint32_t family;
 
-    switch (ip_get_version(data, size)) {
+    switch (ip_get_version(data)) {
     case 4:
         family = htonl(AF_INET);
         break;