Check for clock_gettime()

configure.ac

@@ -16,6 +16,8 @@ AC_PROG_CC_C99
 AC_USE_SYSTEM_EXTENSIONS
 AC_SEARCH_LIBS([getaddrinfo], [resolv nsl])
 AC_SEARCH_LIBS([socket], [socket])
+AC_CHECK_LIB([rt], [clock_gettime])
+AC_CHECK_FUNCS([clock_gettime])
 PKG_CHECK_MODULES([libsodium], [libsodium >= 1.0.4])
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT

src/main.c

@@ -14,6 +14,7 @@
 #include <signal.h>
 #include <poll.h>
 #include <fcntl.h>
+#include <time.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 
@@ -36,6 +37,10 @@
 
 #include <sodium.h>
 
+#ifdef __APPLE__
+#include <mach/mach_time.h>
+#endif
+
 #ifndef O_CLOEXEC
 #define O_CLOEXEC 0
 #endif
@@ -986,50 +991,78 @@ static int gt_track (uint8_t **db, struct ip_common *ic, uint8_t *data, int rev)
     return 0;
 }
 
+static unsigned long long gt_now (void)
+{
+#if defined __APPLE__
+    static mach_timebase_info_data_t mtid;
+    if (!mtid.denom) mach_timebase_info(&mtid);
+    return (mach_absolute_time()*mtid.numer/mtid.denom)/1000ULL;
+#elif defined CLOCK_MONOTONIC
+    struct timespec tv;
+    clock_gettime(CLOCK_MONOTONIC, &tv);
+    return tv.tv_sec*1000000ULL+tv.tv_nsec/1000ULL;
+#else
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec*1000000ULL+tv.tv_usec;
+#endif
+}
+
 static void gt_bench (int chacha)
 {
     unsigned char npub[crypto_aead_aes256gcm_NPUBBYTES];
     memset(npub, 0, sizeof(npub));
 
     unsigned char key[crypto_aead_aes256gcm_KEYBYTES];
-    memset(key,  1, sizeof(key));
+    memset(key, 1, sizeof(key));
 
     crypto_aead_aes256gcm_state ctx;
 
     if (!chacha)
         crypto_aead_aes256gcm_beforenm(&ctx, key);
 
-    int count = 2000000;
-    size_t size = 8;
-
     gt_print("bench: %s\n", chacha?"chacha20poly1305":"aes256gcm");
 
     _align_(16) unsigned char buf[32*1024+crypto_aead_aes256gcm_ABYTES];
 
-    for (size_t size=8; size<=sizeof(buf); size*=2) {
-        struct timeval tv1;
-        gettimeofday(&tv1, NULL);
+    size_t bs = 8;
 
-        for (int i=0; !gt.quit && i<count; i++) {
-            if (chacha) {
-                crypto_aead_chacha20poly1305_encrypt(buf, NULL,
-                        buf, size, NULL, 0, NULL, npub, key);
-            } else {
-                crypto_aead_aes256gcm_encrypt_afternm(buf, NULL,
-                        buf, size, NULL, 0, NULL, npub,
-                        (const crypto_aead_aes256gcm_state *)&ctx);
+    while (!gt.quit && bs<=sizeof(buf)) {
+        size_t total_size = 0;
+        unsigned long long total_dt = 0.0;
+        double mbps = 0.0;
+
+        while (!gt.quit) {
+            unsigned long long now = gt_now();
+
+            size_t size = 0;
+
+            while (!gt.quit && size<16*1024*1024) {
+                if (chacha) {
+                    crypto_aead_chacha20poly1305_encrypt(buf, NULL,
+                            buf, bs, NULL, 0, NULL, npub, key);
+                } else {
+                    crypto_aead_aes256gcm_encrypt_afternm(buf, NULL,
+                            buf, bs, NULL, 0, NULL, npub,
+                            (const crypto_aead_aes256gcm_state *)&ctx);
+                }
+                size += bs;
             }
+
+            total_dt += gt_now()-now;
+            total_size += size;
+
+            double last_mbps = mbps;
+            mbps = total_size*8.0/total_dt;
+
+            double diff = mbps-last_mbps;
+
+            if (-0.1<diff && diff<0.1)
+                break;
         }
 
-        if (gt.quit)
-            break;
-
-        struct timeval tv2;
-        gettimeofday(&tv2, NULL);
-
-        double dt = (tv2.tv_usec+tv2.tv_sec*1e6)-(tv1.tv_usec+tv1.tv_sec*1e6);
-
-        gt_print("block size: %-6zu bps: %.2f\n", size, size*count*8.0/dt);
+        gt_print("%6zu bytes %9.2f Mbps\n", bs, mbps);
+        bs *= 2;
     }
 }
 
@@ -1111,17 +1144,26 @@ static int gt_setup_crypto (struct crypto_ctx *ctx, int fd, int listener)
     if (fd_read_all(fd, data_r, size)!=size)
         return -1;
 
-    if (memcmp(&data_r[size-hash_size-sizeof(proto)], proto, 3))
+    if (memcmp(&data_r[size-hash_size-sizeof(proto)], proto, 3)) {
+        gt_log("bad packet [%02X%02X%02X] !\n",
+            &data_r[size-hash_size-sizeof(proto)+0],
+            &data_r[size-hash_size-sizeof(proto)+1],
+            &data_r[size-hash_size-sizeof(proto)+2]);
         return -2;
+    }
 
-    if (data_r[size-hash_size-sizeof(proto)+3])
+    if (data_r[size-hash_size-sizeof(proto)+3] && !ctx->chacha) {
+        gt_log("peer wants chacha20\n");
         ctx->chacha = 1;
+    }
 
     crypto_generichash(hash, hash_size,
             data_r, size-hash_size, ctx->skey, sizeof(ctx->skey));
 
-    if (sodium_memcmp(&data_r[size-hash_size], hash, hash_size))
+    if (sodium_memcmp(&data_r[size-hash_size], hash, hash_size)) {
+        gt_log("peer sends a bad hash!\n");
         return -2;
+    }
 
     if (listener && fd_write_all(fd, data_w, size)!=size)
         return -1;
@@ -1138,11 +1180,15 @@ static int gt_setup_crypto (struct crypto_ctx *ctx, int fd, int listener)
     crypto_generichash(hash, hash_size,
             data_w, size, ctx->skey, sizeof(ctx->skey));
 
-    if (sodium_memcmp(auth_r, hash, hash_size))
+    if (sodium_memcmp(auth_r, hash, hash_size)) {
+        gt_log("peer sends a bad hash (challenge-response)!\n");
         return -2;
+    }
 
-    if (crypto_scalarmult(shared, secret, data_r))
+    if (crypto_scalarmult(shared, secret, data_r)) {
+        gt_log("I'm just gonna hurt you really, really, BAD\n");
         return -2;
+    }
 
     crypto_generichash_init(&state, ctx->skey, sizeof(ctx->skey), sizeof(key_r));
     crypto_generichash_update(&state, shared, sizeof(shared));
@@ -1392,15 +1438,9 @@ int main (int argc, char **argv)
 
         ctx.chacha = chacha;
 
-        switch (gt_setup_crypto(&ctx, sock.fd, listener)) {
-        case -2:
-            gt_log("%s: key exchange could not be verified!\n", sockname);
-            goto restart;
-        case -1:
+        if (gt_setup_crypto(&ctx, sock.fd, listener)) {
             gt_log("%s: key exchange failed\n", sockname);
             goto restart;
-        default:
-            break;
         }
 
         retry = 0;