68 files changed, 365 insertions, 68 deletions

diff --git a/DESIGN b/DESIGN
index ff37706..f058fe0 100644
--- a/DESIGN
+++ b/DESIGN
@@ -16,7 +16,7 @@ A connection carries one request and closes. Keep-alive works and is rarely
 asked for.
 
 Statistics are approximate on purpose. Counters are per thread and summed
-when read, so a /stats read can under-report once. Nothing drifts.
+when read, so a /stats read can under-report once.
 
 
 Decisions
@@ -60,9 +60,44 @@ connections, the filter serves more requests than no filter, not fewer, so it
 is not the denial of service vector that FreeBSD-SA-02:26 once described.
 
 
+The torrent table is split into 2^OT_BUCKET_COUNT_BITS buckets, 1024 by
+default, set from the Makefile. Inserting a torrent opens a slot in a sorted
+vector, so the bytes moved grow with the bucket's occupancy. Insert cost per
+torrent, Linux:
+
+                2^10     2^12     2^14     2^16
+  200k        466 ns            439 ns
+  1M          834 ns   579 ns   529 ns
+  4M         2348 ns  1163 ns   770 ns   674 ns
+
+Re-announcing an existing torrent moves by under ten per cent over the same
+range, so the cost is paid while the torrent population is built and not in
+steady state. Below a few hundred thousand torrents there is nothing to win.
+2^14 captures most of the gain for two per cent more resident memory.
+
+The cleaner's wake rate does not follow the bucket count. A cap of ten wakes
+a second sets the sleep, and a wake cleans as many buckets as it must to
+finish a sweep in OT_CLEAN_INTERVAL_MINUTES. At the default bucket count that
+is one bucket every 117 ms.
+
+
 Paths not taken
 ---------------
 
+A keyed hash for the bucket index. Info hashes are SHA-1 output and already
+uniform, so it changes no distribution. It would buy resistance to deliberate
+bucket flooding and cost the ordering a full scrape depends on: buckets are
+ordered by hash prefix and sorted within, so walking them emits the sorted
+dictionary bencode wants, with no sort and no copy.
+
+Cache line padding for the per-bucket locks and vector headers. The
+contention it was meant to remove is not there. On glibc, where a 48-byte
+mutex straddles a line, padding gains 3 to 8 per cent, but gains as much at
+one thread where no false sharing can exist, and scaling from one to eight
+threads is identical either way. On FreeBSD, where eight 8-byte mutexes share
+a line and the risk should be highest, padding is 15 per cent slower at one
+thread and neutral to 6 per cent slower at four and eight.
+
 accf_http, the HTTP-aware accept filter. It duplicates a parser the tracker
 has anyway, puts more kernel code in the path, and holds a connection that
 sends "GET /" and stops, which accf_data hands straight over.
@@ -79,8 +114,6 @@ A directory for object files. bmake has no pattern rules and the Makefile
 builds under FreeBSD's make today. Building each binary in one invocation
 clears the objects out of the tree without giving that up.
 
-A src/ directory. 52 files sharing an ot_ prefix are a module list rather
-than clutter, and build output was most of what made the tree look crowded.
 
 
 Platform differences that cost us code
diff --git a/Makefile b/Makefile
index ddf1e05..d2e0c2d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,6 @@
-PREFIX?=..
+PREFIX?=/usr/local
 BINDIR?=$(PREFIX)/bin
+MANDIR?=$(PREFIX)/share/man
 STRIP?=strip
 
 #FEATURES+=-DWANT_V4_ONLY
@@ -19,6 +20,12 @@ STRIP?=strip
 #FEATURES+=-DWANT_DEV_RANDOM
 FEATURES+=-DWANT_FULLSCRAPE
 
+# Buckets the torrent table is split into, as a power of two, 8 to 16. More
+# buckets make inserting a new torrent cheaper and cost memory, which is worth
+# it for a tracker carrying millions of torrents and not for one carrying
+# thousands. DESIGN has the measurements.
+FEATURES+=-DOT_BUCKET_COUNT_BITS=10
+
 #FEATURES+=-D_DEBUG_HTTPERROR
 #FEATURES+=-D_DEBUG_RANDOMTORRENTS
 
@@ -33,7 +40,6 @@ include Mk/gzip.mk
 
 CFLAGS?=-O3
 
-# What the build requires, whatever you do to those.
 OT_CFLAGS+=-Wall -Wextra -Wwrite-strings -pipe -pthread
 OT_LDFLAGS+=-pthread
 
@@ -43,8 +49,8 @@ COMPILE=$(CPPFLAGS) $(OT_CFLAGS) $(FEATURES)
 LINK=$(LDFLAGS) $(OT_LDFLAGS) $(LDLIBS) $(OT_LDLIBS)
 
 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
+HEADERS=src/trackerlogic.h src/ot_urlencoded.h src/ot_batch.h src/ot_buf.h src/ot_event.h src/ot_fdstate.h src/ot_fmt.h src/ot_hex.h src/ot_ip.h src/ot_config.h src/ot_scan.h src/ot_socket.h src/ot_tcp.h src/ot_worker.h src/ot_workqueue.h src/ot_mutex.h src/ot_random.h src/ot_stats.h src/ot_vector.h src/ot_clean.h src/ot_udp.h src/ot_iovec.h src/ot_fullscrape.h src/ot_accesslist.h src/ot_http.h src/ot_livesync.h src/ot_rijndael.h
+SOURCES=src/opentracker.c src/trackerlogic.c src/ot_urlencoded.c src/ot_batch.c src/ot_buf.c src/ot_event.c src/ot_fdstate.c src/ot_fmt.c src/ot_hex.c src/ot_ip.c src/ot_config.c src/ot_scan.c src/ot_socket.c src/ot_tcp.c src/ot_worker.c src/ot_workqueue.c src/ot_mutex.c src/ot_random.c src/ot_stats.c src/ot_vector.c src/ot_clean.c src/ot_udp.c src/ot_iovec.c src/ot_fullscrape.c src/ot_accesslist.c src/ot_http.c src/ot_livesync.c src/ot_rijndael.c
 BINARIES=$(BINARY) $(BINARY).debug
 
 # Everything is built in one go from sources, so there are no object files to
