22 files changed, 493 insertions, 421 deletions

diff --git a/.gitignore b/.gitignore
index 3e469ff..df288e0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,6 @@ proxy.debug
 tests/runner
 tests/runner.poll
 tests/runner.sanitize
+.buildstamp
+.tarball-version
+opentracker-*.tar.gz
diff --git a/Makefile b/Makefile
index 0e5e985..a665890 100644
--- a/Makefile
+++ b/Makefile
@@ -1,20 +1,6 @@
 # $Id$
 
-# Linux flavour
-# PREFIX?=/opt/diet
-# LIBOWFAT_HEADERS=$(PREFIX)/include
-# LIBOWFAT_LIBRARY=$(PREFIX)/lib
-
-# BSD flavour
-# PREFIX?=/usr/local
-# LIBOWFAT_HEADERS=$(PREFIX)/include/libowfat
-# LIBOWFAT_LIBRARY=$(PREFIX)/lib
-
-# Debug flavour
 PREFIX?=..
-LIBOWFAT_HEADERS=$(PREFIX)/libowfat
-LIBOWFAT_LIBRARY=$(PREFIX)/libowfat
-
 BINDIR?=$(PREFIX)/bin
 STRIP?=strip
 
@@ -36,10 +22,8 @@ include Makefile.gzip
 # in Makefile.zstd
 #include Makefile.zstd
 
-#FEATURES+=-DWANT_LOG_NETWORKS
 #FEATURES+=-DWANT_RESTRICT_STATS
 #FEATURES+=-DWANT_IP_FROM_PROXY
-#FEATURES+=-DWANT_FULLLOG_NETWORKS
 #FEATURES+=-DWANT_LOG_NUMWANT
 #FEATURES+=-DWANT_MODEST_FULLSCRAPES
 #FEATURES+=-DWANT_SPOT_WOODPECKER
@@ -55,62 +39,73 @@ FEATURES+=-DWANT_FULLSCRAPE
 #FEATURES+=-D_DEBUG_HTTPERROR
 #FEATURES+=-D_DEBUG_RANDOMTORRENTS
 
-GIT_VERSION=`sh -c 'command -v git >/dev/null && test -d .git && git rev-parse HEAD || echo _git_or_commit_not_found_'`
+VERSION=1.0.0
+TARBALL_VERSION=test -r .tarball-version && read v < .tarball-version && echo "$$v"
+HAVE_GIT=command -v git >/dev/null && test -d .git
+GIT_VERSION=`sh -c '$(TARBALL_VERSION) || { $(HAVE_GIT) && git describe --tags --match "v*" --always --dirty 2>/dev/null; }'`
+OT_TAG=`sh -c '$(TARBALL_VERSION) || { $(HAVE_GIT) && git describe --tags --match "v*" --exact-match 2>/dev/null; }'`
 
 OPTS_debug=-D_DEBUG -g -ggdb # -pg -fprofile-arcs -ftest-coverage
 OPTS_production=-O3
 
-CFLAGS+=-DGIT_VERSION=$(GIT_VERSION) -Wall -pipe -pthread -Wextra -Wwrite-strings #-ansi -pedantic
+CFLAGS+=-DOT_VERSION=\"$(VERSION)\" -DGIT_VERSION=\"$(GIT_VERSION)\" -DOT_TAG=\"$(OT_TAG)\" -Wall -pipe -pthread -Wextra -Wwrite-strings #-ansi -pedantic
 LDFLAGS+=-pthread
 
-# Only the proxy, which has not been ported since the tracker went dual stack,
-# still wants libowfat.
-CFLAGS_libowfat=-I$(LIBOWFAT_HEADERS)
-LDFLAGS_libowfat=-L$(LIBOWFAT_LIBRARY) -lowfat
+# Record feature flags as a dep to allow rebuild when they change
+BUILDSTAMP=.buildstamp
+BUILDDEPS=Makefile $(BUILDSTAMP)
+
+$(BUILDSTAMP): FORCE
+        @echo "$(CFLAGS) $(FEATURES) $(LDFLAGS)" | cmp -s - $@ 2>/dev/null || echo "$(CFLAGS) $(FEATURES) $(LDFLAGS)" > $@
+
+FORCE:
 
 BINARY =opentracker
 HEADERS=trackerlogic.h ot_urlencoded.h ot_batch.h ot_buf.h ot_event.h ot_fdstate.h ot_fmt.h ot_hex.h ot_ip.h ot_config.h ot_scan.h ot_socket.h ot_tcp.h ot_worker.h ot_workqueue.h ot_mutex.h ot_random.h ot_stats.h ot_vector.h ot_clean.h ot_udp.h ot_iovec.h ot_fullscrape.h ot_accesslist.h ot_http.h ot_livesync.h ot_rijndael.h
 SOURCES=opentracker.c trackerlogic.c ot_urlencoded.c ot_batch.c ot_buf.c ot_event.c ot_fdstate.c ot_fmt.c ot_hex.c ot_ip.c ot_config.c ot_scan.c ot_socket.c ot_tcp.c ot_worker.c ot_workqueue.c ot_mutex.c ot_random.c ot_stats.c ot_vector.c ot_clean.c ot_udp.c ot_iovec.c ot_fullscrape.c ot_accesslist.c ot_http.c ot_livesync.c ot_rijndael.c
-SOURCES_proxy=proxy.c ot_batch.c ot_fdstate.c ot_vector.c ot_mutex.c ot_random.c ot_scan.c ot_ip.c ot_socket.c
 
 all: $(BINARY) $(BINARY).debug
 
 CFLAGS_production = $(CFLAGS) $(OPTS_production) $(FEATURES)
 CFLAGS_debug = $(CFLAGS) $(OPTS_debug) $(FEATURES)
 
-CFLAGS_proxy = $(CFLAGS_production) $(CFLAGS_libowfat) -DWANT_SYNC_LIVE
-CFLAGS_proxy_debug = $(CFLAGS_debug) $(CFLAGS_libowfat) -DWANT_SYNC_LIVE
-
-$(BINARY): $(SOURCES) $(HEADERS)
+$(BINARY): $(SOURCES) $(HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_production) $(SOURCES) $(LDFLAGS)
         $(STRIP) $@
