Add meson.build

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

.build.sh

@@ -11,5 +11,8 @@ cd ..
 [ -x glorytun ] || exit 1
 
 mkdir -p deploy
+
+cp glorytun deploy/glorytun-$(cat VERSION)-$(uname -m).debug.bin
+
 strip -s glorytun
-mv glorytun deploy/glorytun-$(cat VERSION)-$(uname -m).bin
+cp glorytun deploy/glorytun-$(cat VERSION)-$(uname -m).bin

Makefile.am

@@ -14,10 +14,11 @@ glorytun_SOURCES = \
     src/option.h \
     src/tun.c \
     src/tun.h \
+    src/iface.c \
+    src/iface.h \
     src/db.c \
     src/db.h
 
-glorytun_CFLAGS  += -I$(srcdir)/mud
 glorytun_SOURCES += \
     mud/mud.h \
     mud/mud.c

meson.build

@@ -0,0 +1,10 @@
+project('glorytun', 'c',
+    version: run_command('./version.sh').stdout()
+)
+
+add_global_arguments('-DPACKAGE_VERSION="'+meson.project_version()+'"', language : 'c')
+
+executable('glorytun', install: true,
+    sources: [ 'src/main.c', 'src/common.c', 'src/option.c', 'src/tun.c', 'src/iface.c', 'mud/mud.c' ],
+    dependencies: [ dependency('libsodium', version : '>=1.0.4') ]
+)

src/common.c

@@ -26,23 +26,6 @@ gt_log(const char *fmt, ...)
     va_end(ap);
 }
 