@@ -67,10 +73,13 @@ $(BUILDSTAMP): FORCE
         @echo "$(CFLAGS) $(COMPILE) $(LINK)" | cmp -s - $@ 2>/dev/null || echo "$(CFLAGS) $(COMPILE) $(LINK)" > $@
 
 clean:
-        rm -rf $(BINARIES) $(BINARIES:=.dSYM) $(BUILDSTAMP) *.o *~
+        rm -rf $(BINARIES) $(BINARIES:=.dSYM) $(BUILDSTAMP) *.o *~ src/*.o src/*~
 
-install:
+install: $(BINARY)
+        install -d $(DESTDIR)$(BINDIR) $(DESTDIR)$(MANDIR)/man1 $(DESTDIR)$(MANDIR)/man5
         install -m 755 $(BINARY) $(DESTDIR)$(BINDIR)
+        install -m 644 man1/opentracker.1 $(DESTDIR)$(MANDIR)/man1
+        install -m 644 man5/opentracker.conf.5 $(DESTDIR)$(MANDIR)/man5
 
 FORCE:
 
diff --git a/Mk/proxy.mk b/Mk/proxy.mk
index 2e876e9..64d18dc 100644
--- a/Mk/proxy.mk
+++ b/Mk/proxy.mk
@@ -7,7 +7,7 @@
 # CFLAGS_libowfat=-I$(LIBOWFAT_HEADERS)
 # LDFLAGS_libowfat=-L$(LIBOWFAT_LIBRARY) -lowfat
 #
-# 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
+# SOURCES_proxy=src/proxy.c src/ot_batch.c src/ot_fdstate.c src/ot_vector.c src/ot_mutex.c src/ot_random.c src/ot_scan.c src/ot_ip.c src/ot_socket.c
 # CFLAGS_proxy=$(CFLAGS_production) $(CFLAGS_libowfat) -DWANT_SYNC_LIVE
 # CFLAGS_proxy_debug=$(CFLAGS_debug) $(CFLAGS_libowfat) -DWANT_SYNC_LIVE
 #
diff --git a/Mk/tests.mk b/Mk/tests.mk
index 8e63839..2efdd72 100644
--- a/Mk/tests.mk
+++ b/Mk/tests.mk
@@ -5,13 +5,13 @@ BUILDDEPS+=Mk/tests.mk
 # 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_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_UNITS=src/ot_urlencoded.c src/ot_fmt.c src/ot_event.c src/ot_batch.c src/ot_fdstate.c src/ot_buf.c src/ot_ip.c src/ot_socket.c src/ot_iovec.c src/ot_vector.c src/ot_random.c src/ot_hex.c src/ot_scan.c src/ot_accesslist.c src/ot_mutex.c src/ot_workqueue.c src/trackerlogic.c
 TEST_HEADERS=tests/test.h $(HEADERS)
 
 # A test binary is not a production binary, so it is built with the features
 # the tests need to reach.
 FEATURES_test=$(FEATURES) -DWANT_ACCESSLIST_BLACK -DWANT_SYNC_LIVE
-CFLAGS_test=-I. -g -O1 $(CPPFLAGS) $(OT_CFLAGS) $(FEATURES_test)
+CFLAGS_test=-Isrc -g -O1 $(CPPFLAGS) $(OT_CFLAGS) $(FEATURES_test)
 
 # clang over $(CC) because the two toolchains do not check the same things.
 CC_sanitize?=clang
@@ -29,7 +29,13 @@ LDFLAGS_integration=$(LINK) -fsanitize=address,undefined
 CFLAGS_tsan=$(OPTS_debug) $(CPPFLAGS) $(OT_CFLAGS) $(FEATURES_integration) -fsanitize=thread -fno-omit-frame-pointer
 LDFLAGS_tsan=$(LINK) -fsanitize=thread
 
-BINARIES+=$(TESTBIN) $(TESTBIN).poll $(TESTBIN).sanitize opentracker.integration opentracker.tsan
+# Live sync is a compile time feature, so reaching it from a black box test
+# needs a binary of its own. tests/integration/test_livesync.py skips itself
+# against a build without it, which is what -v is for.
+FEATURES_livesync=$(FEATURES_integration) -DWANT_SYNC_LIVE
+CFLAGS_livesync=$(OPTS_debug) $(CPPFLAGS) $(OT_CFLAGS) $(FEATURES_livesync) -fsanitize=address,undefined -fno-omit-frame-pointer
+
+BINARIES+=$(TESTBIN) $(TESTBIN).poll $(TESTBIN).sanitize opentracker.integration opentracker.tsan opentracker.livesync
 
 $(TESTBIN): $(TEST_SOURCES) $(TEST_UNITS) $(TEST_HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_test) $(TEST_SOURCES) $(TEST_UNITS)
@@ -46,6 +52,9 @@ opentracker.integration: $(SOURCES) $(HEADERS) $(BUILDDEPS)
 opentracker.tsan: $(SOURCES) $(HEADERS) $(BUILDDEPS)
         $(CC) -o $@ $(CFLAGS_tsan) $(SOURCES) $(LDFLAGS_tsan)
 
+opentracker.livesync: $(SOURCES) $(HEADERS) $(BUILDDEPS)
+        $(CC) -o $@ $(CFLAGS_livesync) $(SOURCES) $(LDFLAGS_integration)
+
 check: $(TESTBIN) $(BINARY)
         ./$(TESTBIN)
 
@@ -61,12 +70,18 @@ check-integration: opentracker.integration
 check-tsan: opentracker.tsan
         OPENTRACKER=./opentracker.tsan $(PYTHON) -m unittest discover -s tests/integration
 
+# The whole suite against a build that has live sync, which is also the only
+# way the live sync tests stop skipping.
+check-livesync: opentracker.livesync
+        OPENTRACKER=./opentracker.livesync $(PYTHON) -m unittest discover -s tests/integration
+
 # Cheapest first, so a quick failure comes back quickly.
 check-all:
         $(MAKE) check
         $(MAKE) check-poll
         $(MAKE) check-sanitize
         $(MAKE) check-integration
+        $(MAKE) check-livesync
         $(MAKE) check-tsan
 
-.PHONY: check check-poll check-sanitize check-integration check-tsan check-all
+.PHONY: check check-poll check-sanitize check-integration check-livesync check-tsan check-all
diff --git a/README_v6 b/README_v6
deleted file mode 100644
index 7fac79a..0000000
--- a/README_v6
+++ /dev/null
@@ -1 +0,0 @@
-IPv6 is implemented in opentracker now. You can chose whether your tracker runs in v4 or v6 mode in Makefile. YMMV.
diff --git a/opentracker.conf.sample b/opentracker.conf.sample
index 491c88a..3cd30dc 100644
--- a/opentracker.conf.sample
+++ b/opentracker.conf.sample
@@ -138,9 +138,11 @@
 # livesync.cluster.listen 192.168.0.1:9696
 #
 #      Note that two udp sockets will be opened. One on ip address 0.0.0.0
-#      port 9696, that will join the multicast group 224.0.42.23 for incoming
+#      port 9696, that will join the multicast group 224.0.23.5 for incoming
 #      udp packets and one on ip address 192.168.0.1 port 9696 for outgoing
-#      udp packets.
+#      udp packets. The group is the same for every opentracker, so a cluster
+#      is kept to itself by the node_ip list below and by the ttl of 1 that
+#      keeps packets on the local link.
 #
 #      As of now one and only one ip address must be given, if opentracker
 #      was built with the WANT_SYNC_LIVE feature.
diff --git a/ot_clean.h b/ot_clean.h
deleted file mode 100644
index e069ee0..0000000
--- a/ot_clean.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
-   It is considered beerware. Prost. Skol. Cheers or whatever. */
-
-#ifndef OT_CLEAN_H__
-#define OT_CLEAN_H__
-
-#include "trackerlogic.h"
-
-/* The amount of time a clean cycle should take */
-#define OT_CLEAN_INTERVAL_MINUTES 2
-
-/* So after each bucket wait 1 / OT_BUCKET_COUNT intervals */
-#define OT_CLEAN_SLEEP            (((OT_CLEAN_INTERVAL_MINUTES) * 60 * 1000000) / (OT_BUCKET_COUNT))
-
-void clean_init(void);
-void clean_deinit(void);
-int  clean_single_torrent(ot_torrent *torrent);
-
-#endif
diff --git a/opentracker.c b/src/opentracker.c
index 14b817e..60a6d8c 100644
--- a/opentracker.c
+++ b/src/opentracker.c
@@ -109,7 +109,7 @@ static void *server_mainloop(void *args) {
 
   (void)args;
 
-  if (workstruct_init(&ws) == -1)
+  if (workstruct_init(&ws, G_INBUF_SIZE) == -1)
     panic("Initializing worker failed");
 
   while (g_opentracker_running) {
diff --git a/ot_accesslist.c b/src/ot_accesslist.c
index 86f9a7d..86f9a7d 100644
--- a/ot_accesslist.c
+++ b/src/ot_accesslist.c
diff --git a/ot_accesslist.h b/src/ot_accesslist.h
index 68c88dc..68c88dc 100644
--- a/ot_accesslist.h
+++ b/src/ot_accesslist.h
diff --git a/ot_batch.c b/src/ot_batch.c
index e4dda0b..e4dda0b 100644
--- a/ot_batch.c
+++ b/src/ot_batch.c
diff --git a/ot_batch.h b/src/ot_batch.h
index 910bea7..910bea7 100644
--- a/ot_batch.h
+++ b/src/ot_batch.h
diff --git a/ot_buf.c b/src/ot_buf.c
index ecd3f8d..ecd3f8d 100644
--- a/ot_buf.c
+++ b/src/ot_buf.c
diff --git a/ot_buf.h b/src/ot_buf.h
index 7fb944e..7fb944e 100644
--- a/ot_buf.h
+++ b/src/ot_buf.h
diff --git a/ot_clean.c b/src/ot_clean.c
index e1d1971..f181e83 100644
--- a/ot_clean.c
+++ b/src/ot_clean.c
@@ -125,26 +125,34 @@ static void clean_sleep(void) {
   pthread_mutex_unlock(&g_clean_mutex);
 }
 
-/* Clean up all peers in current bucket, remove timedout pools and
- torrents */
+/* Clean up all peers in one bucket, remove timedout pools and torrents */
+static void clean_bucket(size_t bucket) {
+  ot_vector *torrents_list = mutex_bucket_lock((int)bucket);
+  size_t     toffs;
+  int        delta_torrentcount = 0;
+
+  for (toffs = 0; toffs < torrents_list->size; ++toffs) {
+    ot_torrent *torrent = ((ot_torrent *)(torrents_list->data)) + toffs;
+    if (clean_single_torrent(torrent)) {
+      vector_remove_torrent(torrents_list, torrent);
+      --delta_torrentcount;
+      --toffs;
+    }
+  }
+  mutex_bucket_unlock((int)bucket, delta_torrentcount);
+}
+
 static void *clean_worker(void *args) {
   (void)args;
   while (1) {
     size_t bucket = OT_BUCKET_COUNT;
-    while (bucket--) {
-      ot_vector *torrents_list = mutex_bucket_lock(bucket);
-      size_t     toffs;
-      int        delta_torrentcount = 0;
+    while (bucket) {
+      size_t todo = bucket < OT_CLEAN_BUCKETS_PER_WAKE ? bucket : OT_CLEAN_BUCKETS_PER_WAKE;
+
+      /* One bucket is locked at a time, however many a wake gets through */
+      while (todo--)
+        clean_bucket(--bucket);
 
-      for (toffs = 0; toffs < torrents_list->size; ++toffs) {
-        ot_torrent *torrent = ((ot_torrent *)(torrents_list->data)) + toffs;
-        if (clean_single_torrent(torrent)) {
-          vector_remove_torrent(torrents_list, torrent);
-          --delta_torrentcount;
-          --toffs;
-        }
-      }
-      mutex_bucket_unlock(bucket, delta_torrentcount);
       if (!g_opentracker_running)
         return NULL;
       clean_sleep();
diff --git a/src/ot_clean.h b/src/ot_clean.h
new file mode 100644
index 0000000..0592791
--- /dev/null
+++ b/src/ot_clean.h
@@ -0,0 +1,28 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+   It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+#ifndef OT_CLEAN_H__
+#define OT_CLEAN_H__
+
+#include "trackerlogic.h"
+
+/* The amount of time a clean cycle should take */
+#define OT_CLEAN_INTERVAL_MINUTES 2
+
+/* How often the cleaner may wake. A full sweep takes OT_CLEAN_INTERVAL_MINUTES.
+   The clean operations per wake is goverend by OT_BUCKET_COUNT_BITS,
+   set by the Makefile.
+   At the default of 1024 buckets this works out at one bucket every
+   117 ms. */
+#define OT_CLEAN_MAX_WAKES_PER_SECOND 10
+
+#define OT_CLEAN_WAKE_BUDGET      ((OT_CLEAN_INTERVAL_MINUTES) * 60 * (OT_CLEAN_MAX_WAKES_PER_SECOND))
+#define OT_CLEAN_BUCKETS_PER_WAKE (((OT_BUCKET_COUNT) + (OT_CLEAN_WAKE_BUDGET) - 1) / (OT_CLEAN_WAKE_BUDGET))
+#define OT_CLEAN_WAKES            ((OT_BUCKET_COUNT) / (OT_CLEAN_BUCKETS_PER_WAKE))
+#define OT_CLEAN_SLEEP            (((OT_CLEAN_INTERVAL_MINUTES) * 60 * 1000000) / (OT_CLEAN_WAKES))
+
+void clean_init(void);
+void clean_deinit(void);
+int  clean_single_torrent(ot_torrent *torrent);
+
+#endif
diff --git a/ot_config.c b/src/ot_config.c
index 95136b5..95136b5 100644
--- a/ot_config.c
+++ b/src/ot_config.c
diff --git a/ot_config.h b/src/ot_config.h
index 79187ee..79187ee 100644
--- a/ot_config.h
+++ b/src/ot_config.h
diff --git a/ot_event.c b/src/ot_event.c
index 6062f70..6062f70 100644
--- a/ot_event.c
+++ b/src/ot_event.c
diff --git a/ot_event.h b/src/ot_event.h
index cb84ca8..cb84ca8 100644
--- a/ot_event.h
+++ b/src/ot_event.h
diff --git a/ot_fdstate.c b/src/ot_fdstate.c
index 8e4bd89..8e4bd89 100644
--- a/ot_fdstate.c
+++ b/src/ot_fdstate.c
diff --git a/ot_fdstate.h b/src/ot_fdstate.h
index 60fe070..60fe070 100644
--- a/ot_fdstate.h
+++ b/src/ot_fdstate.h
diff --git a/ot_fmt.c b/src/ot_fmt.c
index 362c9b5..362c9b5 100644
--- a/ot_fmt.c
+++ b/src/ot_fmt.c
diff --git a/ot_fmt.h b/src/ot_fmt.h
index 214cbc4..214cbc4 100644
--- a/ot_fmt.h
+++ b/src/ot_fmt.h
diff --git a/ot_fullscrape.c b/src/ot_fullscrape.c
index 9afad92..9afad92 100644
--- a/ot_fullscrape.c
+++ b/src/ot_fullscrape.c
diff --git a/ot_fullscrape.h b/src/ot_fullscrape.h
index 8d11cd3..8d11cd3 100644
--- a/ot_fullscrape.h
+++ b/src/ot_fullscrape.h
diff --git a/ot_hex.c b/src/ot_hex.c
index b537094..b537094 100644
--- a/ot_hex.c
+++ b/src/ot_hex.c
diff --git a/ot_hex.h b/src/ot_hex.h
index ddbbb44..ddbbb44 100644
--- a/ot_hex.h
+++ b/src/ot_hex.h
diff --git a/ot_http.c b/src/ot_http.c
index 96b8f4e..96b8f4e 100644
--- a/ot_http.c
+++ b/src/ot_http.c
diff --git a/ot_http.h b/src/ot_http.h
index fb56c64..fb56c64 100644
--- a/ot_http.h
+++ b/src/ot_http.h
diff --git a/ot_iovec.c b/src/ot_iovec.c
index 328f160..328f160 100644
--- a/ot_iovec.c
+++ b/src/ot_iovec.c
diff --git a/ot_iovec.h b/src/ot_iovec.h
index 4a8abbb..4a8abbb 100644
--- a/ot_iovec.h
+++ b/src/ot_iovec.h
diff --git a/ot_ip.c b/src/ot_ip.c
index 9c76290..9c76290 100644
--- a/ot_ip.c
+++ b/src/ot_ip.c
diff --git a/ot_ip.h b/src/ot_ip.h
index 533403e..533403e 100644
--- a/ot_ip.h
+++ b/src/ot_ip.h
diff --git a/ot_livesync.c b/src/ot_livesync.c
index 083fe1a..11b75d2 100644
--- a/ot_livesync.c
+++ b/src/ot_livesync.c
@@ -4,6 +4,7 @@
 /* System */
 #include <arpa/inet.h>
 #include <pthread.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/socket.h>
@@ -22,6 +23,7 @@
 #ifdef WANT_SYNC_LIVE
 
 ot_ip6 groupip_1 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 224, 0, 23, 5};
+static uint16_t g_port = LIVESYNC_PORT;
 
 #define LIVESYNC_INCOMING_BUFFSIZE        (256 * 256)
 
@@ -59,7 +61,7 @@ void livesync_init(void) {
   uint32_t packet_type4 = htonl(OT_SYNC_PEER4);
 
   if (g_socket_in == -1)
-    exerr("No socket address for live sync specified.");
+    return;
 
   /* Prepare outgoing peers buffer */
   memcpy(g_v6_buf.data, &g_tracker_id, sizeof(g_tracker_id));
@@ -101,6 +103,8 @@ void livesync_bind_mcast(ot_ip6 ip, uint16_t port) {
   if (g_socket_in != -1)
     exerr("Error: Livesync listen ip specified twice.");
 
+  g_port = port;
+
   if ((g_socket_in = socket_mcast_join(groupip_1, ip, port)) == -1)
     exerr("Error: Cant bind live sync incoming socket.");
 
@@ -121,7 +125,7 @@ static void livesync_issue_peersync(sync_buffer *buf) {
      has modified the protected element */
   pthread_mutex_unlock(&g_outbuf_mutex);
 
-  socket_mcast_send(g_socket_out, mycopy, fill, groupip_1, LIVESYNC_PORT);
+  socket_mcast_send(g_socket_out, mycopy, fill, groupip_1, g_port);
 }
 
 static void livesync_handle_peersync(struct ot_workstruct *ws, size_t peer_size) {
@@ -159,6 +163,9 @@ static void livesync_handle_peersync(struct ot_workstruct *ws, size_t peer_size)
    stuck when there's not enough traffic to fill udp packets fast
    enough */
 void livesync_ticker(void) {
+  if (g_socket_out == -1)
+    return;
+
   /* livesync_issue_peersync sets g_next_packet_time */
   pthread_mutex_lock(&g_outbuf_mutex);
   if (time_now_seconds() > g_v6_buf.next_packet_time && g_v6_buf.fill > sizeof(g_tracker_id) + sizeof(uint32_t))
@@ -176,8 +183,14 @@ void livesync_ticker(void) {
 /* Inform live sync about whats going on. */
 void livesync_tell(struct ot_workstruct *ws) {
   size_t       peer_size; /* initialized in next line */
-  ot_peer     *peer_src = peer_from_peer6(&ws->peer, &peer_size);
-  sync_buffer *dest_buf = peer_size == OT_PEER_SIZE6 ? &g_v6_buf : &g_v4_buf;
+  ot_peer     *peer_src;
+  sync_buffer *dest_buf;
+
+  if (g_socket_out == -1)
+    return;
+
+  peer_src = peer_from_peer6(&ws->peer, &peer_size);
+  dest_buf = peer_size == OT_PEER_SIZE6 ? &g_v6_buf : &g_v4_buf;
 
   pthread_mutex_lock(&g_outbuf_mutex);
 
@@ -200,9 +213,12 @@ static void *livesync_worker(void *args) {
 
   (void)args;
 
-  /* Initialize our "thread local storage" */
-  ws.inbuf = ws.request = malloc(LIVESYNC_INCOMING_BUFFSIZE);
-  ws.outbuf = ws.reply = 0;
+  if (workstruct_init(&ws, LIVESYNC_INCOMING_BUFFSIZE) == -1) {
+    fprintf(stderr, "Warning: live sync could not get its buffers and will not run.\n");
+    atomic_store(&thread_left, 1);
+    return NULL;
+  }
+  ws.request = ws.inbuf;
 
   while (g_opentracker_running) {
     uint32_t packet_type;
@@ -233,7 +249,7 @@ static void *livesync_worker(void *args) {
     }
   }
 
-  free(ws.inbuf);
+  workstruct_deinit(&ws);
   atomic_store(&thread_left, 1);
   return NULL;
 }
diff --git a/ot_livesync.h b/src/ot_livesync.h
index 4bd3af0..d8d20b3 100644
--- a/ot_livesync.h
+++ b/src/ot_livesync.h
@@ -7,7 +7,8 @@
 #include "trackerlogic.h"
 
 /*
-  Syncing is done as udp packets in the multicast domain 224.0.42.5 port 9696
+  Syncing is done as udp packets in the multicast group 224.0.23.5, on the
+  port livesync.cluster.listen names, 9696 by default
 
   Each tracker should join the multicast group and send its live sync packets
   to that group, using a ttl of 1
diff --git a/ot_mutex.c b/src/ot_mutex.c
index 884b74c..884b74c 100644
--- a/ot_mutex.c
+++ b/src/ot_mutex.c
diff --git a/ot_mutex.h b/src/ot_mutex.h
index d7ded92..d7ded92 100644
--- a/ot_mutex.h
+++ b/src/ot_mutex.h
diff --git a/ot_random.c b/src/ot_random.c
index 43f91bb..43f91bb 100644
--- a/ot_random.c
+++ b/src/ot_random.c
diff --git a/ot_random.h b/src/ot_random.h
index c2d0387..c2d0387 100644
--- a/ot_random.h
+++ b/src/ot_random.h
diff --git a/ot_rijndael.c b/src/ot_rijndael.c
index 3f36bde..3f36bde 100644
--- a/ot_rijndael.c
+++ b/src/ot_rijndael.c
diff --git a/ot_rijndael.h b/src/ot_rijndael.h
index 1235215..1235215 100644
--- a/ot_rijndael.h
+++ b/src/ot_rijndael.h
diff --git a/ot_scan.c b/src/ot_scan.c
index 3b8e87c..3b8e87c 100644
--- a/ot_scan.c
+++ b/src/ot_scan.c
diff --git a/ot_scan.h b/src/ot_scan.h
index a79ec13..a79ec13 100644
--- a/ot_scan.h
+++ b/src/ot_scan.h
diff --git a/ot_socket.c b/src/ot_socket.c
index 79bb01a..79bb01a 100644
--- a/ot_socket.c
+++ b/src/ot_socket.c
diff --git a/ot_socket.h b/src/ot_socket.h
index 5c1d840..5c1d840 100644
--- a/ot_socket.h
+++ b/src/ot_socket.h
diff --git a/ot_stats.c b/src/ot_stats.c
index 2d6335b..2d6335b 100644
--- a/ot_stats.c
+++ b/src/ot_stats.c
diff --git a/ot_stats.h b/src/ot_stats.h
index 45a547e..45a547e 100644
--- a/ot_stats.h
+++ b/src/ot_stats.h
diff --git a/ot_tcp.c b/src/ot_tcp.c
index 1351b92..1351b92 100644
--- a/ot_tcp.c
+++ b/src/ot_tcp.c
diff --git a/ot_tcp.h b/src/ot_tcp.h
index afed142..afed142 100644
--- a/ot_tcp.h
+++ b/src/ot_tcp.h
diff --git a/ot_udp.c b/src/ot_udp.c
index 644b71d..644b71d 100644
--- a/ot_udp.c
+++ b/src/ot_udp.c
diff --git a/ot_udp.h b/src/ot_udp.h
index 2710744..2710744 100644
--- a/ot_udp.h
+++ b/src/ot_udp.h
diff --git a/ot_urlencoded.c b/src/ot_urlencoded.c
index 4109bb5..4109bb5 100644
--- a/ot_urlencoded.c
+++ b/src/ot_urlencoded.c
diff --git a/ot_urlencoded.h b/src/ot_urlencoded.h
index 9882468..9882468 100644
--- a/ot_urlencoded.h
+++ b/src/ot_urlencoded.h
diff --git a/ot_vector.c b/src/ot_vector.c
index ab0566c..ab0566c 100644
--- a/ot_vector.c
+++ b/src/ot_vector.c
diff --git a/ot_vector.h b/src/ot_vector.h
index 8a5ba86..8a5ba86 100644
--- a/ot_vector.h
+++ b/src/ot_vector.h
diff --git a/ot_worker.c b/src/ot_worker.c
index 432d272..ef50945 100644
--- a/ot_worker.c
+++ b/src/ot_worker.c
@@ -20,7 +20,7 @@ static size_t             g_worker_count;
 static void *worker_trampoline(void *args) {
   struct ot_worker *me = args;
 
-  if (workstruct_init(&me->ws) == -1)
+  if (workstruct_init(&me->ws, G_INBUF_SIZE) == -1)
     fprintf(stderr, "Warning: a worker could not get its buffers and will not run.\n");
   else {
     me->run(me);
diff --git a/ot_worker.h b/src/ot_worker.h
index 4954773..4954773 100644
--- a/ot_worker.h
+++ b/src/ot_worker.h
diff --git a/ot_workqueue.c b/src/ot_workqueue.c
index 56a7cd2..56a7cd2 100644
--- a/ot_workqueue.c
+++ b/src/ot_workqueue.c
diff --git a/ot_workqueue.h b/src/ot_workqueue.h
index 82ae29b..82ae29b 100644
--- a/ot_workqueue.h
+++ b/src/ot_workqueue.h
diff --git a/proxy.c b/src/proxy.c
index 8589db5..8589db5 100644
--- a/proxy.c
+++ b/src/proxy.c
diff --git a/trackerlogic.c b/src/trackerlogic.c
index 9565090..8e30a48 100644
--- a/trackerlogic.c
+++ b/src/trackerlogic.c
@@ -567,9 +567,11 @@ void trackerlogic_init(void) {
   stats_init();
 }
 
-int workstruct_init(struct ot_workstruct *ws) {
+/* Live sync reads whole packets rather than requests and wants a larger
+   inbuf than the request path does, hence the size. */
+int workstruct_init(struct ot_workstruct *ws, size_t inbuf_size) {
   memset(ws, 0, sizeof(*ws));
-  ws->inbuf  = malloc(G_INBUF_SIZE);
+  ws->inbuf  = malloc(inbuf_size);
   ws->outbuf = malloc(G_OUTBUF_SIZE);
 #ifdef _DEBUG_HTTPERROR
   ws->debugbuf = malloc(G_DEBUGBUF_SIZE);
diff --git a/trackerlogic.h b/src/trackerlogic.h
index 338e4e6..692b6af 100644
--- a/trackerlogic.h
+++ b/src/trackerlogic.h
@@ -62,7 +62,12 @@ typedef struct {
 
 /* We maintain a list of 1024 pointers to sorted list of ot_torrent structs
  Sort key is, of course, its hash */
+/* Set from the Makefile, 8 to 16. More buckets means shorter vectors and a
+   cheaper insert, which only pays for a tracker carrying millions of
+   torrents; see DESIGN. */
+#ifndef OT_BUCKET_COUNT_BITS
 #define OT_BUCKET_COUNT_BITS          10
+#endif
 
 #define OT_BUCKET_COUNT               (1 << OT_BUCKET_COUNT_BITS)
 #define OT_BUCKET_COUNT_SHIFT         (32 - OT_BUCKET_COUNT_BITS)
@@ -237,7 +242,7 @@ struct ot_workstruct {
 /* Everything a thread that serves requests needs for itself. Set up and torn
    down in one place so that a new kind of worker cannot miss a piece.
    Returns -1 if the buffers could not be had. */
-int  workstruct_init(struct ot_workstruct *ws);
+int  workstruct_init(struct ot_workstruct *ws, size_t inbuf_size);
 void workstruct_deinit(struct ot_workstruct *ws);
 
 /*
diff --git a/tests/integration/harness.py b/tests/integration/harness.py
index b98ce83..a9d38ca 100644
--- a/tests/integration/harness.py
+++ b/tests/integration/harness.py
@@ -20,6 +20,9 @@ import urllib.error
 import urllib.parse
 import urllib.request
 
+# groupip_1 in src/ot_livesync.c
+LIVESYNC_GROUP = "224.0.23.5"
+
 TRACKER = os.environ.get("OPENTRACKER", os.path.join(os.path.dirname(__file__), "..", "..", "opentracker.debug"))
 
 
@@ -76,6 +79,9 @@ class Tracker:
 
     def __init__(self, extra_config="", files=None):
         self.port = free_port()
+        # Only used by a config that asks for live sync, but allocated either
+        # way so {livesync_port} always resolves.
+        self.livesync_port = free_port()
         self.dir = tempfile.mkdtemp(prefix="ot-integration-")
         self.log = None
         self.process = None
@@ -87,7 +93,7 @@ class Tracker:
             with open(self.config, "w") as handle:
                 handle.write("listen.tcp 127.0.0.1:%d\n" % self.port)
                 handle.write("listen.udp 127.0.0.1:%d\n" % self.port)
-                handle.write(extra_config.replace("{dir}", self.dir))
+                handle.write(extra_config.replace("{dir}", self.dir).replace("{livesync_port}", str(self.livesync_port)))
             self.log = open(os.path.join(self.dir, "tracker.log"), "w+b")
             # Leak detection is left at the sanitizer's own default, which is on
             # where LeakSanitizer exists and off where it does not. Asking for it
@@ -186,6 +192,32 @@ class Tracker:
     def torrent_count(self):
         return int(self.stats("torr").split()[0])
 
+    def livesync_send(self, payload):
+        """Put a packet on the live sync group.
+
+        It has to go to the group rather than straight at the port: the
+        tracker binds two sockets there, the reader on the wildcard address
+        and the writer on the configured one, and the kernel gives a unicast
+        datagram to the more specific of the two, which nobody reads."""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton("127.0.0.1"))
+            sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)
+            sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 1)
+            sock.sendto(payload, (LIVESYNC_GROUP, self.livesync_port))
+        finally:
+            sock.close()
+
+    def wait_until(self, predicate, timeout=5):
+        """A live sync packet is handled by another thread, so an effect of
+        one arrives some time after the send."""
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if predicate():
+                return True
+            time.sleep(0.02)
+        return predicate()
+
     # ------------------------------------------------------------ over udp
 
     def udp_connect(self):
diff --git a/tests/integration/test_livesync.py b/tests/integration/test_livesync.py
new file mode 100644
index 0000000..3a9ee58
--- /dev/null
+++ b/tests/integration/test_livesync.py
@@ -0,0 +1,166 @@
+"""Live sync, driven over the multicast group a cluster would use.
+
+Live sync sits behind WANT_SYNC_LIVE, so these only run against a binary
+built with it: make check-livesync. Against any other build they skip, which
+is what the feature list in -v is for.
+"""
+
+import socket
+import struct
+import subprocess
+import unittest
+
+from harness import TRACKER, TrackerTestCase
+
+# enum { OT_SYNC_PEER4, OT_SYNC_PEER6 } in src/ot_livesync.c
+SYNC_PEER4 = 0
+SYNC_PEER6 = 1
+
+# src/trackerlogic.h
+FLAG_SEEDING = 0x80
+FLAG_COMPLETED = 0x40
+FLAG_STOPPED = 0x20
+
+
+def has_livesync():
+    done = subprocess.run([TRACKER, "-v"], capture_output=True, timeout=30)
+    return b"WANT_SYNC_LIVE" in done.stderr
+
+
+def peer4(address, port, flags):
+    """Four bytes of address, two of port, one of flags, one the tracker
+    overwrites with its own idea of the time."""
+    return socket.inet_aton(address) + struct.pack("!H", port) + bytes([flags, 0])
+
+
+def peer6(address, port, flags):
+    return socket.inet_pton(socket.AF_INET6, address) + struct.pack("!H", port) + bytes([flags, 0])
+
+
+def packet(kind, entries, tracker_id=0xDEADBEEF):
+    body = b"".join(info_hash + peer for info_hash, peer in entries)
+    return struct.pack("!I", tracker_id) + struct.pack("!I", kind) + body
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncIn(TrackerTestCase):
+    config = "livesync.cluster.listen 127.0.0.1:{livesync_port}\nlivesync.cluster.node_ip 127.0.0.1\n"
+
+    def counts(self, info_hash):
+        """Seeders and leechers a scrape reports for one torrent."""
+        files = self.tracker.scrape(info_hash)[b"files"]
+        if info_hash not in files:
+            return None
+        entry = files[info_hash]
+        return entry[b"complete"], entry[b"incomplete"]
+
+    def test_a_synced_seeder_arrives(self):
+        info_hash = self.hash_for("sync-seed")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.2.3", 6881, FLAG_SEEDING))]))
+        self.assertTrue(self.tracker.wait_until(lambda: self.counts(info_hash) == (1, 0)),
+                        "scrape says %r" % (self.counts(info_hash),))
+
+    def test_a_synced_leecher_arrives(self):
+        info_hash = self.hash_for("sync-leech")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.2.4", 6881, 0))]))
+        self.assertTrue(self.tracker.wait_until(lambda: self.counts(info_hash) == (0, 1)),
+                        "scrape says %r" % (self.counts(info_hash),))
+
+    def test_a_v6_peer_arrives(self):
+        info_hash = self.hash_for("sync-v6")
+        self.tracker.livesync_send(packet(SYNC_PEER6, [(info_hash, peer6("2001:db8::1", 6881, FLAG_SEEDING))]))
+        self.assertTrue(self.tracker.wait_until(lambda: self.counts(info_hash) == (1, 0)),
+                        "scrape says %r" % (self.counts(info_hash),))
+
+    def test_one_packet_carries_several_torrents(self):
+        hashes = [self.hash_for("sync-many-%d" % i) for i in range(4)]
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(h, peer4("10.1.2.%d" % (5 + i), 6881, FLAG_SEEDING))
+                                                       for i, h in enumerate(hashes)]))
+        self.assertTrue(self.tracker.wait_until(lambda: all(self.counts(h) == (1, 0) for h in hashes)))
+
+    def test_a_stopped_peer_is_taken_away_again(self):
+        info_hash = self.hash_for("sync-stop")
+        peer = peer4("10.1.2.9", 6881, FLAG_SEEDING)
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer)]))
+        self.assertTrue(self.tracker.wait_until(lambda: self.counts(info_hash) == (1, 0)))
+
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.2.9", 6881, FLAG_STOPPED))]))
+        self.assertTrue(self.tracker.wait_until(lambda: self.counts(info_hash) in (None, (0, 0))),
+                        "scrape still says %r" % (self.counts(info_hash),))
+
+    def test_a_truncated_entry_is_dropped(self):
+        """The loop takes whole hash and peer pairs and leaves a short tail
+        where it is, so the complete entry before it still lands."""
+        good, short = self.hash_for("sync-good"), self.hash_for("sync-short")
+        payload = packet(SYNC_PEER4, [(good, peer4("10.1.2.10", 6881, FLAG_SEEDING))]) + short + b"\x0a\x01"
+        self.tracker.livesync_send(payload)
+        self.assertTrue(self.tracker.wait_until(lambda: self.counts(good) == (1, 0)))
+        self.assertIsNone(self.counts(short))
+
+    def test_an_unknown_packet_type_is_ignored(self):
+        info_hash = self.hash_for("sync-unknown")
+        self.tracker.livesync_send(packet(99, [(info_hash, peer4("10.1.2.11", 6881, FLAG_SEEDING))]))
+        self.assertFalse(self.tracker.wait_until(lambda: self.counts(info_hash) is not None, timeout=1))
+
+    def test_synced_peers_are_counted(self):
+        """The live sync worker keeps its own tally like every other worker,
+        and ?mode=syncs is the sum of them."""
+        before = int(self.tracker.stats("syncs").split()[0])
+        hashes = [self.hash_for("sync-count-%d" % i) for i in range(3)]
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(h, peer4("10.1.2.%d" % (20 + i), 6881, FLAG_SEEDING))
+                                                       for i, h in enumerate(hashes)]))
+        self.assertTrue(self.tracker.wait_until(
+            lambda: int(self.tracker.stats("syncs").split()[0]) == before + 3),
+            "syncs says %s" % self.tracker.stats("syncs").split()[0])
+
+    def test_a_packet_with_nothing_but_a_header_is_ignored(self):
+        before = self.tracker.torrent_count()
+        self.tracker.livesync_send(struct.pack("!I", 0xDEADBEEF) + struct.pack("!I", SYNC_PEER4))
+        self.assertFalse(self.tracker.wait_until(lambda: self.tracker.torrent_count() != before, timeout=1))
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncAccess(TrackerTestCase):
+    """Nothing blesses 127.0.0.1 here, so the tracker should take nothing
+    from it. Source address checking is all live sync has."""
+
+    config = "livesync.cluster.listen 127.0.0.1:{livesync_port}\nlivesync.cluster.node_ip 10.0.0.1\n"
+
+    def test_an_unblessed_sender_is_ignored(self):
+        info_hash = self.hash_for("sync-unblessed")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.2.12", 6881, FLAG_SEEDING))]))
+        self.assertFalse(self.tracker.wait_until(lambda: self.tracker.torrent_count() != 0, timeout=1))
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncUnconfigured(TrackerTestCase):
+    """A binary that has the feature but no cluster to join. Somebody whose
+    packager turned WANT_SYNC_LIVE on did not ask for live sync and should
+    not be able to tell that it is there."""
+
+    config = ""
+
+    def test_the_tracker_runs_anyway(self):
+        info_hash = self.hash_for("no-cluster")
+        self.tracker.announce(info_hash, port=6881, left=0)
+        self.assertEqual(self.tracker.torrent_count(), 1)
+
+    def test_nothing_is_said_about_the_missing_cluster(self):
+        self.assertNotIn("sync", self.tracker.output().lower())
+
+    def test_no_socket_is_bound_for_it(self):
+        """A configured tracker holds the wildcard address on that port, so
+        taking it here proves nothing was started."""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            sock.bind(("0.0.0.0", self.tracker.livesync_port))
+        finally:
+            sock.close()
+
+    def test_announcing_stays_clean(self):
+        """Enough announces to pass the watermark that would flush an
+        outgoing buffer, if there were one to flush. The sanitizers in this
+        build turn anything the attempt touched into a failure."""
+        for i in range(200):
+            self.tracker.announce(self.hash_for("no-cluster-%d" % i), port=6881 + i, left=0)
+        self.assertEqual(self.tracker.torrent_count(), 200)
diff --git a/sync_daemon.pl b/tests/sync_daemon.pl
index 9e4bdb9..9e4bdb9 100644
--- a/sync_daemon.pl
+++ b/tests/sync_daemon.pl
diff --git a/tests/t_mutex.c b/tests/t_mutex.c
index e54e2fa..c0c41cc 100644
--- a/tests/t_mutex.c
+++ b/tests/t_mutex.c
@@ -24,7 +24,7 @@ static void hash_for_bucket(ot_hash hash, int bucket) {
 }
 
 static void case_a_hash_names_its_bucket(void) {
-  static const int buckets[] = {0, 1, 2, 17, 511, 512, OT_BUCKET_COUNT - 1};
+  static const int buckets[] = {0, 1, 2, 17, OT_BUCKET_COUNT / 2 - 1, OT_BUCKET_COUNT / 2, OT_BUCKET_COUNT - 1};
   size_t           i;
 
   test_case("a hash is served by the bucket its leading bits name");
diff --git a/tests/t_trackerlogic.c b/tests/t_trackerlogic.c
index f64977f..1cf9141 100644
--- a/tests/t_trackerlogic.c
+++ b/tests/t_trackerlogic.c
@@ -224,7 +224,7 @@ void test_trackerlogic(void) {
   pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
 
   trackerlogic_init();
-  CHECK_INT(workstruct_init(&ws), 0);
+  CHECK_INT(workstruct_init(&ws, G_INBUF_SIZE), 0);
 
   case_an_announce_makes_a_torrent();
   case_the_same_peer_twice_is_one_peer();