From 2afc4893bf802700a1decfff57673cefc861c7e7 Mon Sep 17 00:00:00 2001
From: Dirk Engling <erdgeist@erdgeist.org>
Date: Wed, 3 Apr 2024 22:25:30 +0200
Subject: Prepare opentracker for dual stack capabilities

---
 ot_clean.c | 63 +++++++++++++++++++++++++++++++++++---------------------------
 1 file changed, 36 insertions(+), 27 deletions(-)

(limited to 'ot_clean.c')

diff --git a/ot_clean.c b/ot_clean.c
index 139bedb..3b494f4 100644
--- a/ot_clean.c
+++ b/ot_clean.c
@@ -20,36 +20,36 @@
 #include "ot_accesslist.h"
 
 /* Returns amount of removed peers */
-static ssize_t clean_single_bucket( ot_peer *peers, size_t peer_count, time_t timedout, int *removed_seeders ) {
-  ot_peer *last_peer = peers + peer_count, *insert_point;
-  time_t timediff;
+static ssize_t clean_single_bucket( ot_peer *peers, size_t peer_count, size_t peer_size, time_t timedout, int *removed_seeders ) {
+  ot_peer *last_peer = peers + peer_count * peer_size, *insert_point;
 
   /* Two scan modes: unless there is one peer removed, just increase ot_peertime */
   while( peers < last_peer ) {
-    if( ( timediff = timedout + OT_PEERTIME( peers ) ) >= OT_PEER_TIMEOUT )
+    time_t timediff = timedout + OT_PEERTIME( peers, peer_size );
+    if( timediff >= OT_PEER_TIMEOUT )
       break;
-    OT_PEERTIME( peers++ ) = timediff;
+    OT_PEERTIME( peers, peer_size ) = timediff;
+    peers += peer_size;
   }
 
-  /* If we at least remove one peer, we have to copy  */
-  insert_point = peers;
-  while( peers < last_peer )
-    if( ( timediff = timedout + OT_PEERTIME( peers ) ) < OT_PEER_TIMEOUT ) {
-      OT_PEERTIME( peers ) = timediff;
-      memcpy( insert_point++, peers++, sizeof(ot_peer));
+  /* If we at least remove one peer, we have to copy */
+  for( insert_point = peers; peers < last_peer; peers += peer_size ) {
+    time_t timediff = timedout + OT_PEERTIME( peers, peer_size );
+
+    if( timediff < OT_PEER_TIMEOUT ) {
+      OT_PEERTIME( peers, peer_size ) = timediff;
+      memcpy( insert_point, peers, peer_size);
+      insert_point += peer_size;
     } else
-      if( OT_PEERFLAG( peers++ ) & PEER_FLAG_SEEDING )
+      if( OT_PEERFLAG_D( peers, peer_size ) & PEER_FLAG_SEEDING )
         (*removed_seeders)++;
+  }
 
   return peers - insert_point;
 }
 
-/* Clean a single torrent
-   return 1 if torrent timed out
-*/
-int clean_single_torrent( ot_torrent *torrent ) {
-  ot_peerlist *peer_list = torrent->peer_list;
-  ot_vector *bucket_list = &peer_list->peers;
+int clean_single_peer_list( ot_peerlist *peer_list, size_t peer_size ) {
+  ot_vector *peer_vector = &peer_list->peers;
   time_t timedout = (time_t)( g_now_minutes - peer_list->base );
   int num_buckets = 1, removed_seeders = 0;
 
@@ -69,24 +69,26 @@ int clean_single_torrent( ot_torrent *torrent ) {
   }
 
   if( OT_PEERLIST_HASBUCKETS( peer_list ) ) {
-    num_buckets = bucket_list->size;
-    bucket_list = (ot_vector *)bucket_list->data;
+    num_buckets = peer_vector->size;
+    peer_vector = (ot_vector *)peer_vector->data;
   }
 
   while( num_buckets-- ) {
-    size_t removed_peers = clean_single_bucket( bucket_list->data, bucket_list->size, timedout, &removed_seeders );
+    size_t removed_peers = clean_single_bucket( peer_vector->data, peer_vector->size, peer_size, timedout, &removed_seeders );
     peer_list->peer_count -= removed_peers;
-    bucket_list->size     -= removed_peers;
-    if( bucket_list->size < removed_peers )
-      vector_fixup_peers( bucket_list );
-    ++bucket_list;
+    peer_vector->size     -= removed_peers;
+    if( removed_peers )
+      vector_fixup_peers( peer_vector, peer_size );
+
+    /* Skip to next bucket, a vector containing peers */
+    ++peer_vector;
   }
 
   peer_list->seed_count -= removed_seeders;
 
-  /* See, if we need to convert a torrent from simple vector to bucket list */
+  /* See if we need to convert a torrent 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 );
+    vector_redistribute_buckets( peer_list, peer_size );
 
   if( peer_list->peer_count )
     peer_list->base = g_now_minutes;
@@ -96,7 +98,14 @@ int clean_single_torrent( ot_torrent *torrent ) {
     peer_list->base = g_now_minutes - OT_PEER_TIMEOUT;
   }
   return 0;
+}
 
+/* Clean a single torrent
+   return 1 if torrent timed out
+*/
+int clean_single_torrent( ot_torrent *torrent ) {
+  return clean_single_peer_list( torrent->peer_list6, OT_PEER_SIZE6) *
+         clean_single_peer_list( torrent->peer_list4, OT_PEER_SIZE4);
 }
 
 /* Clean up all peers in current bucket, remove timedout pools and
-- 
cgit v1.2.3