-void
-gt_fatal(const char *fmt, ...)
-{
-    va_list ap;
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-
-    exit(EXIT_FAILURE);
-}
-
-void
-gt_na(const char *name)
-{
-    gt_log("%s is not available on your platform\n", name);
-}
-
 int
 gt_tohex(char *dst, size_t dst_size, const uint8_t *src, size_t src_size)
 {

src/common.h

@@ -37,8 +37,6 @@
 
 int  gt_print (const char *, ...) _printf_(1,2);
 void gt_log   (const char *, ...) _printf_(1,2);
-void gt_fatal (const char *, ...) _printf_(1,2) _noreturn_;
-void gt_na    (const char *);
 
 int gt_tohex   (char *, size_t, const uint8_t *, size_t);
 int gt_fromhex (uint8_t *, size_t, const char *, size_t);

src/iface.c

@@ -0,0 +1,29 @@
+#include "common.h"
+
+#include "str.h"
+
+#include <sys/ioctl.h>
+#include <net/if.h>
+
+int
+iface_set_mtu(char *dev_name, int mtu)
+{
+    struct ifreq ifr = {
+        .ifr_mtu = mtu,
+    };
+
+    str_cpy(ifr.ifr_name, dev_name, IFNAMSIZ - 1);
+
+    int fd = socket(AF_INET, SOCK_DGRAM, 0);
+
+    if (fd == -1)
+        return -1;
+
+    int ret = ioctl(fd, SIOCSIFMTU, &ifr);
+
+    int err = errno;
+    close(fd);
+    errno = err;
+
+    return ret;
+}

src/iface.h

@@ -0,0 +1,3 @@
+#pragma once
+
+int iface_set_mtu (char *, int);

src/ip.h

@@ -10,16 +10,17 @@ struct ip_common {
     uint16_t size;
 };
 
-_pure_
-static inline uint8_t ip_get_version (const uint8_t *data, size_t size)
+_pure_ static inline uint8_t
+ip_get_version(const uint8_t *data, size_t size)
 {
-    if (size<20)
+    if (size < 20)
         return 0;
 
-    return data[0]>>4;
+    return data[0] >> 4;
 }
 
-static inline int ip_get_common (struct ip_common *ic, const uint8_t *data, size_t size)
+static inline int
+ip_get_common(struct ip_common *ic, const uint8_t *data, size_t size)
 {
     ic->version = ip_get_version(data, size);
 
@@ -27,14 +28,16 @@ static inline int ip_get_common (struct ip_common *ic, const uint8_t *data, size
     case 4:
         ic->tc = data[1];
         ic->proto = data[9];
-        ic->hdr_size = (data[0]&0xF)<<2;
-        ic->size = ((data[2]<<8)|data[3]);
-        return 0;
+        ic->hdr_size = (data[0] & 0xF) << 2;
+        ic->size = ((data[2] << 8) | data[3]);
+        if (ic->size >= 20)
+            return 0;
+        break;
     case 6:
-        ic->tc = ((data[0]&0xF)<<4)|(data[1]>>4);
+        ic->tc = ((data[0] & 0xF) << 4) | (data[1] >> 4);
         ic->proto = data[6];
         ic->hdr_size = 40;
-        ic->size = ((data[4]<<8)|data[5])+40;
+        ic->size = ((data[4] << 8) | data[5]) + 40;
         return 0;
     }
 

src/main.c

@@ -5,6 +5,7 @@
 #include "option.h"
 #include "str.h"
 #include "tun.h"
+#include "iface.h"
 
 #include <fcntl.h>
 #include <inttypes.h>
@@ -18,16 +19,21 @@
 #include <arpa/inet.h>
 #include <netdb.h>
 
-#include "mud.h"
+#include "../mud/mud.h"
 
 #ifndef O_CLOEXEC
 #define O_CLOEXEC 0
 #endif
 
-#define GT_MTU(X) ((X) - 28)
+#ifndef PACKAGE_VERSION
+#define PACKAGE_VERSION "unknown"
+#endif
+
+#define GT_MTU(X) ((X)-28)
 
 static struct {
     volatile sig_atomic_t quit;
+    volatile sig_atomic_t reload;
     char *dev;
     char *keyfile;
     char *host;
@@ -45,16 +51,26 @@ static struct {
     int mtu_auto;
     int chacha20;
     int version;
+    int keygen;
+    int persist;
+    struct {
+        unsigned char *data;
+        long size;
+    } buf;
 } gt = {
     .port = 5000,
     .bind = {
         .port = 5000,
     },
+    .mtu = 1500,
     .timeout = 5000,
     .ipv4 = 1,
 #ifdef __linux__
     .ipv6 = 1,
 #endif
+    .buf = {
+        .size = 64 * 1024,
+    },
 };
 
 static void
@@ -79,6 +95,7 @@ fd_set_nonblock(int fd)
 static void
 gt_quit_handler(int sig)
 {
+    gt.reload = (sig == SIGHUP);
     gt.quit = 1;
 }
 
@@ -95,9 +112,9 @@ gt_set_signal(void)
     sigaction(SIGINT, &sa, NULL);
     sigaction(SIGQUIT, &sa, NULL);
     sigaction(SIGTERM, &sa, NULL);
+    sigaction(SIGHUP, &sa, NULL);
 
     sa.sa_handler = SIG_IGN;
-    sigaction(SIGHUP, &sa, NULL);
     sigaction(SIGPIPE, &sa, NULL);
     sigaction(SIGUSR1, &sa, NULL);
     sigaction(SIGUSR2, &sa, NULL);
@@ -115,7 +132,7 @@ gt_print_secretkey(struct mud *mud)
     char buf[2 * sizeof(key) + 1];
 
     gt_tohex(buf, sizeof(buf), key, size);
-    gt_print("secret key: %s\n", buf);
+    gt_print("%s\n", buf);
 }
 
 static int
@@ -177,14 +194,17 @@ gt_setup_option(int argc, char **argv)
         { "bind-backup",    &gt.bind.backup,    option_str    },
         { "bind-port",      &gt.bind.port,      option_long   },
         { "dev",            &gt.dev,            option_str    },
+        { "persist",        NULL,               option_option },
         { "mtu",            &gt.mtu,            option_long   },
         { "mtu-auto",       NULL,               option_option },
         { "keyfile",        &gt.keyfile,        option_str    },
+        { "keygen",         NULL,               option_option },
         { "timeout",        &gt.timeout,        option_long   },
         { "time-tolerance", &gt.time_tolerance, option_long   },
         { "v4only",         NULL,               option_option },
         { "v6only",         NULL,               option_option },
         { "chacha20",       NULL,               option_option },
+        { "buf-size",       &gt.buf.size,       option_long   },
         { "version",        NULL,               option_option },
         {  NULL                                               },
     };
@@ -202,13 +222,13 @@ gt_setup_option(int argc, char **argv)
         return 1;
     }
 
