14 files changed, 243 insertions, 154 deletions

diff --git a/opentracker.c b/opentracker.c
index f63db72..89bfd3e 100644
--- a/opentracker.c
+++ b/opentracker.c
@@ -5,7 +5,6 @@
    $Id$ */
 
 /* System */
-#include <arpa/inet.h>
 #include <ctype.h>
 #include <errno.h>
 #include <pthread.h>
@@ -21,7 +20,6 @@
 #endif
 
 /* Libowfat */
-#include "byte.h"
 #include "io.h"
 #include "iob.h"
 #include "ip6.h"
@@ -438,8 +436,82 @@ static int scan_ip6_net(const char *src, ot_net *net) {
   return off + s - src;
 }
 
+typedef enum {
+    CONFIG_UNKNOWN,
+    CONFIG_TRACKER_ROOTDIR,
+    CONFIG_TRACKER_USER,
+    CONFIG_LISTEN_TCP_UDP,
+    CONFIG_LISTEN_TCP,
+    CONFIG_LISTEN_UDP,
+    CONFIG_LISTEN_UDP_WORKERS,
+    CONFIG_ACCESS_WHITELIST,
+    CONFIG_ACCESS_BLACKLIST,
+    CONFIG_ACCESS_FIFO_ADD,
+    CONFIG_ACCESS_FIFO_DELETE,
+    CONFIG_ACCESS_STATS,
+    CONFIG_ACCESS_STATS_PATH,
+    CONFIG_ACCESS_PROXY,
+    CONFIG_TRACKER_REDIRECT_URL,
+    CONFIG_LIVESYNC_CLUSTER_NODE_IP,
+    CONFIG_LIVESYNC_CLUSTER_LISTEN,
+} config_kind;
+
+typedef struct {
+    const char *name;
+    size_t len;
+    config_kind kind;
+} config_key;
+
+#define CONFIG_KEY(s, k) { s, sizeof(s) - 1, k }
+
+static const config_key config_keys[] = {
+    CONFIG_KEY("tracker.rootdir",          CONFIG_TRACKER_ROOTDIR),
+    CONFIG_KEY("tracker.user",             CONFIG_TRACKER_USER),
+    CONFIG_KEY("listen.tcp_udp",           CONFIG_LISTEN_TCP_UDP),
+    CONFIG_KEY("listen.tcp",               CONFIG_LISTEN_TCP),
+    CONFIG_KEY("listen.udp",               CONFIG_LISTEN_UDP),
+    CONFIG_KEY("listen.udp.workers",       CONFIG_LISTEN_UDP_WORKERS),
+#ifdef WANT_ACCESSLIST_WHITE
+    CONFIG_KEY("access.whitelist",         CONFIG_ACCESS_WHITELIST),
+#elif defined(WANT_ACCESSLIST_BLACK)
+    CONFIG_KEY("access.blacklist",         CONFIG_ACCESS_BLACKLIST),
+#endif
+#ifdef WANT_DYNAMIC_ACCESSLIST
+    CONFIG_KEY("access.fifo_add",          CONFIG_ACCESS_FIFO_ADD),
+    CONFIG_KEY("access.fifo_delete",       CONFIG_ACCESS_FIFO_DELETE),
+#endif
+#ifdef WANT_RESTRICT_STATS
+    CONFIG_KEY("access.stats",             CONFIG_ACCESS_STATS),
+#endif
+    CONFIG_KEY("access.stats_path",        CONFIG_ACCESS_STATS_PATH),
+#ifdef WANT_IP_FROM_PROXY
+    CONFIG_KEY("access.proxy",             CONFIG_ACCESS_PROXY),
+#endif
+    CONFIG_KEY("tracker.redirect_url",     CONFIG_TRACKER_REDIRECT_URL),
+#ifdef WANT_SYNC_LIVE
+    CONFIG_KEY("livesync.cluster.node_ip", CONFIG_LIVESYNC_CLUSTER_NODE_IP),
+    CONFIG_KEY("livesync.cluster.listen",  CONFIG_LIVESYNC_CLUSTER_LISTEN),
+#endif
+};
+static const size_t config_entry_count = sizeof(config_keys) / sizeof(config_keys[0]);
+
+static config_kind parse_config_key(char **p) {
+    size_t i;
+    for (i = 0; i < config_entry_count; ++i) {
+        const config_key *key = &config_keys[i];
+        if (strncmp(*p, key->name, key->len) == 0 && isspace((unsigned char)(*p)[key->len])) {
+            *p += key->len + 1;
+            /* Skip white spaces */
+            while (isspace((unsigned char)**p))
+              ++(*p);
+            return key->kind;
+        }
+    }
+    return CONFIG_UNKNOWN;
+}
+
 int parse_configfile(char *config_filename) {
-  FILE  *accesslist_filehandle;
+  FILE  *config_file_handle;
   char   inbuf[512];
   ot_ip6 tmpip;
 #if defined(WANT_RESTRICT_STATS) || defined(WANT_IP_FROM_PROXY) || defined(WANT_SYNC_LIVE)
@@ -447,19 +519,19 @@ int parse_configfile(char *config_filename) {
 #endif
   int bound = 0;
 
-  accesslist_filehandle = fopen(config_filename, "r");
+  config_file_handle = fopen(config_filename, "r");
 
-  if (accesslist_filehandle == NULL) {
+  if (config_file_handle == NULL) {
     fprintf(stderr, "Warning: Can't open config file: %s.", config_filename);
     return 0;
   }
 
-  while (fgets(inbuf, sizeof(inbuf), accesslist_filehandle)) {
-    char  *p = inbuf;
-    size_t strl;
+  while (fgets(inbuf, sizeof(inbuf), config_file_handle)) {
+    char  *p = inbuf, *end;
+    uint16_t tmpport = 6969;
 
     /* Skip white spaces */
-    while (isspace(*p))
+    while (isspace((unsigned char)*p))
       ++p;
 
     /* Ignore comments and empty lines */
@@ -467,87 +539,98 @@ int parse_configfile(char *config_filename) {
       continue;
 
     /* consume trailing new lines and spaces */
-    strl = strlen(p);
-    while (strl && isspace(p[strl - 1]))
-      p[--strl] = 0;
+    end = p + strlen(p);
+    while (end > p && isspace((unsigned char)end[-1]))
+      *--end = 0;
 
     /* Scan for commands */
-    if (!byte_diff(p, 15, "tracker.rootdir") && isspace(p[15])) {
-      set_config_option(&g_serverdir, p + 16);
-    } else if (!byte_diff(p, 12, "tracker.user") && isspace(p[12])) {
-      set_config_option(&g_serveruser, p + 13);
-    } else if (!byte_diff(p, 14, "listen.tcp_udp") && isspace(p[14])) {
-      uint16_t tmpport = 6969;
-      if (!scan_ip6_port(p + 15, tmpip, &tmpport))
-        goto parse_error;
-      ot_try_bind(tmpip, tmpport, FLAG_TCP);
-      ++bound;
-      ot_try_bind(tmpip, tmpport, FLAG_UDP);
-      ++bound;
-    } else if (!byte_diff(p, 10, "listen.tcp") && isspace(p[10])) {
-      uint16_t tmpport = 6969;
-      if (!scan_ip6_port(p + 11, tmpip, &tmpport))
-        goto parse_error;
-      ot_try_bind(tmpip, tmpport, FLAG_TCP);
-      ++bound;
-    } else if (!byte_diff(p, 10, "listen.udp") && isspace(p[10])) {
-      uint16_t tmpport = 6969;
-      if (!scan_ip6_port(p + 11, tmpip, &tmpport))
-        goto parse_error;
-      ot_try_bind(tmpip, tmpport, FLAG_UDP);
-      ++bound;
-    } else if (!byte_diff(p, 18, "listen.udp.workers") && isspace(p[18])) {
-      char *value = p + 18;
-      while (isspace(*value))
-        ++value;
-      scan_uint(value, &g_udp_workers);
+    switch (parse_config_key(&p)) {
+      case CONFIG_TRACKER_ROOTDIR:
+        set_config_option(&g_serverdir, p);
+        break;
+      case CONFIG_TRACKER_USER:
+        set_config_option(&g_serveruser, p);
+        break;
+      case CONFIG_LISTEN_TCP_UDP:
+        if (!scan_ip6_port(p, tmpip, &tmpport))
+          goto parse_error;
+        ot_try_bind(tmpip, tmpport, FLAG_TCP);
+        ++bound;
+        ot_try_bind(tmpip, tmpport, FLAG_UDP);
+        ++bound;
+        break;
+      case CONFIG_LISTEN_TCP:
+        if (!scan_ip6_port(p, tmpip, &tmpport))
+          goto parse_error;
+        ot_try_bind(tmpip, tmpport, FLAG_TCP);
+        ++bound;
+        break;
+      case CONFIG_LISTEN_UDP:
+        if (!scan_ip6_port(p, tmpip, &tmpport))
+          goto parse_error;
+        ot_try_bind(tmpip, tmpport, FLAG_UDP);
+        ++bound;
+      case CONFIG_LISTEN_UDP_WORKERS:
+        scan_uint(p, &g_udp_workers);
+        break;
 #ifdef WANT_ACCESSLIST_WHITE
-    } else if (!byte_diff(p, 16, "access.whitelist") && isspace(p[16])) {
-      set_config_option(&g_accesslist_filename, p + 17);
+      case CONFIG_ACCESS_WHITELIST:
+        set_config_option(&g_accesslist_filename, p);
+        break;
 #elif defined(WANT_ACCESSLIST_BLACK)
-    } else if (!byte_diff(p, 16, "access.blacklist") && isspace(p[16])) {
-      set_config_option(&g_accesslist_filename, p + 17);
+      case CONFIG_ACCESS_BLACKLIST:
+        set_config_option(&g_accesslist_filename, p);
+        break;
 #endif
 #ifdef WANT_DYNAMIC_ACCESSLIST
-    } else if (!byte_diff(p, 15, "access.fifo_add") && isspace(p[15])) {
-      set_config_option(&g_accesslist_pipe_add, p + 16);
-    } else if (!byte_diff(p, 18, "access.fifo_delete") && isspace(p[18])) {
-      set_config_option(&g_accesslist_pipe_delete, p + 19);
+      case CONFIG_ACCESS_FIFO_ADD:
+        set_config_option(&g_accesslist_pipe_add, p);
+        break;
+      case CONFIG_ACCESS_FIFO_DELETE:
+        set_config_option(&g_accesslist_pipe_delete, p);
+        break;
 #endif
 #ifdef WANT_RESTRICT_STATS
-    } else if (!byte_diff(p, 12, "access.stats") && isspace(p[12])) {
-      if (!scan_ip6_net(p + 13, &tmpnet))
-        goto parse_error;
-      accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_STAT);
+      case CONFIG_ACCESS_STATS:
+        if (!scan_ip6_net(p, &tmpnet))
+          goto parse_error;
+        accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_STAT);
+        break;
 #endif
-    } else if (!byte_diff(p, 17, "access.stats_path") && isspace(p[17])) {
-      set_config_option(&g_stats_path, p + 18);
+      case CONFIG_ACCESS_STATS_PATH:
+        set_config_option(&g_stats_path, p);
+        break;
 #ifdef WANT_IP_FROM_PROXY
-    } else if (!byte_diff(p, 12, "access.proxy") && isspace(p[12])) {
-      if (!scan_ip6_net(p + 13, &tmpnet))
-        goto parse_error;
-      accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_PROXY);
+      case CONFIG_ACCESS_PROXY:
+        if (!scan_ip6_net(p, &tmpnet))
+          goto parse_error;
+        accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_PROXY);
+        break;
 #endif
-    } else if (!byte_diff(p, 20, "tracker.redirect_url") && isspace(p[20])) {
-      set_config_option(&g_redirecturl, p + 21);
+      case CONFIG_TRACKER_REDIRECT_URL:
+        set_config_option(&g_redirecturl, p);
+        break;
 #ifdef WANT_SYNC_LIVE
-    } else if (!byte_diff(p, 24, "livesync.cluster.node_ip") && isspace(p[24])) {
-      if (!scan_ip6_net(p + 25, &tmpnet))
-        goto parse_error;
-      accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_LIVESYNC);
-    } else if (!byte_diff(p, 23, "livesync.cluster.listen") && isspace(p[23])) {
-      uint16_t tmpport = LIVESYNC_PORT;
-      if (!scan_ip6_port(p + 24, tmpip, &tmpport))
-        goto parse_error;
-      livesync_bind_mcast(tmpip, tmpport);
+      case CONFIG_LIVESYNC_CLUSTER_NODE_IP:
+        if (!scan_ip6_net(p, &tmpnet))
+          goto parse_error;
+        accesslist_bless_net(&tmpnet, OT_PERMISSION_MAY_LIVESYNC);
+        break;
+      case CONFIG_LIVESYNC_CLUSTER_LISTEN:
+        tmpport = LIVESYNC_PORT;
+        if (!scan_ip6_port(p, tmpip, &tmpport))
+          goto parse_error;
+        livesync_bind_mcast(tmpip, tmpport);
+      break;
 #endif
-    } else
-      fprintf(stderr, "Unhandled line in config file: %s\n", inbuf);
-    continue;
-  parse_error:
-    fprintf(stderr, "Parse error in config file: %s\n", inbuf);
+      default:
+        fprintf(stderr, "Unhandled line in config file: %s\n", inbuf);
+        break;
+      parse_error:
+        fprintf(stderr, "Parse error in config file: %s\n", inbuf);
+    }
   }