-$(BINARY).debug: $(SOURCES) $(HEADERS)
+$(BINARY).debug: $(SOURCES) $(HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_debug) $(SOURCES) $(LDFLAGS)
-proxy: $(SOURCES_proxy) $(HEADERS)
-        $(CC) -o $@ $(CFLAGS_proxy) $(SOURCES_proxy) $(LDFLAGS) $(LDFLAGS_libowfat)
-proxy.debug: $(SOURCES_proxy) $(HEADERS)
-        $(CC) -o $@ $(CFLAGS_proxy_debug) $(SOURCES_proxy) $(LDFLAGS) $(LDFLAGS_libowfat)
+
+# The proxy is out of service
+#
+# SOURCES_proxy=proxy.c ot_batch.c ot_fdstate.c ot_vector.c ot_mutex.c ot_random.c ot_scan.c ot_ip.c ot_socket.c
+# CFLAGS_proxy = $(CFLAGS_production) -DWANT_SYNC_LIVE
+# CFLAGS_proxy_debug = $(CFLAGS_debug) -DWANT_SYNC_LIVE
+#
+# proxy: $(SOURCES_proxy) $(HEADERS) $(BUILDDEPS)
+#       $(CC) -o $@ $(CFLAGS_proxy) $(SOURCES_proxy) $(LDFLAGS)
+# proxy.debug: $(SOURCES_proxy) $(HEADERS) $(BUILDDEPS)
+#       $(CC) -o $@ $(CFLAGS_proxy_debug) $(SOURCES_proxy) $(LDFLAGS)
 
 # Unit tests. The modules under test are compiled straight into the test
 # binary, so a test may reach a static function by including the source if it
 # has to. tests/stubs.c supplies the few symbols those modules reference but
 # the tests never reach.
 TESTBIN=tests/runner
-TEST_SOURCES=tests/runner.c tests/test.c tests/stubs.c tests/t_urlencoded.c tests/t_iovec.c tests/t_vector.c tests/t_random.c tests/t_hex.c tests/t_accesslist.c tests/t_scan.c tests/t_buf.c tests/t_ip.c tests/t_socket.c tests/t_mutex.c tests/t_workqueue.c tests/t_batch.c tests/t_fdstate.c tests/t_event.c tests/t_fmt.c
-TEST_UNITS=ot_urlencoded.c ot_fmt.c ot_event.c ot_batch.c ot_fdstate.c ot_buf.c ot_ip.c ot_socket.c ot_iovec.c ot_vector.c ot_random.c ot_hex.c ot_scan.c ot_accesslist.c ot_mutex.c ot_workqueue.c
+TEST_SOURCES=tests/runner.c tests/test.c tests/stubs.c tests/t_urlencoded.c tests/t_iovec.c tests/t_vector.c tests/t_random.c tests/t_hex.c tests/t_accesslist.c tests/t_scan.c tests/t_buf.c tests/t_ip.c tests/t_socket.c tests/t_mutex.c tests/t_trackerlogic.c tests/t_workqueue.c tests/t_batch.c tests/t_fdstate.c tests/t_event.c tests/t_fmt.c
+TEST_UNITS=ot_urlencoded.c ot_fmt.c ot_event.c ot_batch.c ot_fdstate.c ot_buf.c ot_ip.c ot_socket.c ot_iovec.c ot_vector.c ot_random.c ot_hex.c ot_scan.c ot_accesslist.c ot_mutex.c ot_workqueue.c trackerlogic.c
 TEST_HEADERS=tests/test.h $(HEADERS)
 # Tests reach code that sits behind feature flags, so the units under test are
 # built with those features enabled. A test binary is not a production binary.
 FEATURES_test=$(FEATURES) -DWANT_ACCESSLIST_BLACK -DWANT_SYNC_LIVE
 CFLAGS_test = $(CFLAGS) -I. -g -O1 $(FEATURES_test)
 
-$(TESTBIN): $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS)
+$(TESTBIN): $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_test) $(TEST_SOURCES) $(TEST_UNITS)
 
 check: $(TESTBIN) $(BINARY)
         ./$(TESTBIN)
 
-$(TESTBIN).poll: $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS)
+$(TESTBIN).poll: $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_test) -DOT_EVENT_FORCE_POLL $(TEST_SOURCES) $(TEST_UNITS)
 
 check-poll: $(TESTBIN).poll
@@ -123,7 +118,7 @@ CC_sanitize?=clang
 CFLAGS_sanitize=$(CFLAGS_test) -fsanitize=address,undefined -fno-omit-frame-pointer
 LDFLAGS_sanitize=$(LDFLAGS) -fsanitize=address,undefined
 
-$(TESTBIN).sanitize: $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS)
+$(TESTBIN).sanitize: $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS) $(BUILDDEPS)
         $(CC_sanitize) -o $@ $(CFLAGS_sanitize) $(TEST_SOURCES) $(TEST_UNITS) $(LDFLAGS_sanitize)
 
 check-sanitize: $(TESTBIN).sanitize
@@ -140,7 +135,7 @@ FEATURES_integration=$(FEATURES) -DWANT_IP_FROM_QUERY_STRING -DWANT_ACCESSLIST_B
 CFLAGS_integration=$(CFLAGS) $(OPTS_debug) $(FEATURES_integration) -fsanitize=address,undefined -fno-omit-frame-pointer
 LDFLAGS_integration=$(LDFLAGS) -fsanitize=address,undefined
 
-opentracker.integration: $(SOURCES) $(HEADERS)
+opentracker.integration: $(SOURCES) $(HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_integration) $(SOURCES) $(LDFLAGS_integration)
 
 check-integration: opentracker.integration
@@ -150,7 +145,7 @@ check-integration: opentracker.integration
 CFLAGS_tsan=$(CFLAGS) $(OPTS_debug) $(FEATURES_integration) -fsanitize=thread -fno-omit-frame-pointer
 LDFLAGS_tsan=$(LDFLAGS) -fsanitize=thread
 
