1 files changed, 27 insertions, 25 deletions

diff --git a/ot_accesslist.c b/ot_accesslist.c
index d7e88ee..4bf1701 100644
--- a/ot_accesslist.c
+++ b/ot_accesslist.c
@@ -21,8 +21,6 @@
 #include <errno.h>
 #endif
 
-/* Libowfat */
-
 /* Opentracker */
 #include "ot_accesslist.h"
 #include "ot_hex.h"
@@ -110,7 +108,7 @@ size_t accesslist_parse_hashes(ot_hash *dest, size_t capacity, const char *buf,
   size_t      count = 0;
 
   while (count < capacity && end - offs >= 40) {
-    if (hex_tohash(dest[count], offs)) {
+    if (hex_to_hash(dest[count], offs)) {
       offs += 40;
 
       if (offs == end || !hex_isdigit((unsigned char)*offs))
@@ -162,6 +160,9 @@ static void accesslist_readfile(void) {
   const char    *map;
   size_t         maplen, capacity, found;
 
+  if (!g_accesslist_filename)
+    return;
+
   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);
@@ -187,7 +188,8 @@ static void accesslist_readfile(void) {
   if (map)
     munmap((void *)map, maplen);
 
-  qsort(accesslist_new->list, found, sizeof(ot_hash), vector_compare_hash);
+  if (found)
+    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 */
@@ -225,18 +227,18 @@ int accesslist_hashisvalid(const ot_hash hash) {
 #endif
   void *exactmatch = NULL;
 
-  if (accesslist)
+  if (accesslist && accesslist->size)
     exactmatch = bsearch(hash, accesslist->list, accesslist->size, OT_HASH_COMPARE_SIZE, vector_compare_hash);
 
 #ifdef WANT_DYNAMIC_ACCESSLIST
   /* If we had no match on the main list, scan the list of dynamically added hashes */
   accesslist_add = g_accesslist_add;
-  if ((exactmatch == NULL) && accesslist_add)
+  if ((exactmatch == NULL) && accesslist_add && accesslist_add->size)
     exactmatch = bsearch(hash, accesslist_add->list, accesslist_add->size, OT_HASH_COMPARE_SIZE, vector_compare_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_delete->list, accesslist_delete->size, OT_HASH_COMPARE_SIZE, vector_compare_hash))
+  if ((exactmatch != NULL) && accesslist_delete && accesslist_delete->size && bsearch(hash, accesslist_delete->list, accesslist_delete->size, OT_HASH_COMPARE_SIZE, vector_compare_hash))
     exactmatch = NULL;
 #endif
 
@@ -308,7 +310,7 @@ static void     *accesslist_adddel_worker(const char *fifoname, ot_accesslist *_
       if (linelen < 41)
         continue;
 
-      if (!hex_tohash(info_hash, line))
+      if (!hex_to_hash(info_hash, line))
         continue;
 
       /* From now on we modify g_accesslist_add and g_accesslist_delete, so prevent the
@@ -339,7 +341,7 @@ static void     *accesslist_adddel_worker(const char *fifoname, ot_accesslist *_
         }
       } else {
         int exactmatch   = 0;
-        ot_hash *insert_point = binary_search(info_hash, (*adding_to)->list, (*adding_to)->size, sizeof(ot_hash), OT_HASH_COMPARE_SIZE, &exactmatch);
+        ot_hash *insert_point = vector_binary_search(info_hash, (*adding_to)->list, (*adding_to)->size, sizeof(ot_hash), OT_HASH_COMPARE_SIZE, &exactmatch);
 
         /* Only if the info hash is not in the adding_to list, create a new head with that entry */
         if (!exactmatch) {
@@ -386,8 +388,9 @@ void accesslist_init(void) {
 }
 
 void accesslist_deinit(void) {
-  /* Wake up sleeping worker */
+  /* Wake the worker and wait for it to notice that the tracker is stopping. */
   pthread_kill(thread_id, SIGHUP);
+  pthread_join(thread_id, NULL);
 
   pthread_mutex_lock(&g_accesslist_mutex);
 
@@ -399,7 +402,6 @@ void accesslist_deinit(void) {
 #endif
 
   pthread_mutex_unlock(&g_accesslist_mutex);
-  pthread_cancel(thread_id);
   pthread_mutex_destroy(&g_accesslist_mutex);
 }
 
@@ -416,7 +418,7 @@ void accesslist_cleanup(void) {
 }
 #endif
 
-int address_in_net(const ot_ip6 address, const ot_net *net) {
+int accesslist_address_in_net(const ot_ip6 address, const ot_net *net) {
   int bits = net->bits, checkbits = (0x7f00 >> (bits & 7));
   int result = memcmp(address, &net->address, bits >> 3);
   if (!result && (bits & 7))
@@ -424,7 +426,7 @@ int address_in_net(const ot_ip6 address, const ot_net *net) {
   return result == 0;
 }
 
-void *set_value_for_net(const ot_net *net, ot_vector *vector, const void *value, const size_t member_size) {
+void *accesslist_set_value_for_net(const ot_net *net, ot_vector *vector, const void *value, const size_t member_size) {
   size_t i;
   int    exactmatch;
 
@@ -435,7 +437,7 @@ void *set_value_for_net(const ot_net *net, ot_vector *vector, const void *value,
   /* Check each net in vector for overlap */
   uint8_t *member = ((uint8_t *)vector->data);
   for (i = 0; i < vector->size; ++i) {
-    if (address_in_net(*(ot_ip6 *)member, net) || address_in_net(net->address, (ot_net *)member))
+    if (accesslist_address_in_net(*(ot_ip6 *)member, net) || accesslist_address_in_net(net->address, (ot_net *)member))
       return 0;
     member += member_size;
   }
@@ -451,16 +453,16 @@ void *set_value_for_net(const ot_net *net, ot_vector *vector, const void *value,
 
 /* Takes a vector filled with { ot_net net, uint8_t[x] value };
    Returns value associated with the net, or NULL if not found */
-void *get_value_for_net(const ot_ip6 address, const ot_vector *vector, const size_t member_size) {
+void *accesslist_get_value_for_net(const ot_ip6 address, const ot_vector *vector, const size_t member_size) {
   int     exactmatch;
   /* This binary search will return a pointer to the first non-containing network... */
-  ot_net *net = binary_search(address, vector->data, vector->size, member_size, sizeof(ot_ip6), &exactmatch);
+  ot_net *net = vector_binary_search(address, vector->data, vector->size, member_size, sizeof(ot_ip6), &exactmatch);
   if (!net)
     return NULL;
   /* ... so we'll need to move back one step unless we've exactly hit the first address in network */
   if (!exactmatch && ((void *)net > vector->data))
     --net;
-  if (!address_in_net(address, net))
+  if (!accesslist_address_in_net(address, net))
     return NULL;
   return (void *)net;
 }
@@ -472,7 +474,7 @@ static pthread_mutex_t g_lognets_list_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 void loglist_add_network(const ot_net *net) {
   pthread_mutex_lock(&g_lognets_list_mutex);
-  set_value_for_net(net, &g_lognets_list, NULL, sizeof(ot_net));
+  accesslist_set_value_for_net(net, &g_lognets_list, NULL, sizeof(ot_net));
   pthread_mutex_unlock(&g_lognets_list_mutex);
 }
 
@@ -487,7 +489,7 @@ void loglist_reset(void) {
 int loglist_check_address(const ot_ip6 address) {
   int result;
   pthread_mutex_lock(&g_lognets_list_mutex);
-  result = (NULL != get_value_for_net(address, &g_lognets_list, sizeof(ot_net)));
+  result = (NULL != accesslist_get_value_for_net(address, &g_lognets_list, sizeof(ot_net)));
   pthread_mutex_unlock(&g_lognets_list_mutex);
   return result;
 }
@@ -508,17 +510,17 @@ int proxylist_add_network(const ot_net *proxy, const ot_net *net) {
   pthread_mutex_lock(&g_proxies_list_mutex);
 
   /* If we have a direct hit, use and extend the vector there */
-  map = binary_search(proxy, g_proxies_list.data, g_proxies_list.size, sizeof(ot_proxymap), sizeof(ot_net), &exactmatch);
+  map = vector_binary_search(proxy, g_proxies_list.data, g_proxies_list.size, sizeof(ot_proxymap), sizeof(ot_net), &exactmatch);
 
   if (!map || !exactmatch) {
     /* else see, if we've got overlapping networks
        and get a new empty vector if not */
     ot_vector empty;
     memset(&empty, 0, sizeof(ot_vector));
-    map = set_value_for_net(proxy, &g_proxies_list, &empty, sizeof(ot_proxymap));
+    map = accesslist_set_value_for_net(proxy, &g_proxies_list, &empty, sizeof(ot_proxymap));
   }
 
-  if (map && set_value_for_net(net, &map->networks, NULL, sizeof(ot_net)))
+  if (map && accesslist_set_value_for_net(net, &map->networks, NULL, sizeof(ot_net)))
     result = 1;
 
   pthread_mutex_unlock(&g_proxies_list_mutex);
@@ -531,8 +533,8 @@ int proxylist_check_proxy(const ot_ip6 proxy, const ot_ip6 address) {
 
   pthread_mutex_lock(&g_proxies_list_mutex);
 
-  if ((map = get_value_for_net(proxy, &g_proxies_list, sizeof(ot_proxymap))))
-    if (!address || get_value_for_net(address, &map->networks, sizeof(ot_net)))
+  if ((map = accesslist_get_value_for_net(proxy, &g_proxies_list, sizeof(ot_proxymap))))
+    if (!address || accesslist_get_value_for_net(address, &map->networks, sizeof(ot_net)))
       result = 1;
 
   pthread_mutex_unlock(&g_proxies_list_mutex);
@@ -587,7 +589,7 @@ int accesslist_bless_net(ot_net *net, ot_permissions permissions) {
 int accesslist_is_blessed(ot_ip6 ip, ot_permissions permissions) {
   size_t i;
   for (i = 0; i < g_admin_nets_count; ++i)
-    if (address_in_net(ip, g_admin_nets + i) && (g_admin_nets_permissions[i] & permissions))
+    if (accesslist_address_in_net(ip, g_admin_nets + i) && (g_admin_nets_permissions[i] & permissions))
       return 1;
   return 0;
 }