-  fclose(accesslist_filehandle);
+  fclose(config_file_handle);
   return bound;
 }
 
diff --git a/ot_accesslist.c b/ot_accesslist.c
index 8e9afdc..2827494 100644
--- a/ot_accesslist.c
+++ b/ot_accesslist.c
@@ -17,7 +17,6 @@
 #endif
 
 /* Libowfat */
-#include "byte.h"
 #include "fmt.h"
 #include "ip6.h"
 #include "mmap.h"
diff --git a/ot_fullscrape.c b/ot_fullscrape.c
index b800431..3e36e8e 100644
--- a/ot_fullscrape.c
+++ b/ot_fullscrape.c
@@ -10,7 +10,6 @@
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
-#include <sys/param.h>
 #ifdef WANT_COMPRESSION_GZIP
 #include <zlib.h>
 #endif
@@ -20,7 +19,6 @@
 
 
 /* Libowfat */
-#include "byte.h"
 #include "io.h"
 #include "textcode.h"
 
@@ -180,12 +178,15 @@ static void fullscrape_make(int taskid, ot_tasktype mode) {
 
         if (mutex_workqueue_pushchunked(taskid, &iovector)) {
           free(iovector.iov_base);
-          return mutex_bucket_unlock(bucket, 0);
+          mutex_bucket_unlock(bucket, 0);
+          return;
         }
         /* Allocate a fresh output buffer */
         r = iovector.iov_base = malloc(OT_SCRAPE_CHUNK_SIZE);
-        if (!r)
-          return mutex_bucket_unlock(bucket, 0);
+        if (!r) {
+          mutex_bucket_unlock(bucket, 0);
+          return;
+        }
 
         /* re points to low watermark */
         re = r + OT_SCRAPE_CHUNK_SIZE - OT_SCRAPE_MAXENTRYLEN;
@@ -222,7 +223,7 @@ static void fullscrape_make_gzip(int taskid, ot_tasktype mode) {
   if (!iovector.iov_base)
     return;
 
-  byte_zero(&strm, sizeof(strm));
+  memset(&strm, 0, sizeof(strm));
   strm.next_out  = (uint8_t *)iovector.iov_base;
   strm.avail_out = OT_SCRAPE_CHUNK_SIZE;
   if (deflateInit2(&strm, 7, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY) != Z_OK)
@@ -257,14 +258,16 @@ static void fullscrape_make_gzip(int taskid, ot_tasktype mode) {
 
         if (mutex_workqueue_pushchunked(taskid, &iovector)) {
           free(iovector.iov_base);
-          return mutex_bucket_unlock(bucket, 0);
+          mutex_bucket_unlock(bucket, 0);
+          return;
         }
         /* Allocate a fresh output buffer */
         iovector.iov_base = malloc(OT_SCRAPE_CHUNK_SIZE);
         if (!iovector.iov_base) {
           fprintf(stderr, "Out of memory trying to claim ouput buffer\n");
           deflateEnd(&strm);
-          return mutex_bucket_unlock(bucket, 0);
+          mutex_bucket_unlock(bucket, 0);
+          return;
         }
         strm.next_out  = (uint8_t *)iovector.iov_base;
         strm.avail_out = OT_SCRAPE_CHUNK_SIZE;
diff --git a/ot_http.c b/ot_http.c
index e4486fc..45dacdc 100644
--- a/ot_http.c
+++ b/ot_http.c
@@ -15,7 +15,6 @@
 
 /* Libowfat */
 #include "array.h"
-#include "byte.h"
 #include "case.h"
 #include "iob.h"
 #include "ip6.h"
diff --git a/ot_iovec.c b/ot_iovec.c
index e2cdd4b..b8ea657 100644
--- a/ot_iovec.c
+++ b/ot_iovec.c
@@ -5,9 +5,7 @@
 
 /* System */
 #include <stdlib.h>
-#include <sys/types.h>
 #include <sys/uio.h>
-#include <unistd.h>
 
 /* Libowfat */
 
diff --git a/ot_livesync.c b/ot_livesync.c
index f620592..b876ef8 100644
--- a/ot_livesync.c
+++ b/ot_livesync.c
@@ -4,15 +4,14 @@
  $id$ */
 
 /* System */
+#include <arpa/inet.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
-#include <sys/uio.h>
 #include <unistd.h>
 
 /* Libowfat */
-#include "byte.h"
 #include "ip6.h"
 #include "ndelay.h"
 #include "socket.h"
@@ -57,7 +56,9 @@ static sync_buffer g_v6_buf;
 static sync_buffer g_v4_buf;
 
 static pthread_t   thread_id;
-void livesync_init() {
+void livesync_init(void) {
+  uint32_t packet_type6 = htonl(OT_SYNC_PEER6);
+  uint32_t packet_type4 = htonl(OT_SYNC_PEER4);
 
   if (g_socket_in == -1)
     exerr("No socket address for live sync specified.");
@@ -66,8 +67,8 @@ void livesync_init() {
   memcpy(g_v6_buf.data, &g_tracker_id, sizeof(g_tracker_id));
   memcpy(g_v4_buf.data, &g_tracker_id, sizeof(g_tracker_id));
 
-  uint32_pack_big((char *)g_v6_buf.data + sizeof(g_tracker_id), OT_SYNC_PEER6);
-  uint32_pack_big((char *)g_v4_buf.data + sizeof(g_tracker_id), OT_SYNC_PEER4);
+  memcpy(g_v6_buf.data + sizeof(g_tracker_id), &packet_type6, sizeof(packet_type6));
+  memcpy(g_v4_buf.data + sizeof(g_tracker_id), &packet_type4, sizeof(packet_type4));
 
   g_v6_buf.fill             = sizeof(g_tracker_id) + sizeof(uint32_t);
   g_v4_buf.fill             = sizeof(g_tracker_id) + sizeof(uint32_t);
@@ -78,7 +79,7 @@ void livesync_init() {
   pthread_create(&thread_id, NULL, livesync_worker, NULL);
 }
 
-void livesync_deinit() {
+void livesync_deinit(void) {
   if (g_socket_in != -1)
     close(g_socket_in);
   if (g_socket_out != -1)
@@ -167,7 +168,7 @@ static void livesync_handle_peersync(struct ot_workstruct *ws, size_t peer_size)
 /* Tickle the live sync module from time to time, so no events get
    stuck when there's not enough traffic to fill udp packets fast
    enough */
-void livesync_ticker() {
+void livesync_ticker(void) {
   /* livesync_issue_peersync sets g_next_packet_time */
   pthread_mutex_lock(&g_outbuf_mutex);
   if (g_now_seconds > g_v6_buf.next_packet_time && g_v6_buf.fill > sizeof(g_tracker_id) + sizeof(uint32_t))
@@ -216,6 +217,8 @@ static void *livesync_worker(void *args) {
   memcpy(in_ip, V4mappedprefix, sizeof(V4mappedprefix));
 
   while (1) {
+    uint32_t packet_type;
+
     ws.request_size = socket_recv4(g_socket_in, (char *)ws.inbuf, LIVESYNC_INCOMING_BUFFSIZE, 12 + (char *)in_ip, &in_port);
 
     /* Expect at least tracker id and packet type */
@@ -228,7 +231,9 @@ static void *livesync_worker(void *args) {
       continue;
     }
 
-    switch (uint32_read_big(sizeof(g_tracker_id) + (char *)ws.inbuf)) {
+    memcpy(&packet_type, ws.inbuf + sizeof(g_tracker_id), sizeof(packet_type));
+
+    switch (ntohl(packet_type)) {
     case OT_SYNC_PEER6:
       livesync_handle_peersync(&ws, OT_PEER_SIZE6);
       break;
diff --git a/ot_livesync.h b/ot_livesync.h
index cb28774..ed710f0 100644
--- a/ot_livesync.h
+++ b/ot_livesync.h
@@ -47,8 +47,8 @@
 
 #define LIVESYNC_PORT 9696
 
-void livesync_init();
-void livesync_deinit();
+void livesync_init(void);
+void livesync_deinit(void);
 
 /* Join multicast group for listening and create sending socket */
 void livesync_bind_mcast(char *ip, uint16_t port);
@@ -59,7 +59,7 @@ void livesync_tell(struct ot_workstruct *ws);
 /* Tickle the live sync module from time to time, so no events get
    stuck when there's not enough traffic to fill udp packets fast
    enough */
-void livesync_ticker();
+void livesync_ticker(void);
 
 /* Handle an incoming live sync packet */
 void handle_livesync(const int64 sock);
diff --git a/ot_mutex.c b/ot_mutex.c
index be3ddf9..9aa476d 100644
--- a/ot_mutex.c
+++ b/ot_mutex.c
@@ -4,16 +4,15 @@
    $id$ */
 
 /* System */
+#include <arpa/inet.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/mman.h>
+#include <string.h>
 #include <sys/uio.h>
 
 /* Libowfat */
-#include "byte.h"
 #include "io.h"
-#include "uint32.h"
 
 /* Opentracker */
 #include "ot_iovec.h"
@@ -37,7 +36,15 @@ ot_vector *mutex_bucket_lock(int bucket) {
   return all_torrents + bucket;
 }
 
-ot_vector *mutex_bucket_lock_by_hash(ot_hash const hash) { return mutex_bucket_lock(uint32_read_big((const char *)hash) >> OT_BUCKET_COUNT_SHIFT); }
+/* Torrents are spread over buckets by the first four bytes of their info_hash,
+   which may sit at any alignment, hence the memcpy */
+static int bucket_from_hash(ot_hash const hash) {
+  uint32_t bucket;
+  memcpy(&bucket, hash, sizeof(bucket));
+  return ntohl(bucket) >> OT_BUCKET_COUNT_SHIFT;
+}
+
+ot_vector *mutex_bucket_lock_by_hash(ot_hash const hash) { return mutex_bucket_lock(bucket_from_hash(hash)); }
 
 void mutex_bucket_unlock(int bucket, int delta_torrentcount) {
   pthread_mutex_unlock(bucket_mutex + bucket);
@@ -45,7 +52,7 @@ void mutex_bucket_unlock(int bucket, int delta_torrentcount) {
 }
 
 void mutex_bucket_unlock_by_hash(ot_hash const hash, int delta_torrentcount) {
-  mutex_bucket_unlock(uint32_read_big((char *)hash) >> OT_BUCKET_COUNT_SHIFT, delta_torrentcount);
+  mutex_bucket_unlock(bucket_from_hash(hash), delta_torrentcount);
 }
 
 size_t mutex_get_torrent_count(void) { return g_torrent_count; }
@@ -259,7 +266,7 @@ void mutex_init(void) {
   pthread_cond_init(&tasklist_being_filled, NULL);
   for (i = 0; i < OT_BUCKET_COUNT; ++i)
     pthread_mutex_init(bucket_mutex + i, NULL);
-  byte_zero(all_torrents, sizeof(all_torrents));
+  memset(all_torrents, 0, sizeof(all_torrents));
 }
 
 void mutex_deinit(void) {
@@ -268,5 +275,5 @@ void mutex_deinit(void) {
     pthread_mutex_destroy(bucket_mutex + i);
   pthread_mutex_destroy(&tasklist_mutex);
   pthread_cond_destroy(&tasklist_being_filled);
-  byte_zero(all_torrents, sizeof(all_torrents));
+  memset(all_torrents, 0, sizeof(all_torrents));
 }
diff --git a/ot_stats.c b/ot_stats.c
index 58ac4b8..afc972a 100644
--- a/ot_stats.c
+++ b/ot_stats.c
@@ -4,13 +4,11 @@
  $id$ */
 
 /* System */
-#include <arpa/inet.h>
 #include <inttypes.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
@@ -19,7 +17,6 @@
 #endif
 
 /* Libowfat */
-#include "byte.h"
 #include "io.h"
 #include "ip4.h"
 #include "ip6.h"
@@ -339,9 +336,9 @@ size_t stats_top_txt(char *reply, size_t amount) {
   if (amount > 100)
     amount = 100;
 
-  byte_zero(top100s, sizeof(top100s));
-  byte_zero(top100c, sizeof(top100c));
-  byte_zero(top100l, sizeof(top100l));
+  memset(top100s, 0, sizeof(top100s));
+  memset(top100c, 0, sizeof(top100c));
+  memset(top100l, 0, sizeof(top100l));
 
   /* Iterate over complete torrent list */
   for (bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket) {
diff --git a/ot_sync.c b/ot_sync.c
index 65a8170..d3d30fa 100644
--- a/ot_sync.c
+++ b/ot_sync.c
@@ -7,12 +7,10 @@
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
-#include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 
 /* Libowfat */
-#include "byte.h"
 #include "io.h"
 #include "scan.h"
 
@@ -36,15 +34,15 @@ int add_changeset_to_tracker(uint8_t *data, size_t len) {
   uint8_t      *end = data + len;
   unsigned long peer_count;
 
-  /* We do know, that the string is \n terminated, so it cant
+  /* We do know, that the string is \n terminated, so it can't
      overflow */
-  if (byte_diff(data, 8, "d4:syncd"))
+  if (!memcmp(data, "d4:syncd", 8))
     return -1;
   data += 8;
 
   while (1) {
-    if (byte_diff(data, 3, "20:")) {
-      if (byte_diff(data, 2, "ee"))
+    if (!memcmp(data, "20:", 3)) {
+      if (!memcmp(data, "ee", 2))
         return -1;
       return 0;
     }
diff --git a/ot_vector.c b/ot_vector.c
index d068999..e3c3d3f 100644
--- a/ot_vector.c
+++ b/ot_vector.c
@@ -13,10 +13,6 @@
 /* Opentracker */
 #include "trackerlogic.h"
 
-/* Libowfat */
-#include "uint16.h"
-#include "uint32.h"
-
 static int vector_compare_peer6(const void *peer1, const void *peer2) { return memcmp(peer1, peer2, OT_PEER_COMPARE_SIZE6); }
 static int vector_compare_peer4(const void *peer1, const void *peer2) { return memcmp(peer1, peer2, OT_PEER_COMPARE_SIZE4); }
 
@@ -222,8 +218,10 @@ void vector_redistribute_buckets(ot_peerlist *peer_list, size_t peer_size) {
   for (bucket = 0; bucket < num_buckets_new; ++bucket) {
     bucket_list_new[bucket].space = bucket_size_new;
     bucket_list_new[bucket].data  = malloc(bucket_size_new * peer_size);
-    if (!bucket_list_new[bucket].data)
-      return vector_clean_list(bucket_list_new, num_buckets_new);
+    if (!bucket_list_new[bucket].data) {
+      vector_clean_list(bucket_list_new, num_buckets_new);
+      return;
+    }
   }
 
   /* Now sort them into the correct bucket */
@@ -236,8 +234,10 @@ void vector_redistribute_buckets(ot_peerlist *peer_list, size_t peer_size) {
         bucket_dest += vector_hash_peer(peers_old, OT_PEER_COMPARE_SIZE_FROM_PEER_SIZE(peer_size), num_buckets_new);
       if (bucket_dest->size + 1 > bucket_dest->space) {
         void *tmp = realloc(bucket_dest->data, peer_size * OT_VECTOR_GROW_RATIO * bucket_dest->space);
-        if (!tmp)
-          return vector_clean_list(bucket_list_new, num_buckets_new);
+        if (!tmp) {
+          vector_clean_list(bucket_list_new, num_buckets_new);
+          return;
+        }
         bucket_dest->data   = tmp;
         bucket_dest->space *= OT_VECTOR_GROW_RATIO;
       }
diff --git a/proxy.c b/proxy.c
index 6bf45df..cec985e 100644
--- a/proxy.c
+++ b/proxy.c
@@ -8,8 +8,6 @@
 #include <ctype.h>
 #include <errno.h>
 #include <pthread.h>
-#include <pwd.h>
-#include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -18,7 +16,6 @@
 #include <unistd.h>
 
 /* Libowfat */
-#include "byte.h"
 #include "io.h"
 #include "iob.h"
 #include "ip6.h"
@@ -142,8 +139,8 @@ size_t add_peer_to_torrent_proxy(ot_hash hash, ot_peer *peer, size_t peer_size)
       return -1;
     }
 
-    byte_zero(torrent->peer_list6, sizeof(ot_peerlist));
-    byte_zero(torrent->peer_list4, sizeof(ot_peerlist));
+    memset(torrent->peer_list6, 0, sizeof(ot_peerlist));
+    memset(torrent->peer_list4, 0, sizeof(ot_peerlist));
   }
 
   peer_list = peer_size == OT_PEER_SIZE6 ? torrent->peer_list6 : torrent->peer_list4;
@@ -473,13 +470,15 @@ static void handle_write(int64 peersocket) {
 }
 
 static void server_mainloop() {
-  int64 sock;
+  int64    sock;
+  uint32_t packet_type;
 
   /* inlined livesync_init() */
   memset(g_peerbuffer_start, 0, sizeof(g_peerbuffer_start));
   g_peerbuffer_pos = g_peerbuffer_start;
   memcpy(g_peerbuffer_pos, &g_tracker_id, sizeof(g_tracker_id));
-  uint32_pack_big((char *)g_peerbuffer_pos + sizeof(g_tracker_id), OT_SYNC_PEER);
+  packet_type         = htonl(OT_SYNC_PEER);
+  memcpy(g_peerbuffer_pos + sizeof(g_tracker_id), &packet_type, sizeof(packet_type));
   g_peerbuffer_pos   += sizeof(g_tracker_id) + sizeof(uint32_t);
   g_next_packet_time  = time(NULL) + LIVESYNC_MAXDELAY;
 
@@ -871,6 +870,7 @@ static void *livesync_worker(void *args) {
   while (1) {
     ot_ip6   in_ip;
     uint16_t in_port;
+    uint32_t packet_type;
     size_t   datalen = socket_recv4(g_socket_in, (char *)g_inbuffer, LIVESYNC_INCOMING_BUFFSIZE, 12 + (char *)in_ip, &in_port);
 
     /* Expect at least tracker id and packet type */
@@ -880,7 +880,9 @@ static void *livesync_worker(void *args) {
       /* drop packet coming from ourselves */
       continue;
     }
-    switch (uint32_read_big((char *)g_inbuffer + sizeof(g_tracker_id))) {
+    memcpy(&packet_type, g_inbuffer + sizeof(g_tracker_id), sizeof(packet_type));
+
+    switch (ntohl(packet_type)) {
     case OT_SYNC_PEER4:
       livesync_handle_peersync(datalen, OT_PEER_SIZE4);
       break;
@@ -888,7 +890,7 @@ static void *livesync_worker(void *args) {
       livesync_handle_peersync(datalen, OT_PEER_SIZE6);
       break;
     default:
-      // fprintf( stderr, "Received an unknown live sync packet type %u.\n", uint32_read_big( sizeof( g_tracker_id ) + (char*)g_inbuffer ) );
+      // fprintf( stderr, "Received an unknown live sync packet type %u.\n", ntohl( packet_type ) );
       break;
     }
   }
diff --git a/scan_urlencoded_query.c b/scan_urlencoded_query.c
index 38d544a..50aced3 100644
--- a/scan_urlencoded_query.c
+++ b/scan_urlencoded_query.c
@@ -6,9 +6,6 @@
 /* Opentracker */
 #include "scan_urlencoded_query.h"
 
-/* Libwofat */
-#include "scan.h"
-
 /* System */
 #include <string.h>
 
diff --git a/trackerlogic.c b/trackerlogic.c
index 7c6b7e1..59e9643 100644
--- a/trackerlogic.c
+++ b/trackerlogic.c
@@ -5,16 +5,12 @@
 
 /* System */
 #include <arpa/inet.h>
-#include <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
 /* Libowfat */
-#include "array.h"
-#include "byte.h"
 #include "io.h"
 #include "iob.h"
 #include "ip6.h"
@@ -49,30 +45,35 @@ void add_torrent_from_saved_state(ot_hash const hash, ot_time base, size_t down_
   ot_torrent *torrent;
   ot_vector  *torrents_list = mutex_bucket_lock_by_hash(hash);
 
-  if (!accesslist_hashisvalid(hash))
-    return mutex_bucket_unlock_by_hash(hash, 0);
+  if (!accesslist_hashisvalid(hash)) {
+    mutex_bucket_unlock_by_hash(hash, 0);
+    return;
+  }
 
   torrent = vector_find_or_insert(torrents_list, (void *)hash, sizeof(ot_torrent), OT_HASH_COMPARE_SIZE, &exactmatch);
-  if (!torrent || exactmatch)
-    return mutex_bucket_unlock_by_hash(hash, 0);
+  if (!torrent || exactmatch) {
+    mutex_bucket_unlock_by_hash(hash, 0);
+    return;
+  }
 
   /* Create a new torrent entry, then */
-  byte_zero(torrent, sizeof(ot_torrent));
+  memset(torrent, 0, sizeof(ot_torrent));
   memcpy(torrent->hash, hash, sizeof(ot_hash));
 
   if (!(torrent->peer_list6 = malloc(sizeof(ot_peerlist))) || !(torrent->peer_list4 = malloc(sizeof(ot_peerlist)))) {
     vector_remove_torrent(torrents_list, torrent);
-    return mutex_bucket_unlock_by_hash(hash, 0);
+    mutex_bucket_unlock_by_hash(hash, 0);
+    return;
   }
 
-  byte_zero(torrent->peer_list6, sizeof(ot_peerlist));
-  byte_zero(torrent->peer_list4, sizeof(ot_peerlist));
+  memset(torrent->peer_list6, 0, sizeof(ot_peerlist));
+  memset(torrent->peer_list4, 0, sizeof(ot_peerlist));
   torrent->peer_list6->base       = base;
   torrent->peer_list4->base       = base;
   torrent->peer_list6->down_count = down_count;
   torrent->peer_list4->down_count = down_count;
 
-  return mutex_bucket_unlock_by_hash(hash, 1);
+  mutex_bucket_unlock_by_hash(hash, 1);
 }
 
 size_t add_peer_to_torrent_and_return_peers(PROTO_FLAG proto, struct ot_workstruct *ws, size_t amount) {
@@ -102,7 +103,7 @@ size_t add_peer_to_torrent_and_return_peers(PROTO_FLAG proto, struct ot_workstru
 
   if (!exactmatch) {
     /* Create a new torrent entry, then */
-    byte_zero(torrent, sizeof(ot_torrent));
+    memset(torrent, 0, sizeof(ot_torrent));
     memcpy(torrent->hash, *ws->hash, sizeof(ot_hash));
 
     if (!(torrent->peer_list6 = malloc(sizeof(ot_peerlist))) || !(torrent->peer_list4 = malloc(sizeof(ot_peerlist)))) {
@@ -111,8 +112,8 @@ size_t add_peer_to_torrent_and_return_peers(PROTO_FLAG proto, struct ot_workstru
       return 0;
     }
 
-    byte_zero(torrent->peer_list6, sizeof(ot_peerlist));
-    byte_zero(torrent->peer_list4, sizeof(ot_peerlist));
+    memset(torrent->peer_list6, 0, sizeof(ot_peerlist));
+    memset(torrent->peer_list4, 0, sizeof(ot_peerlist));
     delta_torrentcount = 1;
   } else
     clean_single_torrent(torrent);