5 files changed, 537 insertions, 3 deletions

diff --git a/tests/integration/harness.py b/tests/integration/harness.py
index b98ce83..10aa6de 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, group=LIVESYNC_GROUP):
+        """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, (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..52e871f
--- /dev/null
+++ b/tests/integration/test_livesync.py
@@ -0,0 +1,208 @@
+"""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)
+
+
+# RFC 2365 sets 239.192.0.0/14 aside for exactly this kind of use
+OWN_GROUP = "239.192.0.7"
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncGroup(TrackerTestCase):
+    config = ("livesync.cluster.group %s\n"
+              "livesync.cluster.listen 127.0.0.1:{livesync_port}\n"
+              "livesync.cluster.node_ip 127.0.0.1\n" % OWN_GROUP)
+
+    def test_the_configured_group_is_joined(self):
+        info_hash = self.hash_for("own-group")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.3.1", 6881, FLAG_SEEDING))]),
+                                   group=OWN_GROUP)
+        self.assertTrue(self.tracker.wait_until(lambda: self.tracker.torrent_count() == 1))
+
+    def test_the_default_group_is_left_alone(self):
+        """A cluster that picked its own group should not hear the one every
+        other opentracker is on."""
+        info_hash = self.hash_for("not-our-group")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.3.2", 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 LiveSyncGroupRefused(TrackerTestCase):
+    """A unicast address is not a group. The line is refused like any other
+    bad config line, which leaves the default standing."""
+
+    config = ("livesync.cluster.group 10.0.0.1\n"
+              "livesync.cluster.listen 127.0.0.1:{livesync_port}\n"
+              "livesync.cluster.node_ip 127.0.0.1\n")
+
+    def test_the_line_is_refused(self):
+        self.assertIn("Parse error", self.tracker.output())
+
+    def test_and_the_default_group_still_works(self):
+        info_hash = self.hash_for("fallback-group")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.3.3", 6881, FLAG_SEEDING))]))
+        self.assertTrue(self.tracker.wait_until(lambda: self.tracker.torrent_count() == 1))
diff --git a/tests/sync_daemon.pl b/tests/sync_daemon.pl
new file mode 100644
index 0000000..9e4bdb9
--- /dev/null
+++ b/tests/sync_daemon.pl
@@ -0,0 +1,294 @@
+#!/usr/bin/perl
+
+# This software was written by Philipp Wuensche <cryx-otsync@h3q.com>
+# It is considered beerware.
+
+use strict;
+
+#use Convert::Bencode_XS qw(:all);
+use Convert::Bencode qw(:all);
+use Data::Dumper;
+use LWP::UserAgent;
+use URI::Escape;
+
+# enable verbose output
+my $debug = 0;
+
+# tracker from where we get our sync data
+my @trackers = ('127.0.0.1:8989');
+# tracker to upload merged data
+my @client_tracker = ('127.0.0.1:8989');
+
+# time to wait between syncs
+my $sleeptime = '300';
+
+# SSL cert and key
+my $ssl_cert = 'cert.pem';
+my $ssl_key = 'key.pem';
+
+foreach(@trackers) {
+        print "Syncing from: $_\n";
+}
+foreach(@client_tracker) {
+        print "Syncing to: $_\n";
+}
+
+my $file = shift;
+
+
+# global hash for storing the merged syncs
+my %merged_syncs;
+
+while(1) {
+        %merged_syncs;
+        my @bencoded_sync_data;
+
+        # fetch the sync from every tracker and put it into an array in bencoded form
+        foreach my $tracker (@trackers) {
+                my $bencoded_sync = fetch_sync($tracker);
+#               my $bencoded_sync = fetch_sync_from_file($file);
+                if($bencoded_sync ne 0 && $bencoded_sync =~ /^d4\:sync/) {
+                        push(@bencoded_sync_data,$bencoded_sync);
+                }
+        }
+
+        # bdecode every sync and throw it into the merged-sync
+        foreach my $bencoded_sync (@bencoded_sync_data) {
+                print "Doing merge...\n";
+                merge_sync(bdecode($bencoded_sync));
+                my $num_torrents = keys(%merged_syncs);
+
+                print "number of torrents: $num_torrents\n";
+        }
+
+        # number of max. peers in one changeset
+        my $peer_limit = 500;
+        # max number of changesets per commit
+        my $max_changesets = 10;
+        my $hash_count = 0;
+        my $peer_count = 0;
+        my $changeset;
+        my @escaped_changesets;
+
+        # run until all hashes are put into changesets and commited to the trackers
+        while(keys(%merged_syncs) != 0) {
+
+                foreach my $hash (keys(%merged_syncs)) {
+                        print "Starting new changeset\n" if($peer_count == 0 && $debug);
+                        my $num_peers = keys(%{$merged_syncs{$hash}});
+
+                        print "\t$peer_count peers for $hash_count hashes in changeset\n" if($debug);
+
+                        my $pack_hash = pack('H*',$hash);
+
+                        # as long as the peer_limit is not reached, add new hashes with peers to the changeset hash-table
+                        if($peer_count < $peer_limit) {
+                                print "\t\tAdd $num_peers peers for $hash changeset\n" if($debug);
+                                $peer_count = $peer_count + $num_peers;
+                                foreach my $peer_socket (keys(%{$merged_syncs{$hash}})) {
+
+                                        my $flags = $merged_syncs{$hash}{$peer_socket};
+
+                                        print "\t\t\tAdd $peer_socket $flags\n" if($debug);
+
+                                        my $pack_peer = packme($peer_socket,$flags);
+
+                                        $changeset->{'sync'}->{$pack_hash} = $changeset->{'sync'}->{$pack_hash}.$pack_peer;
+                                }
+                                $hash_count++;
+                                # hash is stored in the changeset, delete it from the hash-table
+                                delete $merged_syncs{$hash};
+                        }
+
+                        # the peer_limit is reached or we are out of torrents, so start preparing a changeset
+                        if($peer_count >= $peer_limit || keys(%merged_syncs) == 0) {
+
+                                print "Commit changeset for $hash_count hashes with $peer_count peers total\n" if($debug);
+
+                                # bencode the changeset
+                                my $enc_changeset = bencode($changeset);
+
+                                # URL-escape the changeset and put into an array of changesets
+                                my $foobar = uri_escape($enc_changeset);
+                                push(@escaped_changesets,$foobar);
+
+                                # the changeset is ready and stored, so delete it from the changeset hash-table
+                                delete $changeset->{'sync'};
+
+                                $hash_count = 0;
+                                $peer_count = 0;
+                                print "\n\n\n" if($debug);
+                        }
+
+                        # if enought changesets are prepared or we are out of torrents for more changesets,
+                        # sync the changesets to the trackers
+                        if($#escaped_changesets == $max_changesets || keys(%merged_syncs) == 0) {
+                                print "\tSync...\n";
+                                sync_to_tracker(\@escaped_changesets);
+                                undef @escaped_changesets;
+                        }
+
+                }
+        }
+
+        print "Sleeping for $sleeptime seconds\n";
+        sleep $sleeptime;
+}
+
+sub connect_tracker {
+        # connect a tracker via HTTPS, returns the body of the response
+        my $url = shift;
+
+        $ENV{HTTPS_DEBUG} = 0;
+        $ENV{HTTPS_CERT_FILE} = $ssl_cert;
+        $ENV{HTTPS_KEY_FILE}  = $ssl_key;
+
+        my $ua = new LWP::UserAgent;
+        my $req = new HTTP::Request('GET', $url);
+        my $res = $ua->request($req);
+
+        my $content = $res->content;
+
+        if($res->is_success()) {
+                return $content;
+        } else {
+                print $res->code."|".$res->status_line."\n";
+                return 0;
+        }
+}
+
+sub sync_to_tracker {
+        # commit changesets to a tracker
+        my @changesets = @{(shift)};
+
+        # prepare the URI with URL-encoded changesets concatenated by a &
+        my $uri = 'sync?';
+        foreach my $set (@changesets) {
+                $uri .= 'changeset='.$set.'&';
+        }
+        my $uri_length = length($uri);
+
+        # commit the collection of changesets to the tracker via HTTPS
+        foreach my $tracker (@client_tracker) {
+                print "\t\tTracker: $tracker (URI: $uri_length)\n";
+                my $url = "https://$tracker/".$uri;
+                connect_tracker($url);
+        }
+}
+
+sub packme {
+        # pack data
+        # returns ipaddr, port and flags in packed format
+        my $peer_socket = shift;
+        my $flags = shift;
+
+        my($a,$b,$c,$d,$port) = split(/[\.,\:]/,$peer_socket);
+        my $pack_peer = pack('C4 n1 b16',$a,$b,$c,$d,$port,$flags);
+
+        return $pack_peer;
+}
+
+sub unpackme {
+        # unpack packed data
+        # returns ipaddr. in quad-form with port (a.b.c.d:port) and flags as bitfield
+        # data is packed as:
+        # - 4 byte ipaddr. (unsigned char value)
+        # - 2 byte port (unsigned short in "network" (big-endian) order)
+        # - 2 byte flags (bit string (ascending bit order inside each byte))
+        my $data = shift;
+
+        my($a, $b, $c, $d, $port, $flags) = unpack('C4 n1 b16',$data);
+        my $peer_socket = "$a\.$b\.$c\.$d\:$port";
+
+        return($peer_socket,$flags);
+}
+
+sub fetch_sync {
+        # fetch sync from a tracker
+        my $tracker = shift;
+        my $url = "https://$tracker/sync";
+
+        print "Fetching from $url\n";
+
+        my $body = connect_tracker($url);
+
+        if($body && $body =~ /^d4\:sync/) {
+                return $body;
+        } else {
+                return 0;
+        }
+}
+
+sub fetch_sync_from_file {
+        # fetch sync from a file
+        my $file = shift;
+        my $body;
+        print "Fetching from file $file\n";
+        open(FILE,"<$file");
+        while(<FILE>) {
+                $body .= $_;
+        }
+        close(FILE);
+        return $body;
+}
+
+sub merge_sync {
+        # This builds a hash table with the torrenthash as keys. The value is a hash table again with the peer-socket as keys
+        # and flags in the value
+        # Example:
+        # 60dd2beb4197f71677c0f5ba92b956f7d04651e5 =>
+        #       192.168.23.23:2323 => 0000000000000000
+        #       23.23.23.23:2342 => 0000000100000000
+        # b220b4d7136e84a88abc090db88bec8604a808f3 =>
+        #       42.23.42.23:55555 => 0000000000000000
+
+        my $hashref = shift;
+ 
+        my $nonuniq_hash_counter = 0;
+        my $nonuniq_peer_counter = 0;
+        my $hash_counter = 0;
+        my $peer_counter = 0;
+
+        foreach my $key (keys(%{$hashref->{'sync'}})) {
+                # start merge for every sha1-hash in the sync
+                my $hash = unpack('H*',$key);
+
+                $hash_counter++;
+                $nonuniq_hash_counter++ if exists $merged_syncs{$hash};
+
+                while(${$hashref->{'sync'}}{$key} ne "")
+                {
+                        # split the value into 8-byte and unpack it for getting peer-socket and flags
+                        my($peer_socket,$flags) = unpackme(substr(${$hashref->{'sync'}}{$key},0,8,''));
+
+                        $peer_counter++;
+                        $nonuniq_peer_counter++ if exists $merged_syncs{$hash}{$peer_socket};
+
+                        # Create a hash table with sha1-hash as key and a hash table as value.
+                        # The hash table in the value has the peer-socket as key and flags as value
+                        # If the entry already exists, the flags are ORed together, if not it is ORed with 0
+                        $merged_syncs{$hash}{$peer_socket} = $flags | $merged_syncs{$hash}{$peer_socket};
+                }
+        }
+        print "$hash_counter hashes $nonuniq_hash_counter non-uniq, $peer_counter peers $nonuniq_peer_counter non-uniq.\n";
+
+}
+
+sub test_decode {
+        my $hashref = shift;
+
+        print "CHANGESET DEBUG OUTPUT\n";
+
+        print Dumper $hashref;
+        foreach my $key (keys(%{$hashref->{'sync'}})) {
+                my $hash = unpack('H*',$key);
+
+                print "Changeset for $hash\n";
+                while(${$hashref->{'sync'}}{$key} ne "")
+                {
+
+                        my($peer_socket,$flags) = unpackme(substr(${$hashref->{'sync'}}{$key},0,8,''));
+                        print "\tSocket: $peer_socket Flags: $flags\n";
+                }
+        }
+}
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();