1 files changed, 35 insertions, 29 deletions

diff --git a/src/ot_clean.c b/src/ot_clean.c
index 9e2186f..130bd2a 100644
--- a/src/ot_clean.c
+++ b/src/ot_clean.c
@@ -51,51 +51,48 @@ static ssize_t clean_single_bucket(ot_peer *peers, size_t peer_count, size_t pee
   return (peers - insert_point) / peer_size;
 }
 
-/* Age one family's peers by timedout minutes. Frees the list and clears the
-   slot once its last peer is gone, so an absent family costs nothing. */
-static void clean_peer_list_family(ot_peerlist **slot, size_t peer_size, ot_time timedout) {
-  ot_peerlist *peer_list = *slot;
-  ot_vector   *peer_vector;
-  size_t       num_buckets = 1, removed_seeders = 0;
+/* Age one family's peers by timedout minutes. Releases and zeroes the vector
+   once its last peer is gone, so an empty family costs nothing. */
+static void clean_family_vector(ot_vector *peer_vector, size_t peer_size, ot_time timedout, size_t *removed_seeders) {
+  ot_vector *bucket = peer_vector;
+  size_t     num_buckets = 1, peer_count;
 
-  if (!peer_list)
-    return;
-
-  peer_vector = &peer_list->peers;
-  if (OT_PEERLIST_HASBUCKETS(peer_list)) {
+  if (OT_VECTOR_HASBUCKETS(peer_vector)) {
     num_buckets = peer_vector->size;
-    peer_vector = (ot_vector *)peer_vector->data;
+    bucket      = (ot_vector *)peer_vector->data;
   }
 
   while (num_buckets--) {
-    size_t removed_peers   = clean_single_bucket(peer_vector->data, peer_vector->size, peer_size, timedout, &removed_seeders);
-    peer_list->peer_count -= removed_peers;
-    peer_vector->size     -= removed_peers;
+    size_t removed_peers = clean_single_bucket(bucket->data, bucket->size, peer_size, timedout, removed_seeders);
+    bucket->size        -= removed_peers;
     if (removed_peers)
-      vector_fixup_peers(peer_vector, peer_size);
+      vector_fixup_peers(bucket, peer_size);
 
     /* Skip to next bucket, a vector containing peers */
-    ++peer_vector;
+    ++bucket;
   }
 
-  peer_list->seed_count -= removed_seeders;
+  peer_count = vector_peer_count(peer_vector);
 
-  if (!peer_list->peer_count) {
-    free_peerlist(peer_list);
-    *slot = NULL;
+  /* Run dry: release the family (a collapsed bucket list or a plain vector) */
+  if (!peer_count) {
+    free_peer_vector(peer_vector);
+    memset(peer_vector, 0, sizeof(*peer_vector));
     return;
   }
 
-  /* See if we need to convert the list from simple vector to bucket list */
-  if ((peer_list->peer_count > OT_PEER_BUCKET_MINCOUNT) || OT_PEERLIST_HASBUCKETS(peer_list))
-    vector_redistribute_buckets(peer_list, peer_size);
+  /* See if we need to convert the vector from simple to bucket list or back */
+  if ((peer_count > OT_PEER_BUCKET_MINCOUNT) || OT_VECTOR_HASBUCKETS(peer_vector))
+    vector_redistribute_buckets(peer_vector, peer_size, peer_count);
 }
 
 /* Clean a single torrent
    return 1 if torrent timed out
 */
 int clean_single_torrent(ot_torrent *torrent) {
-  ot_time timedout = time_since_minutes(torrent->base);
+  ot_time      timedout        = time_since_minutes(torrent->base);
+  ot_peerlist *peer_list       = torrent->peer_list;
+  size_t       removed_seeders = 0;
 
   /* Touched since the last sweep: nothing to do */
   if (!timedout)
@@ -107,7 +104,7 @@ int clean_single_torrent(ot_torrent *torrent) {
 
   /* Already empty and nothing arrived before the peer timeout: keep it only
      while a down count is worth remembering */
-  if (timedout > OT_PEER_TIMEOUT && !torrent->peer_list6 && !torrent->peer_list4)
+  if (timedout > OT_PEER_TIMEOUT && !peer_list)
     return (torrent->down_count && timedout <= g_empty_torrent_timeout) ? 0 : 1;
 
   /* Peers past the peer timeout are gone regardless, which caps how far the
@@ -115,10 +112,19 @@ int clean_single_torrent(ot_torrent *torrent) {
   if (timedout > OT_PEER_TIMEOUT)
     timedout = OT_PEER_TIMEOUT;
 
-  clean_peer_list_family(&torrent->peer_list6, OT_PEER_SIZE6, timedout);
-  clean_peer_list_family(&torrent->peer_list4, OT_PEER_SIZE4, timedout);
+  if (peer_list) {
+    clean_family_vector(&peer_list->peers6, OT_PEER_SIZE6, timedout, &removed_seeders);
+    clean_family_vector(&peer_list->peers4, OT_PEER_SIZE4, timedout, &removed_seeders);
+    peer_list->seed_count -= removed_seeders;
+
+    /* Both families gone: drop the peerlist, the torrent keeps only its count */
+    if (!vector_peer_count(&peer_list->peers6) && !vector_peer_count(&peer_list->peers4)) {
+      free_peerlist(peer_list);
+      torrent->peer_list = peer_list = NULL;
+    }
+  }
 
-  if (torrent->peer_list6 || torrent->peer_list4)
+  if (peer_list)
     torrent->base = time_now_minutes(); /* still carrying peers */
   else {
     /* Fell empty: hold base a peer timeout back so a later idle sweep makes