1 files changed, 83 insertions, 61 deletions

diff --git a/ot_accesslist.c b/ot_accesslist.c
index f1bb885..a199fa4 100644
--- a/ot_accesslist.c
+++ b/ot_accesslist.c
@@ -10,21 +10,23 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#ifdef WANT_DYNAMIC_ACCESSLIST
-#include <errno.h>
+#if defined(WANT_ACCESSLIST_BLACK) || defined(WANT_ACCESSLIST_WHITE)
+#include <fcntl.h>
+#include <stdint.h>
+#include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #endif
+#ifdef WANT_DYNAMIC_ACCESSLIST
+#include <errno.h>
+#endif
 
 /* Libowfat */
-#include "byte.h"
-#include "fmt.h"
 #include "ip6.h"
-#include "mmap.h"
-#include "scan.h"
 
 /* Opentracker */
 #include "ot_accesslist.h"
+#include "ot_hex.h"
 #include "ot_vector.h"
 #include "trackerlogic.h"
 
@@ -99,65 +101,94 @@ static void accesslist_clean(ot_accesslist *accesslist) {
   }
 }
 
-/* Read initial access list */
+/* A hash needs forty bytes, and all but a final one are followed by at least
+   one separator, so n hashes need at least 41n - 1 bytes. (len + 1) / 41 is
+   therefore an exact upper bound on what a buffer of len bytes can hold. */
+size_t accesslist_parse_hashes(ot_hash *dest, size_t capacity, const char *buf, size_t len) {
+  const char *end   = buf + len;
+  const char *offs  = buf;
+  size_t      count = 0;
+
+  while (count < capacity && end - offs >= 40) {
+    if (hex_tohash(dest[count], offs)) {
+      offs += 40;
+
+      if (offs == end || !hex_isdigit((unsigned char)*offs))
+        ++count;
+    }
+
+    /* Find start of next line */
+    while (offs < end && *(offs++) != '\n') {}
+  }
+
+  return count;
+}
+
+/* Map a file read only. Returns 0 and sets map and maplen on success, -1 if
+   the file cannot be opened or mapped. */
+static int accesslist_map(const char *filename, const char **map, size_t *maplen) {
+  struct stat st;
+  void       *mapped;
+  int         fd = open(filename, O_RDONLY);
+
+  if (fd < 0)
+    return -1;
+
+  if (fstat(fd, &st) < 0 || st.st_size < 0 || (uintmax_t)st.st_size > (uintmax_t)SIZE_MAX) {
+    close(fd);
+    return -1;
+  }
+
+  if (st.st_size == 0) {
+    close(fd);
+    *map    = NULL;
+    *maplen = 0;
+    return 0;
+  }
+
+  mapped = mmap(NULL, (size_t)st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+  close(fd);
+
+  if (mapped == MAP_FAILED)
+    return -1;
+
+  *map    = mapped;
+  *maplen = (size_t)st.st_size;
+  return 0;
+}
+
 static void accesslist_readfile(void) {
   ot_accesslist *accesslist_new;
-  ot_hash       *info_hash;
-  const char    *map, *map_end, *read_offs;
-  size_t         maplen;
+  const char    *map;
+  size_t         maplen, capacity, found;
 
-  if ((map = mmap_read(g_accesslist_filename, &maplen)) == NULL) {
+  if (accesslist_map(g_accesslist_filename, &map, &maplen) < 0) {
     char *wd = getcwd(NULL, 0);
     fprintf(stderr, "Warning: Can't open accesslist file: %s (but will try to create it later, if necessary and possible).\nPWD: %s\n", g_accesslist_filename, wd);
     free(wd);
     return;
   }
 
-  /* You need at least 41 bytes to pass an info_hash, make enough room
-     for the maximum amount of them */
-  accesslist_new = accesslist_make(g_accesslist, maplen / 41);
+  /* Make room for the most info_hashes this file could possibly hold */
+  capacity       = (maplen + 1) / 41;
+  accesslist_new = accesslist_make(g_accesslist, capacity);
   if (!accesslist_new) {
-    fprintf(stderr, "Warning: Not enough memory to allocate %zd bytes for accesslist buffer. May succeed later.\n", (maplen / 41) * 20);
-    mmap_unmap(map, maplen);
+    fprintf(stderr, "Warning: Not enough memory to allocate %zd bytes for accesslist buffer. May succeed later.\n", capacity * sizeof(ot_hash));
+    if (map)
+      munmap((void *)map, maplen);
     return;
   }
-  info_hash = accesslist_new->list;
 
-  /* No use to scan if there's not enough room for another full info_hash */
-  map_end   = map + maplen - 40;
-  read_offs = map;
-
-  /* We do ignore anything that is not of the form "^[:xdigit:]{40}[^:xdigit:].*" */
-  while (read_offs <= map_end) {
-    size_t i;
-    for (i = 0; i < sizeof(ot_hash); ++i) {
-      int eger1 = scan_fromhex((unsigned char)read_offs[2 * i]);
-      int eger2 = scan_fromhex((unsigned char)read_offs[1 + 2 * i]);
-      if (eger1 < 0 || eger2 < 0)
-        break;
-      (*info_hash)[i] = (uint8_t)(eger1 * 16 + eger2);
-    }
-
-    if (i == sizeof(ot_hash)) {
-      read_offs += 40;
-
-      /* Append accesslist to accesslist vector */
-      if (read_offs == map_end || scan_fromhex((unsigned char)*read_offs) < 0)
-        ++info_hash;
-    }
-
-    /* Find start of next line */
-    while (read_offs <= map_end && *(read_offs++) != '\n')
-      ;
-  }
+  found = maplen ? accesslist_parse_hashes(accesslist_new->list, capacity, map, maplen) : 0;
 #ifdef _DEBUG
-  fprintf(stderr, "Added %zd info_hashes to accesslist\n", (size_t)(info_hash - accesslist_new->list));
+  fprintf(stderr, "Added %zd info_hashes to accesslist\n", found);
 #endif
 
-  mmap_unmap(map, maplen);
+  if (map)
+    munmap((void *)map, maplen);
 
-  qsort(accesslist_new->list, info_hash - accesslist_new->list, sizeof(*info_hash), vector_compare_hash);
-  accesslist_new->size = info_hash - accesslist_new->list;
+  qsort(accesslist_new->list, found, sizeof(ot_hash), vector_compare_hash);
+  accesslist_new->size = found;
 
   /* Now exchange the accesslist vector in the least race condition prone way */
   pthread_mutex_lock(&g_accesslist_mutex);
@@ -197,7 +228,7 @@ int accesslist_hashisvalid(ot_hash hash) {
 
   /* If we found a matching hash on the main list, scan the list of dynamically deleted hashes */
   accesslist_delete = g_accesslist_delete;
-  if ((exactmatch != NULL) && accesslist_delete && bsearch(hash, accesslist_add->list, accesslist_add->size, OT_HASH_COMPARE_SIZE, vector_compare_hash))
+  if ((exactmatch != NULL) && accesslist_delete && bsearch(hash, accesslist_delete->list, accesslist_delete->size, OT_HASH_COMPARE_SIZE, vector_compare_hash))
     exactmatch = NULL;
 #endif
 
@@ -262,7 +293,6 @@ static void     *accesslist_adddel_worker(char *fifoname, ot_accesslist *_Atomic
 
     while ((linelen = getline(&line, &linecap, fifo)) > 0) {
       ot_hash info_hash;
-      size_t  i;
 
       printf("Got line %*s", (int)linelen, line);
       /* We do ignore anything that is not of the form "^[:xdigit:]{40}[^:xdigit:].*"
@@ -270,15 +300,7 @@ static void     *accesslist_adddel_worker(char *fifoname, ot_accesslist *_Atomic
       if (linelen < 41)
         continue;
 
-      for (i = 0; i < sizeof(ot_hash); ++i) {
-        int eger1 = scan_fromhex((unsigned char)line[2 * i]);
-        int eger2 = scan_fromhex((unsigned char)line[1 + 2 * i]);
-        if (eger1 < 0 || eger2 < 0)
-          break;
-        ((uint8_t *)info_hash)[i] = (uint8_t)(eger1 * 16 + eger2);
-      }
-      printf("parsed info_hash %20s\n", info_hash);
-      if (i != sizeof(ot_hash))
+      if (!hex_tohash(info_hash, line))
         continue;
 
       /* From now on we modify g_accesslist_add and g_accesslist_delete, so prevent the
@@ -528,9 +550,9 @@ int accesslist_bless_net(ot_net *net, ot_permissions permissions) {
     if (net->bits < 128) {
       _debug[off++] = '/';
       if (ip6_isv4mapped(net->address))
-        off += fmt_long(_debug + off, net->bits - 96);
+        off += snprintf(_debug + off, sizeof(_debug) - off, "%d", net->bits - 96);
       else
-        off += fmt_long(_debug + off, net->bits);
+        off += snprintf(_debug + off, sizeof(_debug) - off, "%d", net->bits);
     }
 
     if (permissions & OT_PERMISSION_MAY_STAT)