-opentracker.tsan: $(SOURCES) $(HEADERS)
+opentracker.tsan: $(SOURCES) $(HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_tsan) $(SOURCES) $(LDFLAGS_tsan)
 
 check-tsan: opentracker.tsan
@@ -164,12 +159,27 @@ check-all:
         $(MAKE) check-integration
         $(MAKE) check-tsan
 
-.PHONY: all check check-poll check-sanitize check-integration check-tsan check-all clean install
+.PHONY: all FORCE dist check check-poll check-sanitize check-integration check-tsan check-all clean install
 
-BINARIES=opentracker opentracker.debug opentracker.integration opentracker.tsan proxy proxy.debug $(TESTBIN) $(TESTBIN).sanitize $(TESTBIN).poll
+BINARIES=opentracker opentracker.debug opentracker.integration opentracker.tsan $(TESTBIN) $(TESTBIN).sanitize $(TESTBIN).poll
 
 clean:
-        rm -rf $(BINARIES) $(BINARIES:=.dSYM) *.o *~
+        rm -rf $(BINARIES) $(BINARIES:=.dSYM) $(BUILDSTAMP) *.o *~
 
 install:
         install -m 755 opentracker $(DESTDIR)$(BINDIR)
+
+# Roll a release: tag it v<something>, then make dist. The commit is written
+# into the tarball, so a build from it reports the same version this checkout
+# would, without a git to ask. The tarball is HEAD by construction, so the
+# working tree it was rolled from does not enter into the version.
+DISTNAME=opentracker-$(VERSION)
+
+dist:
+        @test "`git describe --tags --match 'v*' --exact-match 2>/dev/null`" = "v$(VERSION)" || \
+                { echo "HEAD must carry the tag v$(VERSION). Tag the release, or correct VERSION."; exit 1; }
+        rm -rf $(DISTNAME) $(DISTNAME).tar.gz
+        git archive --format=tar --prefix=$(DISTNAME)/ HEAD | tar -xf -
+        git describe --tags --match "v*" --always > $(DISTNAME)/.tarball-version
+        tar -czf $(DISTNAME).tar.gz $(DISTNAME)
+        rm -rf $(DISTNAME)
diff --git a/man1/opentracker.1 b/man1/opentracker.1
index 0103ebe..489a54c 100644
--- a/man1/opentracker.1
+++ b/man1/opentracker.1
@@ -15,6 +15,7 @@
 .Op Fl d Ar chdir
 .Op Fl u Ar user
 .Op Fl w| Fl b accesslist
+.Op Fl v
 .Sh DESCRIPTION
 .Nm
 is a bittorrent tracker that implements announce and scrape actions over the
@@ -85,6 +86,9 @@ has been compiled with the
 or
 .Br WANT_ACCESSLIST_WHITE
 options, this option sets the location of the accesslist.
+.It Fl v
+Report the version, the event mechanism in use and the feature flags this
+binary was built with.
 .El
 .Sh EXAMPLES
 Start
diff --git a/man4/opentracker.conf.4 b/man4/opentracker.conf.4
index 1bd1c7a..239ab88 100644
--- a/man4/opentracker.conf.4
+++ b/man4/opentracker.conf.4
@@ -84,9 +84,6 @@ Specifies the IP address and port opentracker will listen on for incoming live s
 .It livesync.cluster.node_ip Ar ip_address
 Specifies one trusted IP address for sync between trackers running in a cluster. Can be added more than once.
 .Pp
-.It batchsync.cluster.admin_ip Ar ip_address
-Specifies the admin IP address for old-style (HTTP-based) asynchronous tracker syncing.
-.Pp
 .It tracker.rootdir Ar path
 Specifies the directory opentracker will chroot/chdir to. All black/white list files must be located in this directory.
 .Pp
diff --git a/opentracker.conf.sample b/opentracker.conf.sample
index f075703..491c88a 100644
--- a/opentracker.conf.sample
+++ b/opentracker.conf.sample
@@ -154,12 +154,6 @@
 # livesync.cluster.node_ip 192.168.0.4
 # livesync.cluster.node_ip 192.168.0.5
 # livesync.cluster.node_ip 192.168.0.6
-#
-#      This is the admin ip address for old style (HTTP based) asynchronus
-#      tracker syncing.
-#
-# batchsync.cluster.admin_ip 10.1.1.1
-#
 
 # V)   Control privilege drop behaviour.
 #      Put in the directory opentracker will chroot/chdir to. All black/white
diff --git a/ot_accesslist.c b/ot_accesslist.c
index df084b8..945ddcf 100644
--- a/ot_accesslist.c
+++ b/ot_accesslist.c
@@ -503,34 +503,6 @@ void *accesslist_get_value_for_net(const ot_ip6 address, const ot_vector *vector
   return (void *)net;
 }
 
