Version 0.0.7

Avoid pointer arithmetic on void *

Makefile.am

@@ -1,4 +1,13 @@
 bin_PROGRAMS = glorytun
-glorytun_SOURCES = src/common.h src/common-static.h src/main.c src/option.c src/option.h
 glorytun_CFLAGS = $(libsodium_CFLAGS)
 glorytun_LDADD = $(libsodium_LIBS)
+glorytun_SOURCES = \
+    src/common.h \
+    src/common-static.h \
+    src/common.c \
+    src/ip-static.h \
+    src/main.c \
+    src/option.c \
+    src/option.h \
+    src/tun.c \
+    src/tun.h

README.md

@@ -16,5 +16,5 @@ To build and install the latest version:
 
 To create and use a new secret key:
 
-    $ dd if=/dev/random iflag=fullblock of=glorytun.key bs=32 count=1
+    $ dd if=/dev/urandom of=glorytun.key bs=32 count=1
     # glorytun keyfile glorytun.key [...]

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ([2.65])
-AC_INIT([glorytun], [0.0.1], [https://github.com/angt/glorytun/issues],
+AC_INIT([glorytun], [0.0.7], [https://github.com/angt/glorytun/issues],
         [glorytun], [https://github.com/angt/glorytun])
 AC_CONFIG_SRCDIR([src/common.h])
 AC_CONFIG_AUX_DIR([build-aux])

src/common.c

@@ -0,0 +1,40 @@
+#include "common.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+int gt_print (const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    int ret = vfprintf(stdout, fmt, ap);
+    va_end(ap);
+
+    if (ret<0)
+        return 0;
+
+    return ret;
+}
+
+void gt_log (const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    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);
+}

src/common.h

@@ -14,6 +14,8 @@
 #define PALIGN(x)      ((void *)ALIGN((size_t)(x)))
 #define PALIGN_DOWN(x) ((void *)ALIGN_DOWN((size_t)(x)))
 
+#define _printf_(A,B)  __attribute__((format(printf,A,B)))
+#define _noreturn_     __attribute__((noreturn))
 #define _unused_       __attribute__((unused))
 
 typedef struct buffer buffer_t;
@@ -24,3 +26,8 @@ struct buffer {
     uint8_t *write;
     uint8_t *end;
 };
+
+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 *);

src/ip-static.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdint.h>
+
+static inline int ip_get_version (const uint8_t *data, size_t size)
+{
+    if (size<20)   // XXX
+        return -1; // XXX
+
+    return data[0]>>4;
+}
+
+static inline void ip_set_size (uint8_t *data, size_t size)
+{
+    data[2] = 0xFF&(size>>8);
+    data[3] = 0xFF&(size);
+}
+
+static inline ssize_t ip_get_size (const uint8_t *data, size_t size)
+{
+    switch (ip_get_version(data, size)) {
+    case 4:
+        return (data[2]<<8)|data[3];
+    case -1:
+        return -1;
+    }
+
+    return 0;
+}
+
+static inline int ip_get_dscp (const uint8_t *data, size_t size)
+{
+    switch (ip_get_version(data, size)) {
+    case 4:
+        return data[1]>>2;
+    }
+
+    return 0;
+}

src/option.c

@@ -5,18 +5,10 @@
 
 #include "option.h"
 
-int option_flag (void *data, _unused_ int argc, _unused_ char **argv)
-{
-    const int one = 1;
-    byte_cpy(data, &one, sizeof(one));
-
-    return 0;
-}
-
 int option_str (void *data, int argc, char **argv)
 {
     if (argc<2 || !argv[1]) {
-        printf("option `%s' need a string argument\n", argv[0]);
+        gt_print("option `%s' need a string argument\n", argv[0]);
         return -1;
     }
 
@@ -28,7 +20,7 @@ int option_str (void *data, int argc, char **argv)
 int option_long (void *data, int argc, char **argv)
 {
     if (argc<2 || !argv[1]) {
-        printf("option `%s' need an integer argument\n", argv[0]);
+        gt_print("option `%s' need an integer argument\n", argv[0]);
         return -1;
     }
 
@@ -37,7 +29,7 @@ int option_long (void *data, int argc, char **argv)
     long val = strtol(argv[1], &end, 0);
 
     if (errno || argv[1]==end) {
-        printf("argument `%s' is not a valid integer\n", argv[1]);
+        gt_print("argument `%s' is not a valid integer\n", argv[1]);
         return -1;
     }
 
@@ -46,8 +38,21 @@ int option_long (void *data, int argc, char **argv)
     return 1;
 }
 
+int option_is_set (struct option *opts, const char *name)
+{
+    for (int k=0; opts[k].name; k++) {
+        if (!str_cmp(opts[k].name, name))
+            return opts[k].set;
+    }
+
+    return 0;
+}
+
 int option_option (void *data, int argc, char **argv)
 {
+    if (!data)
+        return 0;
+
     struct option *opts = (struct option *)data;
 
     for (int k=0; opts[k].name; k++)
@@ -61,7 +66,7 @@ int option_option (void *data, int argc, char **argv)
                 continue;
 
             if (opts[k].set) {
-                printf("option `%s' is already set\n", opts[k].name);
+                gt_print("option `%s' is already set\n", opts[k].name);
                 return -1;
             }
 
@@ -84,31 +89,31 @@ int option_option (void *data, int argc, char **argv)
     return argc;
 }
 
-static void option_usage (struct option *opts, char *name)
+static int option_usage (struct option *opts, int slen)
 {
-    char *usage = "usage: ";
-    size_t slen = str_len(usage)+str_len(name);
-    size_t len = slen;
+    if (!opts)
+        return 0;
 
-    printf("%s%s", usage, name);
-
-    if (slen>40)
-        slen = 12;
+    int len = slen;
 
     for (int k=0; opts[k].name; k++) {
-        char *arg = (opts[k].call==option_flag)?"":" ARG";
-        size_t inc = str_len(opts[k].name)+str_len(arg)+3;
-
-        if (len+inc>72) {
-            printf("\n%*s", (int)slen, "");
+        if (len>slen+40) {
+            gt_print("\n%*s", (int)slen, "");
             len = slen;
         }
 
-        printf(" [%s%s]", opts[k].name, arg);
-        len += inc;
+        len += gt_print(" [%s", opts[k].name);
+
+        if (opts[k].call==option_option) {
+            len += option_usage((struct option *)opts[k].data, len);
+        } else {
+            len += gt_print(" ARG");
+        }
+
+        len += gt_print("]");
     }
 
-    printf("\n");
+    return len;
 }
 
 int option (struct option *opts, int argc, char **argv)
@@ -121,8 +126,18 @@ int option (struct option *opts, int argc, char **argv)
     if (ret<0 || ret+1>=argc)
         return 1;
 
-    printf("option `%s' is unknown\n", argv[ret+1]);
-    option_usage(opts, argv[0]);
+    gt_print("option `%s' is unknown\n", argv[ret+1]);
+
+    int slen = gt_print("usage: %s", argv[0]);
+
+    if (slen>40) {
+        slen = 12;
+        gt_print("\n%*s", (int)slen, "");
+    }
+
+    option_usage(opts, slen);
+
+    printf("\n");
 
     return 1;
 }

src/option.h

@@ -7,9 +7,9 @@ struct option {
     int set;
 };
 
-int option_flag   (void *, int, char **);
+int option_option (void *, int, char **);
 int option_str    (void *, int, char **);
 int option_long   (void *, int, char **);
-int option_option (void *, int, char **);
 
-int option (struct option *, int, char **);
+int option_is_set (struct option *, const char *);
+int option        (struct option *, int, char **);

src/tun.c

@@ -0,0 +1,209 @@
+#include "common-static.h"
+#include "ip-static.h"
+
+#include "tun.h"
+
+#include <stdio.h>
+#include <fcntl.h>
+
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+
+#ifdef __linux__
+# include <linux/if.h>
+# include <linux/if_tun.h>
+#endif
+
+#ifdef __APPLE__
+# include <sys/sys_domain.h>
+# include <sys/kern_control.h>
+# include <net/if_utun.h>
+#endif
+
+#if defined(__APPLE__) || defined(__OpenBSD__)
+# define GT_BSD_TUN 1
+#endif
+
+#ifdef __linux__
+int tun_create (char *name, int multiqueue)
+{
+    int fd = open("/dev/net/tun", O_RDWR);
+
+    if (fd<0) {
+        perror("open /dev/net/tun");
+        return -1;
+    }
+
+    struct ifreq ifr = {
+        .ifr_flags = IFF_TUN|IFF_NO_PI,
+    };
+
+    if (multiqueue) {
+#ifdef IFF_MULTI_QUEUE
+        ifr.ifr_flags |= IFF_MULTI_QUEUE;
+#else
+        gt_na("IFF_MULTI_QUEUE");
+#endif
+    }
+
+    str_cpy(ifr.ifr_name, name, IFNAMSIZ-1);
+
+    int ret = ioctl(fd, TUNSETIFF, &ifr);
+
+    if (ret<0) {
+        perror("ioctl TUNSETIFF");
+        return -1;
+    }
+
+    gt_log("tun name: %s\n", ifr.ifr_name);
+
+    return fd;
+}
+#elif defined(__APPLE__)
+int tun_create (_unused_ char *name, _unused_ int mq)
+{
+    for (unsigned dev_id = 0; dev_id < 32; dev_id++) {
+        struct ctl_info ci;
+
+        byte_set(&ci, 0, sizeof(ci));
+        str_cpy(ci.ctl_name, UTUN_CONTROL_NAME, sizeof(ci.ctl_name)-1);
+
+        int fd = socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
+
+        if (fd==-1)
+            return -1;
+
+        if (ioctl(fd, CTLIOCGINFO, &ci)==-1) {
+            close(fd);
+            continue;
+        }
+
+        struct sockaddr_ctl sc = {
+            .sc_id = ci.ctl_id,
+            .sc_len = sizeof(sc),
+            .sc_family = AF_SYSTEM,
+            .ss_sysaddr = AF_SYS_CONTROL,
+            .sc_unit = dev_id+1,
+        };
+
+        if (connect(fd, (struct sockaddr *)&sc, sizeof(sc))==-1) {
+            close(fd);
+            continue;
+        }
+
+        gt_log("tun name: /dev/utun%u\n", dev_id);
+
+        return fd;
+    }
+
+    return -1;
+}
+#else
+int tun_create (_unused_ char *name, _unused_ int mq)
+{
+    for (unsigned dev_id = 0; dev_id < 32; dev_id++) {
+        char dev_path[11];
+
+        snprintf(dev_path, sizeof(dev_path), "/dev/tun%u", dev_id);
+
+        int fd = open(dev_path, O_RDWR);
+
+        if (fd==-1)
+            continue;
+
+        gt_log("tun name: %s\n", dev_path);
+
+        return fd;
+    }
+
+    return -1;
+}
+#endif
+
+ssize_t tun_read (int fd, void *data, size_t size)
+{
+    if (!size)
+        return -2;
+
+#ifdef GT_BSD_TUN
+    uint32_t family;
+
+    struct iovec iov[2] = {
+        { .iov_base = &family, .iov_len = sizeof(family) },
+        { .iov_base = data, .iov_len = 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 (errno)
+            perror("tun read");
+
+        return 0;
+    }
+
+#ifdef GT_BSD_TUN
+    if (ret<(ssize_t) sizeof(family))
+        return 0;
+
+    return ret-sizeof(family);
+#else
+    return ret;
+#endif
+}
+
+ssize_t tun_write (int fd, const void *data, size_t size)
+{
+    if (!size)
+        return -2;
+
+#ifdef GT_BSD_TUN
+    uint32_t family;
+
+    switch (ip_get_version(data, size)) {
+    case 4:
+        family = htonl(AF_INET);
+        break;
+    case 6:
+        family = htonl(AF_INET6);
+        break;
+    default:
+        return -1;
+    }
+
+    struct iovec iov[2] = {
+        { .iov_base = &family, .iov_len = sizeof(family) },
+        { .iov_base = (void *) data, .iov_len = 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 (errno)
+            perror("tun write");
+
+        return 0;
+    }
+
+#ifdef GT_BSD_TUN
+    if (ret<(ssize_t) sizeof(family))
+        return 0;
+
+    return ret-sizeof(family);
+#else
+    return ret;
+#endif
+}

src/tun.h

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