-    if (gt.host && !option_is_set(opts, "keyfile")) {
-        gt_log("keyfile option must be set\n");
+    if ((int)gt.timeout <= 0) {
+        gt_log("bad timeout\n");
         return 1;
     }
 
-    if ((int)gt.timeout <= 0) {
-        gt_log("bad timeout\n");
+    if (gt.buf.size <= 0) {
+        gt_log("bad buf-size\n");
         return 1;
     }
 
@@ -225,10 +245,30 @@ gt_setup_option(int argc, char **argv)
     gt.mtu_auto = option_is_set(opts, "mtu-auto");
     gt.chacha20 = option_is_set(opts, "chacha20");
     gt.version = option_is_set(opts, "version");
+    gt.keygen = option_is_set(opts, "keygen");
+    gt.persist = option_is_set(opts, "persist");
+
+    gt.buf.data = malloc(gt.buf.size);
 
     return 0;
 }
 
+static void
+gt_setup_mtu(struct mud *mud, char *tun_name)
+{
+    int mtu = mud_get_mtu(mud);
+
+    if (mtu == (int)gt.mtu)
+        return;
+
+    gt.mtu = mtu;
+
+    gt_log("setup MTU to %i on interface %s\n", mtu, tun_name);
+
+    if (iface_set_mtu(tun_name, mtu) == -1)
+        perror("tun_set_mtu");
+}
+
 int
 main(int argc, char **argv)
 {
@@ -238,7 +278,7 @@ main(int argc, char **argv)
         return 1;
 
     if (gt.version) {
-        gt_print(PACKAGE_STRING "\n");
+        gt_print(PACKAGE_VERSION "\n");
         return 0;
     }
 
@@ -251,6 +291,36 @@ main(int argc, char **argv)
             gt_log("couldn't create ICMP socket\n");
     }
 
+    struct mud *mud = mud_create(gt.bind.port, gt.ipv4, gt.ipv6);
+
+    if (!mud) {
+        gt_log("couldn't create mud\n");
+        return 1;
+    }
+
+    if (gt.keygen || str_empty(gt.keyfile)) {
+        if (mud_new_key(mud)) {
+            gt_log("couldn't generate a new key\n");
+            return 1;
+        }
+    }
+
+    if (gt.keygen) {
+        gt_print_secretkey(mud);
+        return 0;
+    }
+
+    if (!gt.chacha20 && mud_set_aes(mud))
+        gt_log("AES is not available\n");
+
+    if (gt.timeout > 0)
+        mud_set_send_timeout_msec(mud, gt.timeout);
+
+    if (gt.time_tolerance > 0)
+        mud_set_time_tolerance_sec(mud, gt.time_tolerance);
+
+    mud_set_mtu(mud, GT_MTU(gt.mtu));
+
     char *tun_name = NULL;
 
     int tun_fd = tun_create(gt.dev, &tun_name);
@@ -260,26 +330,17 @@ main(int argc, char **argv)
         return 1;
     }
 
-    struct mud *mud = mud_create(gt.bind.port, gt.ipv4, gt.ipv6,
-                                 !gt.chacha20, GT_MTU(gt.mtu));
-
-    if (!mud) {
-        gt_log("couldn't create mud\n");
-        return 1;
-    }
+    if (tun_set_persist(tun_fd, gt.persist) == -1)
+        perror("tun_set_persist");
 
     if (str_empty(gt.keyfile)) {
+        gt_print("here is your new secret key:\n");
         gt_print_secretkey(mud);
     } else {
         if (gt_setup_secretkey(mud, gt.keyfile))
             return 1;
     }
 
