banman: schedule sweep at ban expiry instead of polling

Give BanMan access to CScheduler so it can fire SweepBanned()
at the exact moment the next ban expires. This triggers
BannedListChanged to refresh the GUI without polling timers.

Track m_next_sweep_time to avoid accumulating redundant scheduled
tasks: Ban() only reschedules when the new ban expires sooner than
what is already scheduled, and ScheduleNextSweep() skips if a
sweep is already pending for an earlier or equal time.

Fix an off-by-one in SweepBanned(): use >= instead of > so that
entries are swept at the exact expiry second, consistent with
IsBanned() which uses < for the active check. This prevents a
tight reschedule loop when the scheduler fires at the boundary.

Fixes bitcoinknots#273

Author: Bortlesboat

src/banman.cpp

@@ -9,10 +9,14 @@
 #include <logging.h>
 #include <netaddress.h>
 #include <node/interface_ui.h>
+#include <scheduler.h>
 #include <sync.h>
 #include <util/time.h>
 #include <util/translation.h>
 
+#include <algorithm>
+#include <limits>
+
 
 BanMan::BanMan(fs::path ban_file, CClientUIInterface* client_interface, int64_t default_ban_time)
     : m_client_interface(client_interface), m_ban_db(std::move(ban_file)), m_default_ban_time(default_ban_time)
@@ -26,6 +30,43 @@ BanMan::~BanMan()
     DumpBanlist();
 }
 
+void BanMan::StartScheduledTasks(CScheduler& scheduler)
+{
+    LOCK(m_banned_mutex);
+    m_scheduler = &scheduler;
+    ScheduleNextSweep();
+}
+
+void BanMan::SweepBannedAndSchedule()
+{
+    LOCK(m_banned_mutex);
+    SweepBanned();
+    m_next_sweep_time = std::numeric_limits<int64_t>::max();
+    ScheduleNextSweep();
+}
+
+void BanMan::ScheduleNextSweep()
+{
+    AssertLockHeld(m_banned_mutex);
+
+    if (!m_scheduler) return;
+    if (m_banned.empty()) return;
+
+    int64_t earliest = std::numeric_limits<int64_t>::max();
+    for (const auto& [subnet, entry] : m_banned) {
+        if (entry.nBanUntil < earliest) {
+            earliest = entry.nBanUntil;
+        }
+    }
+
+    if (earliest >= m_next_sweep_time) return;
+
+    m_next_sweep_time = earliest;
+    int64_t now = GetTime();
+    auto delay = std::chrono::seconds(std::max<int64_t>(0, earliest - now));
+    m_scheduler->scheduleFromNow([this] { SweepBannedAndSchedule(); }, delay);
+}
+
 void BanMan::LoadBanlist()
 {
     LOCK(m_banned_mutex);
@@ -144,6 +185,12 @@ void BanMan::Ban(const CSubNet& sub_net, int64_t ban_time_offset, bool since_uni
         if (m_banned[sub_net].nBanUntil < ban_entry.nBanUntil) {
             m_banned[sub_net] = ban_entry;
             m_is_dirty = true;
+            if (m_scheduler && ban_entry.nBanUntil < m_next_sweep_time) {
+                m_next_sweep_time = ban_entry.nBanUntil;
+                int64_t now = GetTime();
+                auto delay = std::chrono::seconds(std::max<int64_t>(0, m_next_sweep_time - now));
+                m_scheduler->scheduleFromNow([this] { SweepBannedAndSchedule(); }, delay);
+            }
         } else
             return;
     }
@@ -189,7 +236,7 @@ void BanMan::SweepBanned()
     while (it != m_banned.end()) {
         CSubNet sub_net = (*it).first;
         CBanEntry ban_entry = (*it).second;
-        if (!sub_net.IsValid() || now > ban_entry.nBanUntil) {
+        if (!sub_net.IsValid() || now >= ban_entry.nBanUntil) {
             m_banned.erase(it++);
             m_is_dirty = true;
             notify_ui = true;

src/banman.h

@@ -13,6 +13,7 @@
 
 #include <chrono>
 #include <cstdint>
+#include <limits>
 #include <memory>
 
 // NOTE: When adjusting this, update rpcnet:setban's help ("24h")
@@ -23,6 +24,7 @@ static constexpr std::chrono::minutes DUMP_BANS_INTERVAL{15};
 
 class CClientUIInterface;
 class CNetAddr;
+class CScheduler;
 class CSubNet;
 
 // Banman manages two related but distinct concepts:
@@ -62,6 +64,7 @@ class BanMan
     BanMan(fs::path ban_file, CClientUIInterface* client_interface, int64_t default_ban_time);
     void Ban(const CNetAddr& net_addr, int64_t ban_time_offset = 0, bool since_unix_epoch = false) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     void Ban(const CSubNet& sub_net, int64_t ban_time_offset = 0, bool since_unix_epoch = false) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
+    void StartScheduledTasks(CScheduler& scheduler) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     void Discourage(const CNetAddr& net_addr) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     void ClearBanned() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
 
@@ -83,8 +86,12 @@ class BanMan
     void LoadBanlist() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     //!clean unused entries (if bantime has expired)
     void SweepBanned() EXCLUSIVE_LOCKS_REQUIRED(m_banned_mutex);
+    void SweepBannedAndSchedule() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
+    void ScheduleNextSweep() EXCLUSIVE_LOCKS_REQUIRED(m_banned_mutex);
 
     Mutex m_banned_mutex;
+    CScheduler* m_scheduler GUARDED_BY(m_banned_mutex){nullptr};
+    int64_t m_next_sweep_time GUARDED_BY(m_banned_mutex){std::numeric_limits<int64_t>::max()};
     banmap_t m_banned GUARDED_BY(m_banned_mutex);
     bool m_is_dirty GUARDED_BY(m_banned_mutex){false};
     CClientUIInterface* m_client_interface = nullptr;

src/init.cpp

@@ -2437,6 +2437,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         banman->DumpBanlist();
     }, DUMP_BANS_INTERVAL);
 
+    banman->StartScheduledTasks(scheduler);
+
     if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
 
 #if HAVE_SYSTEM