-#ifdef WANT_FULLLOG_NETWORKS
-static ot_vector       g_lognets_list;
-ot_log                *g_logchain_first, *g_logchain_last;
-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);
-  accesslist_set_value_for_net(net, &g_lognets_list, NULL, sizeof(ot_net));
-  pthread_mutex_unlock(&g_lognets_list_mutex);
-}
-
-void loglist_reset(void) {
-  pthread_mutex_lock(&g_lognets_list_mutex);
-  free(g_lognets_list.data);
-  g_lognets_list.data = 0;
-  g_lognets_list.size = g_lognets_list.space = 0;
-  pthread_mutex_unlock(&g_lognets_list_mutex);
-}
-
-int loglist_check_address(const ot_ip6 address) {
-  int result;
-  pthread_mutex_lock(&g_lognets_list_mutex);
-  result = (NULL != accesslist_get_value_for_net(address, &g_lognets_list, sizeof(ot_net)));
-  pthread_mutex_unlock(&g_lognets_list_mutex);
-  return result;
-}
-#endif
-
 #ifdef WANT_IP_FROM_PROXY
 typedef struct {
   ot_net   *proxy;
diff --git a/ot_accesslist.h b/ot_accesslist.h
index 0a8bf4c..ca0e126 100644
--- a/ot_accesslist.h
+++ b/ot_accesslist.h
@@ -14,6 +14,8 @@
 
 #if defined(WANT_ACCESSLIST_BLACK) || defined(WANT_ACCESSLIST_WHITE)
 #define WANT_ACCESSLIST
+/* Starts a thread that rereads the list when sent SIGHUP, and is stopped by
+   being sent one, so the caller blocks SIGHUP process wide beforehand */
 void         accesslist_init(void);
 void         accesslist_deinit(void);
 int          accesslist_hashisvalid(const ot_hash hash);
@@ -64,22 +66,6 @@ int proxylist_add_network(const ot_net *proxy, const ot_net *net);
 int proxylist_check_network(const ot_ip6 *proxy, const ot_ip6 address /* can be NULL to only check proxy */);
 #endif
 
-#ifdef WANT_FULLLOG_NETWORKS
-typedef struct ot_log ot_log;
-struct ot_log {
-  ot_ip6   ip;
-  uint8_t *data;
-  size_t   size;
-  ot_time  time;
-  ot_log  *next;
-};
-extern ot_log *g_logchain_first, *g_logchain_last;
-
-void           loglist_add_network(const ot_net *net);
-void           loglist_reset(void);
-int            loglist_check_address(const ot_ip6 address);
-#endif
-
 typedef enum {
   OT_PERMISSION_MAY_FULLSCRAPE = 0x1,
   OT_PERMISSION_MAY_STAT       = 0x2,
diff --git a/ot_config.c b/ot_config.c
index 272acf1..5da6642 100644
--- a/ot_config.c
+++ b/ot_config.c
@@ -432,6 +432,7 @@ static void help(char *name) {
   HELPLINE("-d dir", "specify directory to try to chroot to (default: \".\")");
   HELPLINE("-u user", "specify user under whose privileges opentracker should run (default: \"nobody\")");
   HELPLINE("-A ip[/bits]", "bless an ip address or net as admin address (e.g. to allow syncs from this address)");
+  HELPLINE("-v", "report version, event mechanism and the feature flags opentracker was built with");
 #ifdef WANT_ACCESSLIST_BLACK
   HELPLINE("-b file", "specify blacklist file.");
 #elif defined(WANT_ACCESSLIST_WHITE)
@@ -566,6 +567,7 @@ void config_parse(int argc, char **argv) {
       char *cursor = buffer;
 
       stats_return_tracker_version(&cursor, buffer + sizeof(buffer) - 1);
+      stats_return_tracker_features(&cursor, buffer + sizeof(buffer) - 1);
       *cursor = 0;
       fputs(buffer, stderr);
       exit(0);
diff --git a/ot_http.c b/ot_http.c
index b0e1de3..b243ff6 100644
--- a/ot_http.c
+++ b/ot_http.c
@@ -289,10 +289,8 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
                                               {"top10", TASK_STATS_TOP10},
                                               {"renew", TASK_STATS_RENEW},
                                               {"syncs", TASK_STATS_SYNCS},
-                                              {"version", TASK_STATS_VERSION},
                                               {"everything", TASK_STATS_EVERYTHING},
                                               {"statedump", TASK_FULLSCRAPE_TRACKERSTATE},
-                                              {"fulllog", TASK_STATS_FULLLOG},
                                               {"woodpeckers", TASK_STATS_WOODPECKERS},
 #ifdef WANT_LOG_NUMWANT
                                               {"numwants", TASK_STATS_NUMWANTS},
@@ -559,10 +557,7 @@ static ot_keywords keywords_announce[] = {{"port", 1},    {"left", 2}, {"event",
 #ifdef WANT_IP_FROM_QUERY_STRING
                                           {"ip", 7},
 #endif
-#ifdef WANT_FULLLOG_NETWORKS
-                                          {"lognet", 8},
-#endif
-                                          {"peer_id", 9}, {NULL, -3}};
+                                          {"peer_id", 8}, {NULL, -3}};
 static ot_keywords keywords_announce_event[] = {{"completed", 1}, {"stopped", 2}, {NULL, -3}};
 
 /* For the replies that are one fixed string and nothing else, where the only
@@ -687,43 +682,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       OT_SETIP(&ws->peer, tmp_buf1);
     } break;
 #endif
-#ifdef WANT_FULLLOG_NETWORKS
-    case 8: /* matched "lognet" */
-    {
-      // if( accesslist_is_blessed( cookie->ip, OT_PERMISSION_MAY_STAT ) ) {
-      char        *tmp_buf = ws->reply;
-      ot_net       net;
-      uint64_t     value;
-      signed short parsed, bits;
-
-      len          = urlencoded_parse(&read_ptr, tmp_buf, SCAN_SEARCHPATH_VALUE);
-      tmp_buf[len] = 0;
-      if (len <= 0)
-        HTTPERROR_400_PARAM;
-      if (*tmp_buf == '-') {
-        loglist_reset();
-        return ws->reply_size = reply_literal(ws, "Successfully removed.\n");
-      }
-      parsed = ip_parse(tmp_buf, net.address);
-      if (!parsed)
-        HTTPERROR_400_PARAM;
-      if (tmp_buf[parsed++] != '/')
-        bits = 128;
-      else {
-        parsed = scan_uint(tmp_buf + parsed, &value, 128);
-        if (!parsed)
-          HTTPERROR_400_PARAM;
-        bits = (signed short)value;
-        if (ip_is_v4mapped(net.address))
-          bits += 96;
-      }
-      net.bits = bits;
-      loglist_add_network(&net);
-      return ws->reply_size = reply_literal(ws, "Successfully added.\n");
-      //}
-    } break;
-#endif
-    case 9: /* matched "peer_id" */
+    case 8: /* matched "peer_id" */
       /* ignore this, when we have less than 20 bytes */
       if (urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
         HTTPERROR_400_PARAM;
@@ -757,30 +716,6 @@ ssize_t http_handle_request(const int64_t sock, struct ot_workstruct *ws) {
   ssize_t reply_off, len;
   char   *read_ptr = ws->request, *write_ptr;
 
-#ifdef WANT_FULLLOG_NETWORKS
-  struct http_data *cookie = fdstate_cookie(sock);
-  if (loglist_check_address(cookie->ip)) {
-    ot_log *log = malloc(sizeof(ot_log));
-    if (log) {
-      log->size = ws->request_size;
-      log->data = malloc(ws->request_size);
-      log->next = 0;
-      log->time = time_now_seconds();
-      memcpy(log->ip, cookie->ip, sizeof(ot_ip6));
-      if (log->data) {
-        memcpy(log->data, ws->request, ws->request_size);
-        if (!g_logchain_first)
-          g_logchain_first = g_logchain_last = log;
-        else {
-          g_logchain_last->next = log;
-          g_logchain_last       = log;
-        }
-      } else
-        free(log);
-    }
-  }
-#endif
-
 #ifdef _DEBUG_HTTPERROR
   reply_off = ws->request_size;
   if (ws->request_size >= G_DEBUGBUF_SIZE)
diff --git a/ot_stats.c b/ot_stats.c
index d38355a..a2eb084 100644
--- a/ot_stats.c
+++ b/ot_stats.c
@@ -4,7 +4,6 @@
  $id$ */
 
 /* System */
-#include <inttypes.h>
 #include <pthread.h>
 #include <stdatomic.h>
 #include <stdio.h>
@@ -19,6 +18,7 @@
 
 /* Opentracker */
 #include "ot_accesslist.h"
+#include "ot_event.h"
 #include "ot_hex.h"
 #include "ot_iovec.h"
 #include "ot_ip.h"
@@ -117,10 +117,6 @@ union stats_network_node {
   stats_network_node *children[STATS_NETWORK_NODE_COUNT];
 };
 
-#ifdef WANT_LOG_NETWORKS
-static stats_network_node *stats_network_counters_root;
-#endif
-
 static int stat_increase_network_count(stats_network_node **pnode, int depth, uintptr_t ip) {
   int                 foo = __LDR(ip, depth);
   stats_network_node *node;
@@ -504,36 +500,6 @@ static void             stats_return_numwants(char **reply, const char *reply_en
 }
 #endif
 
-#ifdef WANT_FULLLOG_NETWORKS
-static void stats_return_fulllog(size_t *iovec_entries, struct iovec **iovector, char *r) {
-  ot_log *loglist  = g_logchain_first, *llnext;
-  char   *re       = r + OT_STATS_TMPSIZE;
-
-  g_logchain_first = g_logchain_last = 0;
-
-  while (loglist) {
-    if (r + (loglist->size + 64) >= re) {
-      r = iovec_next_chunk(iovec_entries, iovector, r, 32 * OT_STATS_TMPSIZE);
-      if (!r)
-        return;
-      re = r + 32 * OT_STATS_TMPSIZE;
-    }
-    char ip_readable[64];
-
-    ip_readable[ip_format(ip_readable, loglist->ip)] = 0;
-    fmt_append(&r, re, "%08ld: %s\n", loglist->time, ip_readable);
-    fmt_bytes(&r, re, loglist->data, loglist->size);
-    fmt_append(&r, re, "\n*\n\n");
-
-    llnext = loglist->next;
-    free(loglist->data);
-    free(loglist);
-    loglist = llnext;
-  }
-  iovec_trim_last(iovec_entries, iovector, r);
-}
-#endif
-
 static void stats_return_everything(char **reply, const char *reply_end) {
   unsigned long long total[OT_COUNTER_COUNT];
 
@@ -546,10 +512,6 @@ static void stats_return_everything(char **reply, const char *reply_end) {
 
   fmt_append(reply, reply_end, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
   fmt_append(reply, reply_end, "<stats>\n");
-  fmt_append(reply, reply_end, "  <tracker_id>%" PRIu32 "</tracker_id>\n", g_tracker_id);
-  fmt_append(reply, reply_end, "  <version>\n");
-  stats_return_tracker_version(reply, reply_end);
-  fmt_append(reply, reply_end, "  </version>\n");
   fmt_append(reply, reply_end, "  <uptime>%llu</uptime>\n", (unsigned long long)(time(NULL) - ot_start_time));
   fmt_append(reply, reply_end, "  <torrents>\n");
   fmt_append(reply, reply_end, "    <count_mutex>%zd</count_mutex>\n", mutex_get_torrent_count());
@@ -580,10 +542,99 @@ static void stats_return_everything(char **reply, const char *reply_end) {
   fmt_append(reply, reply_end, "</stats>");
 }
 
+/* The names as the Makefile spells them, so that what a binary reports maps
+   straight back onto the FEATURES lines it was built from */
+static const char *const build_features[] = {
+#ifdef WANT_V4_ONLY
+    "WANT_V4_ONLY",
+#endif
+#ifdef WANT_ACCESSLIST_BLACK
+    "WANT_ACCESSLIST_BLACK",
+#endif
+#ifdef WANT_ACCESSLIST_WHITE
+    "WANT_ACCESSLIST_WHITE",
+#endif
+#ifdef WANT_DYNAMIC_ACCESSLIST
+    "WANT_DYNAMIC_ACCESSLIST",
+#endif
+#ifdef WANT_SYNC_LIVE
+    "WANT_SYNC_LIVE",
+#endif
+#ifdef WANT_IP_FROM_QUERY_STRING
+    "WANT_IP_FROM_QUERY_STRING",
+#endif
+#ifdef WANT_IP_FROM_PROXY
+    "WANT_IP_FROM_PROXY",
+#endif
+#ifdef WANT_COMPRESSION_GZIP
+    "WANT_COMPRESSION_GZIP",
+#endif
+#ifdef WANT_COMPRESSION_GZIP_ALWAYS
+    "WANT_COMPRESSION_GZIP_ALWAYS",
+#endif
+#ifdef WANT_COMPRESSION_ZSTD
+    "WANT_COMPRESSION_ZSTD",
+#endif
+#ifdef WANT_COMPRESSION_ZSTD_ALWAYS
+    "WANT_COMPRESSION_ZSTD_ALWAYS",
+#endif
+#ifdef WANT_FULLSCRAPE
+    "WANT_FULLSCRAPE",
+#endif
+#ifdef WANT_MODEST_FULLSCRAPES
+    "WANT_MODEST_FULLSCRAPES",
+#endif
+#ifdef WANT_KEEPALIVE
+    "WANT_KEEPALIVE",
+#endif
+#ifdef WANT_RESTRICT_STATS
+    "WANT_RESTRICT_STATS",
+#endif
+#ifdef WANT_LOG_NUMWANT
+    "WANT_LOG_NUMWANT",
+#endif
+#ifdef WANT_SPOT_WOODPECKER
+    "WANT_SPOT_WOODPECKER",
+#endif
+#ifdef WANT_SYSLOGS
+    "WANT_SYSLOGS",
+#endif
+#ifdef WANT_DEV_RANDOM
+    "WANT_DEV_RANDOM",
+#endif
+#ifdef WANT_INSECURE_RANDOM_FALLBACK
+    "WANT_INSECURE_RANDOM_FALLBACK",
+#endif
+#ifdef _DEBUG
+    "_DEBUG",
+#endif
+#ifdef _DEBUG_HTTPERROR
+    "_DEBUG_HTTPERROR",
+#endif
+#ifdef _DEBUG_RANDOMTORRENTS
+    "_DEBUG_RANDOMTORRENTS",
+#endif
+    NULL};
+
+void stats_return_tracker_features(char **reply, const char *reply_end) {
+  size_t i;
+
+  fmt_append(reply, reply_end, "events: %s\n", event_mechanism());
+  fmt_append(reply, reply_end, "features:");
+  for (i = 0; build_features[i]; ++i)
+    fmt_append(reply, reply_end, " %s", build_features[i]);
+  if (!build_features[0])
+    fmt_append(reply, reply_end, " none");
+  fmt_append(reply, reply_end, "\n");
+}
+
 void stats_return_tracker_version(char **reply, const char *reply_end) {
-#define QUOTE(name) #name
-#define SQUOTE(name) QUOTE(name)
-  fmt_append(reply, reply_end, "https://erdgeist.org/gitweb/opentracker/commit/?id=" SQUOTE(GIT_VERSION) "\n");
+  fmt_append(reply, reply_end, "opentracker %s", OT_VERSION);
+  if (*GIT_VERSION && strcmp(GIT_VERSION, OT_TAG))
+    fmt_append(reply, reply_end, " (%s)", GIT_VERSION);
+  fmt_append(reply, reply_end, "\n");
+  if (*OT_TAG)
+    fmt_append(reply, reply_end, "https://erdgeist.org/gitweb/opentracker/tag/?h=%s\n", OT_TAG);
 }
 
 void return_stats_for_tracker(char **reply, const char *reply_end, int mode, int format) {
@@ -610,9 +661,6 @@ void return_stats_for_tracker(char **reply, const char *reply_end, int mode, int
   case TASK_STATS_HTTPERRORS:
     stats_httperrors_txt(reply, reply_end);
     break;
-  case TASK_STATS_VERSION:
-    stats_return_tracker_version(reply, reply_end);
-    break;
   case TASK_STATS_RENEW:
     stats_return_renew_bucket(reply, reply_end);
     break;
@@ -671,11 +719,6 @@ static void stats_make(size_t *iovec_entries, struct iovec **iovector, ot_taskty
     stats_return_woodpeckers(&r, r_end, 128);
     break;
 #endif
-#ifdef WANT_FULLLOG_NETWORKS
-  case TASK_STATS_FULLLOG:
-    stats_return_fulllog(iovec_entries, iovector, r);
-    return;
-#endif
   default:
     iovec_free(iovec_entries, iovector);
     return;
@@ -693,9 +736,6 @@ void stats_issue_event(struct ot_workstruct *ws, ot_status_event event, PROTO_FL
       COUNT(OT_COUNTER_TCP_CONNECTIONS, 1);
     else
       COUNT(OT_COUNTER_UDP_CONNECTIONS, 1);
-#ifdef WANT_LOG_NETWORKS
-    stat_increase_network_count(&stats_network_counters_root, 0, event_data);
-#endif
     break;
   case EVENT_ANNOUNCE:
     if (proto == FLAG_TCP)
diff --git a/ot_stats.h b/ot_stats.h
index f484765..f9a9d87 100644
--- a/ot_stats.h
+++ b/ot_stats.h
@@ -35,6 +35,7 @@ void               stats_deliver(int64_t sock, int tasktype);
 void               stats_cleanup(void);
 void               return_stats_for_tracker(char **reply, const char *reply_end, int mode, int format);
 void               stats_return_tracker_version(char **reply, const char *reply_end);
+void               stats_return_tracker_features(char **reply, const char *reply_end);
 void               stats_init(void);
 void               stats_deinit(void);
 
diff --git a/ot_sync.c b/ot_sync.c
deleted file mode 100644
index c19cf36..0000000
--- a/ot_sync.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/* 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 <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-
-/* Opentracker */
-#include "ot_fmt.h"
-#include "ot_iovec.h"
-#include "ot_mutex.h"
-#include "ot_workqueue.h"
-#include "ot_scan.h"
-#include "ot_stats.h"
-#include "ot_sync.h"
-#include "trackerlogic.h"
-
-#ifdef WANT_SYNC_BATCH
-
-#define OT_SYNC_CHUNK_SIZE (512 * 1024)
-
-/* Import Changeset from an external authority
-   format: d4:syncd[..]ee
-   [..]:   ( 20:01234567890abcdefghij16:XXXXYYYY )+
-*/
-int add_changeset_to_tracker(uint8_t *data, size_t len) {
-  ot_hash *hash;
-  uint8_t *end = data + len;
-  uint64_t peer_count;
-
-  /* We do know, that the string is \n terminated, so it can't
-     overflow */
-  if (!memcmp(data, "d4:syncd", 8))
-    return -1;
-  data += 8;
-
-  while (1) {
-    if (!memcmp(data, "20:", 3)) {
-      if (!memcmp(data, "ee", 2))
-        return -1;
-      return 0;
-    }
-    data += 3;
-    hash  = (ot_hash *)data;
-    data += sizeof(ot_hash);
-
-    /* Scan string length indicator, strictly: bencode writes no leading zeros */
-    data += (len = scan_uint_bencode((char *)data, &peer_count, (uint64_t)(end - data)));
-
-    /* If no long was scanned, it is not divisible by 8, it is not
-       followed by a colon or claims to need to much memory, we fail */
-    if (!len || !peer_count || (peer_count & 7) || (*data++ != ':') || (data + peer_count > end))
-      return -1;
-
-    while (peer_count > 0) {
-      add_peer_to_torrent(hash, (ot_peer *)data, 1);
-      data       += 8;
-      peer_count -= 8;
-    }
-  }
-  return 0;
-}
-
-/* Proposed output format
-   d4:syncd20:<info_hash>8*N:(xxxxyyyy)*Nee
-*/
-static void sync_make(size_t *iovec_entries, struct iovec **iovector) {
-  size_t bucket;
-  char  *r, *re;
-
-  /* Setup return vector... */
-  *iovec_entries = 0;
-  *iovector      = NULL;
-  if (!(r = iovec_new_chunk(iovec_entries, iovector, OT_SYNC_CHUNK_SIZE)))
-    return;
-
-  /* ... and pointer to end of current output buffer.
-     This works as a low watermark */
-  re = r + OT_SYNC_CHUNK_SIZE;
-
-  memmove(r, "d4:syncd", 8);
-  r += 8;
-
-  /* For each bucket... */
-  for (bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket) {
-    /* Get exclusive access to that bucket */
-    ot_vector *torrents_list = mutex_bucket_lock(bucket);
-    size_t     tor_offset;
-
-    /* For each torrent in this bucket.. */
-    for (tor_offset = 0; tor_offset < torrents_list->size; ++tor_offset) {
-      /* Address torrents members */
-      ot_peerlist *peer_list  = (((ot_torrent *)(torrents_list->data))[tor_offset]).peer_list;
-      ot_hash     *hash       = &(((ot_torrent *)(torrents_list->data))[tor_offset]).hash;
-      const size_t byte_count = sizeof(ot_peer) * peer_list->changeset.size;
-
-      /* If we reached our low watermark in buffer... */
-      if (re - r <= (ssize_t)(/* strlen( "20:" ) == */ 3 + sizeof(ot_hash) + /* strlen_max( "%zd" ) == */ 12 + byte_count)) {
-
-        /* Allocate a fresh output buffer at the end of our buffers list
-           release bucket and return, if that fails */
-        if (!(r = iovec_next_chunk(iovec_entries, iovector, r, OT_SYNC_CHUNK_SIZE)))
-          return mutex_bucket_unlock(bucket);
-
-        /* Adjust new end of output buffer */
-        re = r + OT_SYNC_CHUNK_SIZE;
-      }
-
-      fmt_append(&r, re, "20:");
-      fmt_bytes(&r, re, hash, sizeof(ot_hash));
-      fmt_append(&r, re, "%zd:", byte_count);
-      fmt_bytes(&r, re, peer_list->changeset.data, byte_count);
-    }
-
-    /* All torrents done: release lock on currenct bucket */
-    mutex_bucket_unlock(bucket);
-  }
-
-  /* Close bencoded sync dictionary */
-  *r++ = 'e';
-  *r++ = 'e';
-
-  /* Release unused memory in current output buffer */
-  iovec_trim_last(iovec_entries, iovector, r);
-}
-
-/* This is the entry point into this worker thread
-   It grabs tasks from mutex_tasklist and delivers results back
-*/
-static void *sync_worker(void *args) {
-  size_t        iovec_entries;
-  struct iovec *iovector;
-
-  args = args;
-
-  while (1) {
-    ot_tasktype tasktype = TASK_SYNC_OUT;
-    ot_taskid   taskid   = workqueue_poptask(&tasktype);
-    sync_make(&iovec_entries, &iovector);
-    stats_issue_event(ws, EVENT_SYNC_OUT, FLAG_TCP, iovec_length(&iovec_entries, &iovector));
-    if (workqueue_pushresult(taskid, iovec_entries, iovector))
-      iovec_free(&iovec_entries, &iovector);
-  }
-  return NULL;
-}
-
-static pthread_t thread_id;
-void sync_init( ) {
-  pthread_create( &thread_id, NULL, sync_worker, NULL );
-}
-
-void sync_deinit( ) {
-  pthread_cancel( thread_id );
-}
-
-void sync_deliver( int64_t socket ) {
-  workqueue_pushtask( socket, TASK_SYNC_OUT );
-}
-
-#endif
diff --git a/ot_sync.h b/ot_sync.h
deleted file mode 100644
index b6964fa..0000000
--- a/ot_sync.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
-   It is considered beerware. Prost. Skol. Cheers or whatever.
-
-   $id$ */
-
-#ifndef OT_SYNC_H__
-#define OT_SYNC_H__
-
-#include <stdint.h>
-
-#ifdef WANT_SYNC_BATCH
-enum { SYNC_IN, SYNC_OUT };
-
-void sync_init();
-void sync_deinit();
-void sync_deliver(int64_t socket);
-
-int  add_changeset_to_tracker(uint8_t *data, size_t len);
-#else
-
-#define sync_init()
-#define sync_deinit()
-
-#endif
-
-#endif
diff --git a/ot_workqueue.h b/ot_workqueue.h
index f99a7b5..4acd6fd 100644
--- a/ot_workqueue.h
+++ b/ot_workqueue.h
@@ -23,7 +23,6 @@ typedef enum {
   TASK_STATS_FULLSCRAPE          = 0x0005,
   TASK_STATS_TPB                 = 0x0006,
   TASK_STATS_HTTPERRORS          = 0x0007,
-  TASK_STATS_VERSION             = 0x0008,
   TASK_STATS_RENEW               = 0x000a,
   TASK_STATS_SYNCS               = 0x000b,
   TASK_STATS_COMPLETED           = 0x000c,
@@ -36,7 +35,6 @@ typedef enum {
   TASK_STATS_TOP10               = 0x0104,
   TASK_STATS_TOP100              = 0x0105,
   TASK_STATS_EVERYTHING          = 0x0106,
-  TASK_STATS_FULLLOG             = 0x0107,
   TASK_STATS_WOODPECKERS         = 0x0108,
 
   TASK_FULLSCRAPE                = 0x0200, /* Default mode */
diff --git a/proxy.c b/proxy.c
index b06e256..f6e90a3 100644
--- a/proxy.c
+++ b/proxy.c
@@ -3,6 +3,10 @@
 
    $Id$ */
 
+/* This relays sync traffic between trackers, and between multicast domains
+   that have no route to each other, so that no tracker has to reach out to
+   the outside world by itself. Defunc. */
+
 /* System */
 #include <arpa/inet.h>
 #include <ctype.h>
diff --git a/tests/integration/test_stats.py b/tests/integration/test_stats.py
index 820b917..088d8a1 100644
--- a/tests/integration/test_stats.py
+++ b/tests/integration/test_stats.py
@@ -15,10 +15,10 @@ import xml.etree.ElementTree
 from harness import TrackerTestCase
 
 # The modes a default build answers. "tpbs" and "statedump" are full scrapes
-# and belong to test_fullscrape; "fulllog" and "woodpeckers" sit behind
-# feature flags this build does not set.
+# and belong to test_fullscrape; "woodpeckers" sits behind a
+# feature flag this build does not set.
 MRTG_MODES = ["peer", "conn", "scrp", "udp4", "tcp4", "torr", "fscr", "completed", "syncs"]
-TEXT_MODES = ["herr", "s24s", "top10", "top100", "renew", "version"]
+TEXT_MODES = ["herr", "s24s", "top10", "top100", "renew"]
 
 
 class StatsShape(TrackerTestCase):
@@ -55,9 +55,22 @@ class StatsShape(TrackerTestCase):
         self.assertIsNotNone(root.find("torrents/count_mutex"))
         self.assertIsNotNone(root.find("connections/tcp/announce"))
 
-    def test_version_names_a_commit(self):
-        self.assertIn(b"opentracker", self.tracker.stats("version").lower() + b"opentracker")
-        self.assertRegex(self.tracker.stats("version"), rb"https?://")
+    def test_the_version_mode_is_gone(self):
+        """Which build a tracker is and what went into it is of use to whoever
+        attacks it and to nobody else on the far end of a socket. It is
+        reported by -v, to whoever already has the binary."""
+        with self.assertRaises(urllib.error.HTTPError) as caught:
+            self.tracker.stats("version")
+        self.assertEqual(caught.exception.code, 400, "an unknown mode, like any other")
+
+    def test_everything_does_not_name_the_build(self):
+        self.assertNotIn(b"opentracker 1", self.tracker.stats("everything"))
+
+    def test_everything_does_not_name_the_tracker_id(self):
+        """The id a tracker recognises its own live sync packets by. Knowing
+        it is of no use to a client and of some use to whoever would like a
+        tracker to discard what it is told."""
+        self.assertNotIn(b"tracker_id", self.tracker.stats("everything"))
 
 
 class StatsCount(TrackerTestCase):
diff --git a/tests/integration/test_version.py b/tests/integration/test_version.py
new file mode 100644
index 0000000..66f570d
--- /dev/null
+++ b/tests/integration/test_version.py
@@ -0,0 +1,36 @@
+"""The -v report, which is where a build says what went into it.
+
+Driving the binary is the only way to see this: the feature list is a table
+of #ifdefs, so it is only true for the flags the binary itself was built with.
+"""
+
+import subprocess
+import unittest
+
+from harness import TRACKER
+
+
+class VersionFlag(unittest.TestCase):
+    def report(self):
+        # -v writes to stderr and exits before it binds anything
+        done = subprocess.run([TRACKER, "-v"], capture_output=True, timeout=30)
+        self.assertEqual(done.returncode, 0, done.stderr)
+        return done.stderr.decode()
+
+    def test_first_line_names_the_release(self):
+        # The commit in brackets is there in a checkout and in a release
+        # tarball, and absent in a build that had neither to ask.
+        first = self.report().splitlines()[0]
+        self.assertRegex(first, r"^opentracker \d+\.\d+\.\d+( \(\S+\))?$")
+
+    def test_names_the_event_mechanism(self):
+        self.assertRegex(self.report(), r"(?m)^events: (epoll|kqueue|poll)$")
+
+    def test_lists_the_features_this_build_has(self):
+        # The Makefile builds this binary with these and not with those, so a
+        # feature table that stops following the build fails here.
+        report = self.report()
+        for want in ("WANT_KEEPALIVE", "WANT_ACCESSLIST_BLACK", "WANT_DYNAMIC_ACCESSLIST"):
+            self.assertIn(want, report)
+        for unwanted in ("WANT_SPOT_WOODPECKER", "WANT_V4_ONLY", "WANT_RESTRICT_STATS"):
+            self.assertNotIn(unwanted, report)
diff --git a/tests/runner.c b/tests/runner.c
index dcb009c..97c6d51 100644
--- a/tests/runner.c
+++ b/tests/runner.c
@@ -28,6 +28,7 @@ static const struct module modules[] = {{"ot_urlencoded", test_urlencoded},
                                         {"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_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 7582dab..d7296cc 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -87,6 +87,7 @@ 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);
diff --git a/trackerlogic.h b/trackerlogic.h
index 53edabd..39afece 100644
--- a/trackerlogic.h
+++ b/trackerlogic.h
@@ -256,10 +256,6 @@ void workstruct_deinit(struct ot_workstruct *ws);
 #define WANT_SYNC_PARAM(param)
 #endif
 
-#ifdef WANT_LOG_NETWORKS
-#error Live logging networks disabled at the moment.
-#endif
-
 void   trackerlogic_init(void);
 void   trackerlogic_deinit(void);
 void   exerr(const char *message);