-    mud_set_send_timeout_msec(mud, gt.timeout);
-
-    if (gt.time_tolerance > 0)
-        mud_set_time_tolerance_sec(mud, gt.time_tolerance);
-
     if (gt.host && gt.port) {
         if (gt.bind.backup) {
             if (mud_peer(mud, gt.bind.backup, gt.host, gt.port, 1)) {
@@ -313,25 +374,21 @@ main(int argc, char **argv)
         }
     }
 
-    gt.mtu = GT_MTU(mud_get_mtu(mud));
-
-    if (tun_set_mtu(tun_name, gt.mtu) == -1) {
-        perror("tun_set_mtu");
-        return 1;
-    }
+    gt_setup_mtu(mud, tun_name);
 
     int mud_fd = mud_get_fd(mud);
 
     fd_set_nonblock(tun_fd);
     fd_set_nonblock(mud_fd);
 
+    if (icmp_fd != -1)
+        fd_set_nonblock(icmp_fd);
+
     gt_log("running...\n");
 
     fd_set rfds;
     FD_ZERO(&rfds);
 
-    unsigned char buf[8 * 1024];
-
     int last_fd = 1 + MAX(tun_fd, MAX(mud_fd, icmp_fd));
 
     while (!gt.quit) {
@@ -351,12 +408,12 @@ main(int argc, char **argv)
         if (icmp_fd != -1 && FD_ISSET(icmp_fd, &rfds)) {
             struct sockaddr_storage ss;
             socklen_t sl = sizeof(ss);
-            ssize_t r = recvfrom(icmp_fd, buf, sizeof(buf), 0,
+            ssize_t r = recvfrom(icmp_fd, gt.buf.data, gt.buf.size, 0,
                                  (struct sockaddr *)&ss, &sl);
             if (r >= 8) {
                 struct ip_common ic;
-                if (!ip_get_common(&ic, buf, r) && ic.proto == 1) {
-                    unsigned char *data = &buf[ic.hdr_size];
+                if (!ip_get_common(&ic, gt.buf.data, r) && ic.proto == 1) {
+                    unsigned char *data = &gt.buf.data[ic.hdr_size];
                     if (data[0] == 3) {
                         int mtu = (data[6] << 8) | data[7];
                         if (mtu) {
@@ -371,15 +428,15 @@ main(int argc, char **argv)
         if (FD_ISSET(tun_fd, &rfds)) {
             size_t size = 0;
 
-            while (sizeof(buf) - size > gt.mtu) {
-                const ssize_t r = tun_read(tun_fd, &buf[size],
-                                           sizeof(buf) - size);
-                if (r <= 0)
+            while (gt.buf.size - size >= gt.mtu) {
+                const int r = tun_read(tun_fd, &gt.buf.data[size], gt.buf.size - size);
+
+                if (r <= 0 || r > gt.mtu)
                     break;
 
                 struct ip_common ic;
 
-                if (ip_get_common(&ic, &buf[size], r) || ic.size != r)
+                if (ip_get_common(&ic, &gt.buf.data[size], r) || ic.size != r)
                     break;
 
                 size += r;
@@ -394,11 +451,9 @@ main(int argc, char **argv)
                 while (q < size) {
                     struct ip_common ic;
 
-                    if ((ip_get_common(&ic, &buf[q], size - q)) ||
-                        (ic.size > size - q)) {
-                        size = q;
+                    if ((ip_get_common(&ic, &gt.buf.data[q], size - q)) ||
+                        (ic.size > size - q))
                         break;
-                    }
 
                     if (q + ic.size > p + gt.mtu)
                         break;
@@ -409,19 +464,13 @@ main(int argc, char **argv)
                         tc = ic.tc & 0xFC;
                 }
 
-                int r = mud_send(mud, &buf[p], q - p, tc);
+                if (p >= q)
+                    break;
+
+                int r = mud_send(mud, &gt.buf.data[p], q - p, tc);
 
                 if (r == -1 && errno == EMSGSIZE) {
-                    int mtu = GT_MTU(mud_get_mtu(mud));
-
-                    if (mtu != (int)gt.mtu) {
-                        gt.mtu = mtu;
-
-                        gt_log("setup MTU to %i on interface %s\n", mtu, tun_name);
-
-                        if (tun_set_mtu(tun_name, mtu) == -1)
-                            perror("tun_set_mtu");
-                    }
+                    gt_setup_mtu(mud, tun_name);
                 } else {
                     if (r == -1 && errno != EAGAIN)
                         perror("mud_send");
@@ -432,31 +481,40 @@ main(int argc, char **argv)
         }
 
         if (FD_ISSET(mud_fd, &rfds)) {
-            while (1) {
-                const int size = mud_recv(mud, buf, sizeof(buf));
+            size_t size = 0;
 
-                if (size <= 0) {
-                    if (size == -1 && errno != EAGAIN)
+            while (gt.buf.size - size >= gt.mtu) {
+                const int r = mud_recv(mud, &gt.buf.data[size], gt.buf.size - size);
+
+                if (r <= 0) {
+                    if (r == -1 && errno != EAGAIN)
                         perror("mud_recv");
                     break;
                 }
 
-                int p = 0;
+                size += r;
+            }
 
-                while (p < size) {
-                    struct ip_common ic;
+            int p = 0;
 
-                    if ((ip_get_common(&ic, &buf[p], size - p)) ||
-                        (ic.size > size - p))
-                        break;
+            while (p < size) {
+                struct ip_common ic;
 
-                    tun_write(tun_fd, &buf[p], ic.size);
+                if ((ip_get_common(&ic, &gt.buf.data[p], size - p)) ||
+                    (ic.size > size - p))
+                    break;
 
-                    p += ic.size;
-                }
+                tun_write(tun_fd, &gt.buf.data[p], ic.size);
+
+                p += ic.size;
             }
         }
     }
 
+    if (gt.reload && tun_fd >= 0) {
+        if (tun_set_persist(tun_fd, 1) == -1)
+            perror("tun_set_persist");
+    }
+
     return 0;
 }

src/str.h

@@ -2,14 +2,15 @@
 
 #include "common.h"
 
-static inline size_t str_cpy (char *restrict dst, const char *restrict src, size_t len)
+static inline size_t
+str_cpy(char *restrict dst, const char *restrict src, size_t len)
 {
     if (!dst || !src)
         return 0;
 
     size_t i;
 
-    for (i=0; i<len && src[i]; i++)
+    for (i = 0; i < len && src[i]; i++)
         dst[i] = src[i];
 
     dst[i] = 0;
@@ -17,29 +18,29 @@ static inline size_t str_cpy (char *restrict dst, const char *restrict src, size
     return i;
 }
 
-_pure_
-static inline int str_empty (const char *restrict str)
+_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)
+_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])
+    while (sa[i] == sb[i])
         if (!sa[i++])
             return 0;
 
-    return i+1;
+    return i + 1;
 }
 
-_pure_
-static inline size_t str_len (const char *restrict str)
+_pure_ static inline size_t
+str_len(const char *restrict str)
 {
     if (!str)
         return 0;
@@ -47,11 +48,12 @@ static inline size_t str_len (const char *restrict str)
     return strlen(str);
 }
 
-static inline char *str_cat (const char **strs, size_t count)
+static inline char *
+str_cat(const char **strs, size_t count)
 {
     size_t size = 1;
 
-    for (size_t i=0; i<count; i++)
+    for (size_t i = 0; i < count; i++)
         size += str_len(strs[i]);
 
     char *str = malloc(size);
@@ -61,7 +63,7 @@ static inline char *str_cat (const char **strs, size_t count)
 
     char *p = str;
 
-    for (size_t i=0; i<count; i++) {
+    for (size_t i = 0; i < count; i++) {
         size_t len = str_len(strs[i]);
         memcpy(p, strs[i], len);
         p += len;

src/tun.c

@@ -17,6 +17,7 @@
 #define IFF_TUN 0x0001
 #define IFF_NO_PI 0x1000
 #define TUNSETIFF _IOW('T', 202, int)
+#define TUNSETPERSIST _IOW('T', 203, int)
 #endif
 
 #ifdef __APPLE__
@@ -45,7 +46,9 @@ tun_create_by_id(char *name, size_t size, unsigned id)
     str_cpy(ci.ctl_name, UTUN_CONTROL_NAME, sizeof(ci.ctl_name) - 1);
 
     if (ioctl(fd, CTLIOCGINFO, &ci)) {
+        int err = errno;
         close(fd);
+        errno = err;
         return -1;
     }
 
@@ -58,7 +61,9 @@ tun_create_by_id(char *name, size_t size, unsigned id)
     };
 
     if (connect(fd, (struct sockaddr *)&sc, sizeof(sc))) {
+        int err = errno;
         close(fd);
+        errno = err;
         return -1;
     }
 
@@ -72,8 +77,10 @@ tun_create_by_name(char *name, size_t size, char *dev_name)
 {
     unsigned id = 0;
 
-    if (sscanf(dev_name, "utun%u", &id) != 1)
+    if (sscanf(dev_name, "utun%u", &id) != 1) {
+        errno = EINVAL;
         return -1;
+    }
 
     return tun_create_by_id(name, size, id);
 }
@@ -152,11 +159,11 @@ tun_create(char *dev_name, char **ret_name)
     return fd;
 }
 
-ssize_t
+int
 tun_read(int fd, void *data, size_t size)
 {
     if (!size)
-        return -1;
+        return 0;
 
 #ifdef GT_BSD_TUN
     uint32_t family;
@@ -173,35 +180,24 @@ tun_read(int fd, void *data, size_t size)
     };
 
     ssize_t ret = readv(fd, iov, 2);
-#else
-    ssize_t ret = read(fd, data, size);
-#endif
 
-    if (ret == -1) {
-        if (errno == EAGAIN || errno == EINTR)
-            return -1;
+    if (ret <= (ssize_t)0)
+        return ret;
 
-        if (errno)
-            perror("tun read");
-
-        return 0;
-    }
-
-#ifdef GT_BSD_TUN
-    if (ret < (ssize_t)sizeof(family))
+    if (ret <= (ssize_t)sizeof(family))
         return 0;
 
     return ret - sizeof(family);
 #else
-    return ret;
+    return read(fd, data, size);
 #endif
 }
 
-ssize_t
+int
 tun_write(int fd, const void *data, size_t size)
 {
     if (!size)
-        return -1;
+        return 0;
 
 #ifdef GT_BSD_TUN
     uint32_t family;
@@ -214,6 +210,7 @@ tun_write(int fd, const void *data, size_t size)
         family = htonl(AF_INET6);
         break;
     default:
+        errno = EINVAL;
         return -1;
     }
 
@@ -229,49 +226,26 @@ tun_write(int fd, const void *data, size_t size)
     };
 
     ssize_t ret = writev(fd, iov, 2);
-#else
-    ssize_t ret = write(fd, data, size);
-#endif
 
-    if (ret == -1) {
-        if (errno == EAGAIN || errno == EINTR)
-            return -1;
+    if (ret <= (ssize_t)0)
+        return ret;
 
-        if (errno)
-            perror("tun write");
-
-        return 0;
-    }
-
-#ifdef GT_BSD_TUN
-    if (ret < (ssize_t)sizeof(family))
+    if (ret <= (ssize_t)sizeof(family))
         return 0;
 
     return ret - sizeof(family);
 #else
-    return ret;
+    return write(fd, data, size);
 #endif
 }
 
 int
-tun_set_mtu(char *dev_name, int mtu)
+tun_set_persist(int fd, int on)
 {
-    struct ifreq ifr = {
-        .ifr_mtu = mtu,
-    };
-
-    str_cpy(ifr.ifr_name, dev_name, IFNAMSIZ - 1);
-
-    int fd = socket(AF_INET, SOCK_DGRAM, 0);
-
-    if (fd == -1)
-        return -1;
-
-    int ret = ioctl(fd, SIOCSIFMTU, &ifr);
-
-    int err = errno;
-    close(fd);
-    errno = err;
-
-    return ret;
+#ifdef TUNSETPERSIST
+    return ioctl(fd, TUNSETPERSIST, on);
+#else
+    errno = ENOSYS;
+    return -1;
+#endif
 }

src/tun.h

@@ -1,8 +1,6 @@
 #pragma once
 
-#include <unistd.h>
-
-int     tun_create  (char *, char **);
-ssize_t tun_read    (int, void *, size_t);
-ssize_t tun_write   (int, const void *, size_t);
-int     tun_set_mtu (char *, int);
+int tun_create      (char *, char **);
+int tun_read        (int, void *, size_t);
+int tun_write       (int, const void *, size_t);
+int tun_set_persist (int, int);