6 files changed, 465 insertions, 3 deletions

diff --git a/tests/integration/test_dynamic_accesslist.py b/tests/integration/test_dynamic_accesslist.py
new file mode 100644
index 0000000..7fa5fde
--- /dev/null
+++ b/tests/integration/test_dynamic_accesslist.py
@@ -0,0 +1,50 @@
+"""Hashes added to and removed from the blacklist while the tracker runs.
+
+The two FIFOs are read by threads of their own, which is also what makes
+this the test that drives those threads through a shutdown.
+"""
+
+import os
+import time
+import unittest
+
+from harness import TrackerTestCase
+
+BLOCKED = bytes(range(1, 21))
+
+
+def as_hex(info_hash):
+    return "".join("%02x" % b for b in info_hash)
+
+
+class DynamicAccesslist(TrackerTestCase):
+    config = ("access.blacklist {dir}/blacklist\n"
+              "access.fifo_add {dir}/add.fifo\n"
+              "access.fifo_delete {dir}/delete.fifo\n")
+    files = {"blacklist": b""}
+
+    def feed(self, name, info_hash):
+        """Writing to the FIFO blocks until the reader has it, so this also
+           tells us the thread is alive."""
+        with open(os.path.join(self.tracker.dir, name), "w") as fifo:
+            fifo.write("%s added by a test\n" % as_hex(info_hash))
+
+    def wait_for(self, info_hash, blocked, patience=5.0):
+        """The reader thread picks the hash up on its own schedule, so this
+           waits for the answer to change rather than assuming it already has."""
+        deadline = time.time() + patience
+        while time.time() < deadline:
+            answer = self.tracker.announce(info_hash)
+            if (b"failure reason" in answer) == blocked:
+                return True
+            time.sleep(0.05)
+        return False
+
+    def test_a_hash_can_be_blocked_and_released_while_running(self):
+        self.assertNotIn(b"failure reason", self.tracker.announce(BLOCKED))
+
+        self.feed("add.fifo", BLOCKED)
+        self.assertTrue(self.wait_for(BLOCKED, blocked=True), "the hash was never blocked")
+
+        self.feed("delete.fifo", BLOCKED)
+        self.assertTrue(self.wait_for(BLOCKED, blocked=False), "the hash was never released")
diff --git a/tests/runner.c b/tests/runner.c
index 38bfb86..97c6d51 100644
--- a/tests/runner.c
+++ b/tests/runner.c
@@ -27,6 +27,8 @@ static const struct module modules[] = {{"ot_urlencoded", test_urlencoded},
                                         {"ot_buf", test_buf},
                                         {"ot_ip", test_ip},
                                         {"ot_socket", test_socket},
+                                        {"ot_mutex", test_mutex},
+                                        {"trackerlogic", test_trackerlogic},
                                         {"ot_workqueue", test_workqueue},
                                         {"ot_batch", test_batch},
                                         {"ot_fdstate", test_fdstate},
diff --git a/tests/stubs.c b/tests/stubs.c
index a8e6962..5999e2d 100644
--- a/tests/stubs.c
+++ b/tests/stubs.c
@@ -8,11 +8,9 @@
    behaviour should be supplied here rather than the test weakened. */
 
 /* Opentracker */
+#include "ot_stats.h"
 #include "trackerlogic.h"
 
-/* ot_vector.c calls this from vector_clean_list, which no test drives yet. */
-void free_peerlist(ot_peerlist *peer_list) { (void)peer_list; }
-
 /* ot_accesslist.c is built with WANT_ACCESSLIST_BLACK so that the hash parser
    is reachable. These two belong to accesslist_readfile and the reload worker,
    neither of which any test drives. */
@@ -26,3 +24,32 @@ long io_trywrite(long d, const char *buf, long len) {
   (void)buf;
   return len;
 }
+
+/* trackerlogic.c is under test, and starting it up starts every module it
+   leans on. None of them is driven by these tests, so they are answered here
+   rather than linked in and left to run threads of their own. */
+void clean_init(void) {}
+void clean_deinit(void) {}
+int  clean_single_torrent(ot_torrent *torrent) {
+  (void)torrent;
+  return 0;
+}
+void fullscrape_init(void) {}
+void fullscrape_deinit(void) {}
+void livesync_init(void) {}
+void livesync_deinit(void) {}
+void livesync_tell(struct ot_workstruct *ws) { (void)ws; }
+void stats_init(void) {}
+void stats_deinit(void) {}
+void stats_issue_event(struct ot_workstruct *ws, ot_status_event event, PROTO_FLAG proto, uintptr_t event_data) {
+  (void)ws;
+  (void)event;
+  (void)proto;
+  (void)event_data;
+}
+void stats_counters_register(struct ot_workstruct *ws) { (void)ws; }
+void stats_counters_retire(struct ot_workstruct *ws) { (void)ws; }
+
+const char *g_stats_path;
+ssize_t     g_stats_path_len;
+uint32_t    g_tracker_id;
diff --git a/tests/t_mutex.c b/tests/t_mutex.c
new file mode 100644
index 0000000..7c1463b
--- /dev/null
+++ b/tests/t_mutex.c
@@ -0,0 +1,138 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+   It is considered beerware. Prost. Skol. Cheers or whatever.
+
+   $id$ */
+
+/* System */
+#include <pthread.h>
+#include <stdatomic.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Opentracker */
+#include "ot_mutex.h"
+#include "test.h"
+
+/* Every announce passes through here, and what it has to get right is which
+   bucket a hash belongs to and that two threads never hold one bucket at
+   once. Both are checked against real mutexes rather than a stand-in. */
+
+/* A hash that lands in a chosen bucket: the bucket is the top
+   OT_BUCKET_COUNT_BITS of the first four bytes, read in network order */
+static void hash_for_bucket(ot_hash hash, int bucket) {
+  memset(hash, 0, sizeof(ot_hash));
+  hash[0] = (uint8_t)(bucket >> (OT_BUCKET_COUNT_BITS - 8));
+  hash[1] = (uint8_t)((bucket << (16 - OT_BUCKET_COUNT_BITS)) & 0xff);
+}
+
+static void case_a_hash_names_its_bucket(void) {
+  static const int buckets[] = {0, 1, 2, 17, 511, 512, OT_BUCKET_COUNT - 1};
+  size_t           i;
+
+  test_case("a hash is served by the bucket its leading bits name");
+  for (i = 0; i < sizeof(buckets) / sizeof(buckets[0]); ++i) {
+    ot_hash    hash;
+    ot_vector *by_hash, *by_number;
+
+    hash_for_bucket(hash, buckets[i]);
+    by_hash = mutex_bucket_lock_by_hash(hash);
+    mutex_bucket_unlock_by_hash(hash, 0);
+
+    by_number = mutex_bucket_lock(buckets[i]);
+    mutex_bucket_unlock(buckets[i], 0);
+
+    CHECK(by_hash == by_number);
+  }
+}
+
+static void case_every_bucket_is_its_own(void) {
+  ot_vector *first, *last, *middle;
+
+  test_case("no two buckets are the same one");
+  first  = mutex_bucket_lock(0);
+  mutex_bucket_unlock(0, 0);
+  middle = mutex_bucket_lock(OT_BUCKET_COUNT / 2);
+  mutex_bucket_unlock(OT_BUCKET_COUNT / 2, 0);
+  last   = mutex_bucket_lock(OT_BUCKET_COUNT - 1);
+  mutex_bucket_unlock(OT_BUCKET_COUNT - 1, 0);
+
+  CHECK(first != middle);
+  CHECK(middle != last);
+  CHECK(first != last);
+}
+
+static void case_the_count_follows_what_unlock_is_told(void) {
+  size_t before = mutex_get_torrent_count();
+
+  test_case("the torrent count moves by what unlocking reports, and not otherwise");
+  mutex_bucket_lock(3);
+  mutex_bucket_unlock(3, 0);
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 0);
+
+  mutex_bucket_lock(3);
+  mutex_bucket_unlock(3, 5);
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 5);
+
+  mutex_bucket_lock(3);
+  mutex_bucket_unlock(3, -2);
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 3);
+}
+
+static _Atomic int g_other_got_in;
+
+static void *take_a_bucket(void *args) {
+  int bucket = (int)(intptr_t)args;
+
+  mutex_bucket_lock(bucket);
+  atomic_store(&g_other_got_in, 1);
+  mutex_bucket_unlock(bucket, 0);
+  return NULL;
+}
+
+static int waited_for_entry(int patience_ms) {
+  int waited;
+
+  for (waited = 0; waited < patience_ms && !atomic_load(&g_other_got_in); ++waited)
+    usleep(1000);
+  return atomic_load(&g_other_got_in);
+}
+
+static void case_a_held_bucket_keeps_others_out(void) {
+  pthread_t other;
+
+  test_case("a second thread waits for the bucket this one holds");
+  atomic_store(&g_other_got_in, 0);
+  mutex_bucket_lock(9);
+  CHECK_INT(pthread_create(&other, NULL, take_a_bucket, (void *)(intptr_t)9), 0);
+
+  CHECK_INT(waited_for_entry(200), 0);
+
+  mutex_bucket_unlock(9, 0);
+  CHECK_INT(waited_for_entry(2000), 1);
+  pthread_join(other, NULL);
+}
+
+static void case_another_bucket_is_free_meanwhile(void) {
+  pthread_t other;
+
+  test_case("and a different bucket is not held up by it");
+  atomic_store(&g_other_got_in, 0);
+  mutex_bucket_lock(9);
+  CHECK_INT(pthread_create(&other, NULL, take_a_bucket, (void *)(intptr_t)10), 0);
+
+  CHECK_INT(waited_for_entry(2000), 1);
+  pthread_join(other, NULL);
+  mutex_bucket_unlock(9, 0);
+}
+
+void test_mutex(void) {
+  mutex_init();
+
+  case_a_hash_names_its_bucket();
+  case_every_bucket_is_its_own();
+  case_the_count_follows_what_unlock_is_told();
+  case_a_held_bucket_keeps_others_out();
+  case_another_bucket_is_free_meanwhile();
+
+  mutex_deinit();
+}
diff --git a/tests/t_trackerlogic.c b/tests/t_trackerlogic.c
new file mode 100644
index 0000000..d3d8755
--- /dev/null
+++ b/tests/t_trackerlogic.c
@@ -0,0 +1,243 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+   It is considered beerware. Prost. Skol. Cheers or whatever.
+
+   $id$ */
+
+/* System */
+#include <arpa/inet.h>
+#include <signal.h>
+#include <pthread.h>
+#include <string.h>
+
+/* Opentracker */
+#include "ot_mutex.h"
+#include "trackerlogic.h"
+#include "test.h"
+
+/* The swarm itself: what an announce does to a torrent, and what a scrape
+   says about it afterwards. The counts are read back through the udp scrape
+   because that is the one reply the tracker builds as plain numbers. */
+
+static struct ot_workstruct ws;
+
+static void                 hash_named(ot_hash hash, const char *name) {
+  memset(hash, 0, sizeof(ot_hash));
+  memcpy(hash, name, strlen(name) < sizeof(ot_hash) ? strlen(name) : sizeof(ot_hash));
+}
+
+/* An IPv4 peer arrives as the v4 mapped form the tracker stores */
+static void peer_v4(ot_peer6 peer, uint8_t last, uint16_t port) {
+  ot_ip6   ip = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 10, 0, 0, 0};
+  uint16_t net_port = htons(port);
+
+  ip[15] = last;
+  memset(peer, 0, sizeof(ot_peer6));
+  OT_SETIP(peer, ip);
+  OT_SETPORT(peer, &net_port);
+  OT_PEERFLAG(peer) = 0;
+}
+
+static void peer_v6(ot_peer6 peer, uint8_t last, uint16_t port) {
+  ot_ip6   ip = {0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  uint16_t net_port = htons(port);
+
+  ip[15] = last;
+  memset(peer, 0, sizeof(ot_peer6));
+  OT_SETIP(peer, ip);
+  OT_SETPORT(peer, &net_port);
+  OT_PEERFLAG(peer) = 0;
+}
+
+static void announce(ot_hash *hash, ot_peer6 peer) {
+  ws.hash = hash;
+  memcpy(ws.peer, peer, sizeof(ot_peer6));
+  ws.reply = ws.outbuf;
+  add_peer_to_torrent_and_return_peers(FLAG_TCP, &ws, 50);
+}
+
+/* seeders, downloads completed, leechers */
+static void scrape(ot_hash hash, uint32_t counts[3]) {
+  char reply[12];
+
+  return_udp_scrape_for_torrent(hash, reply);
+  counts[0] = ntohl(((uint32_t *)reply)[0]);
+  counts[1] = ntohl(((uint32_t *)reply)[1]);
+  counts[2] = ntohl(((uint32_t *)reply)[2]);
+}
+
+static void case_an_announce_makes_a_torrent(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+  size_t   before = mutex_get_torrent_count();
+
+  test_case("the first announce for a hash creates its torrent");
+  hash_named(hash, "first-announce");
+  peer_v4(peer, 1, 6881);
+  announce(&hash, peer);
+
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 1);
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 1); /* one leecher */
+  CHECK_INT((int)counts[0], 0);
+}
+
+static void case_the_same_peer_twice_is_one_peer(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("announcing twice renews a peer rather than adding another");
+  hash_named(hash, "renewing");
+  peer_v4(peer, 2, 6881);
+  announce(&hash, peer);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 1);
+}
+
+static void case_a_port_makes_a_different_peer(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("the same address on another port is another peer");
+  hash_named(hash, "two-ports");
+  peer_v4(peer, 3, 6881);
+  announce(&hash, peer);
+  peer_v4(peer, 3, 6882);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 2);
+}
+
+static void case_seeding_is_counted_apart(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a seeder counts as complete, a leecher as incomplete");
+  hash_named(hash, "seed-and-leech");
+  peer_v4(peer, 4, 6881);
+  OT_PEERFLAG(peer) |= PEER_FLAG_SEEDING;
+  announce(&hash, peer);
+  peer_v4(peer, 5, 6881);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[0], 1);
+  CHECK_INT((int)counts[2], 1);
+}
+
+static void case_completion_without_seeding_is_not_believed(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a peer that claims to have completed but is still leeching is not counted");
+  hash_named(hash, "claiming");
+  peer_v4(peer, 6, 6881);
+  OT_PEERFLAG(peer) |= PEER_FLAG_COMPLETED;
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[1], 0);
+  CHECK_INT((int)counts[2], 1); /* still a leecher */
+}
+
+static void case_completing_is_counted_once(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a seeder reporting completion is counted once, however often it says so");
+  hash_named(hash, "completing");
+  peer_v4(peer, 7, 6881);
+  OT_PEERFLAG(peer) |= PEER_FLAG_COMPLETED | PEER_FLAG_SEEDING;
+  announce(&hash, peer);
+  announce(&hash, peer);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[1], 1);
+  CHECK_INT((int)counts[0], 1);
+}
+
+static void case_a_peer_can_leave(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a peer that stops is gone from the swarm");
+  hash_named(hash, "leaving");
+  peer_v4(peer, 7, 6881);
+  announce(&hash, peer);
+  peer_v4(peer, 8, 6881);
+  announce(&hash, peer);
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 2);
+
+  ws.hash = &hash;
+  memcpy(ws.peer, peer, sizeof(ot_peer6));
+  remove_peer_from_torrent(FLAG_TCP, &ws);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 1);
+}
+
+static void case_the_families_are_kept_apart(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a v4 and a v6 peer of one swarm are both counted");
+  hash_named(hash, "dual-stack");
+  peer_v4(peer, 9, 6881);
+  announce(&hash, peer);
+  peer_v6(peer, 9, 6881);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 2);
+}
+
+static void case_a_hash_nobody_announced(void) {
+  ot_hash  hash;
+  uint32_t counts[3];
+
+  test_case("a hash nobody has announced scrapes as nothing at all");
+  hash_named(hash, "never-seen");
+  scrape(hash, counts);
+  CHECK_INT((int)counts[0], 0);
+  CHECK_INT((int)counts[1], 0);
+  CHECK_INT((int)counts[2], 0);
+}
+
+void test_trackerlogic(void) {
+  sigset_t signal_mask;
+
+  /* accesslist_init starts a thread that waits for SIGHUP and is stopped by
+     being sent one, so the signal has to be blocked here as the tracker
+     blocks it, or stopping the tracker logic ends this process instead */
+  sigemptyset(&signal_mask);
+  sigaddset(&signal_mask, SIGHUP);
+  pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
+
+  trackerlogic_init();
+  CHECK_INT(workstruct_init(&ws), 0);
+
+  case_an_announce_makes_a_torrent();
+  case_the_same_peer_twice_is_one_peer();
+  case_a_port_makes_a_different_peer();
+  case_seeding_is_counted_apart();
+  case_completion_without_seeding_is_not_believed();
+  case_completing_is_counted_once();
+  case_a_peer_can_leave();
+  case_the_families_are_kept_apart();
+  case_a_hash_nobody_announced();
+
+  workstruct_deinit(&ws);
+  trackerlogic_deinit();
+}
diff --git a/tests/test.h b/tests/test.h
index d58742c..d7296cc 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -86,6 +86,8 @@ void test_scan(void);
 void test_buf(void);
 void test_ip(void);
 void test_socket(void);
+void test_mutex(void);
+void test_trackerlogic(void);
 void test_workqueue(void);
 void test_batch(void);
 void test_fdstate(void);