net: run tor control based on networkactive

When -networkactive=0 is set, Tor control connection attempts were still
running and logging retry messages. Wire tor control lifecycle to CConnman
similar to mapport: add EnableTorControl() called from Start() and
SetNetworkActive().

TorController starts disconnected and waits for EnableTorControl(true)
from CConnman::Start() before connecting. The event loop stays alive
(unlike mapport's thread start/stop) since restructuring libevent
lifecycle would be more invasive.

Author: willcl-ark

src/net.cpp

@@ -48,6 +48,7 @@
 #include <unordered_map>
 
 void EnableMapPort(bool enable);
+void EnableTorControl(bool enable);
 
 TRACEPOINT_SEMAPHORE(net, closed_connection);
 TRACEPOINT_SEMAPHORE(net, evicted_inbound_connection);
@@ -3227,6 +3228,7 @@ void CConnman::SetNetworkActive(bool active)
     fNetworkActive = active;
 
     EnableMapPort(m_mapport_enabled && active);
+    EnableTorControl(active);
 
     if (m_client_interface) {
         m_client_interface->NotifyNetworkActiveChanged(fNetworkActive);
@@ -3434,6 +3436,7 @@ bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
     }
 
     EnableMapPort(m_mapport_enabled && fNetworkActive);
+    EnableTorControl(fNetworkActive);
 
     return true;
 }

src/torcontrol.cpp

@@ -25,6 +25,7 @@
 #include <util/time.h>
 
 #include <algorithm>
+#include <atomic>
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
@@ -331,11 +332,11 @@ TorController::TorController(struct event_base* _base, const std::string& tor_co
     reconnect_ev = event_new(base, -1, 0, reconnect_cb, this);
     if (!reconnect_ev)
         LogWarning("tor: Failed to create event for reconnection: out of memory?");
-    // Start connection attempts immediately
-    if (!conn.Connect(m_tor_control_center, std::bind(&TorController::connected_cb, this, std::placeholders::_1),
-         std::bind(&TorController::disconnected_cb, this, std::placeholders::_1) )) {
-        LogWarning("tor: Initiating connection to Tor control port %s failed", m_tor_control_center);
-    }
+    // Schedule initial connection attempt after event loop starts and
+    // EnableTorControl has been called from CConnman::Start()
+    struct timeval timeout = {1, 0};
+    if (reconnect_ev)
+        event_add(reconnect_ev, &timeout);
     // Read service private key if cached
     std::pair<bool,std::string> pkf = ReadBinaryFile(GetPrivateKeyFile());
     if (pkf.first) {
@@ -640,6 +641,11 @@ void TorController::disconnected_cb(TorControlConnection& _conn)
     if (!reconnect)
         return;
 
+    if (!m_network_active) {
+        LogDebug(BCLog::TOR, "Network inactive, not reconnecting to Tor control port\n");
+        return;
+    }
+
     LogDebug(BCLog::TOR, "Not connected to Tor control port %s, retrying in %.2f s\n",
              m_tor_control_center, reconnect_timeout);
 
@@ -653,6 +659,13 @@ void TorController::disconnected_cb(TorControlConnection& _conn)
 
 void TorController::Reconnect()
 {
+    if (!m_network_active) {
+        // Reschedule to keep the event loop alive while waiting for network
+        struct timeval timeout = {60, 0};
+        if (reconnect_ev)
+            event_add(reconnect_ev, &timeout);
+        return;
+    }
     /* Try to reconnect and reestablish if we get booted - for example, Tor
      * may be restarting.
      */
@@ -662,6 +675,21 @@ void TorController::Reconnect()
     }
 }
 
+void TorController::SetNetworkActive(bool active)
+{
+    m_network_active = active;
+    // Cancel any pending reconnect timer
+    if (reconnect_ev) {
+        event_del(reconnect_ev);
+    }
+    if (!active) {
+        // Disconnect if currently connected
+        conn.Disconnect();
+    }
+    // Reconnect handles both cases: connects if active, reschedules if inactive
+    Reconnect();
+}
+
 fs::path TorController::GetPrivateKeyFile()
 {
     return gArgs.GetDataDirNet() / "onion_v3_private_key";
@@ -676,12 +704,16 @@ void TorController::reconnect_cb(evutil_socket_t fd, short what, void *arg)
 /****** Thread ********/
 static struct event_base *gBase;
 static std::thread torControlThread;
+static std::atomic<TorController*> gTorController{nullptr};
 
 static void TorControlThread(CService onion_service_target)
 {
     TorController ctrl(gBase, gArgs.GetArg("-torcontrol", DEFAULT_TOR_CONTROL), onion_service_target);
+    gTorController.store(&ctrl);
 
     event_base_dispatch(gBase);
+
+    gTorController.store(nullptr);
 }
 
 void StartTorControl(CService onion_service_target)
@@ -722,6 +754,13 @@ void StopTorControl()
     }
 }
 
+void EnableTorControl(bool enable)
+{
+    if (TorController* ctrl = gTorController.load()) {
+        ctrl->SetNetworkActive(enable);
+    }
+}
+
 CService DefaultOnionServiceTarget(uint16_t port)
 {
     struct in_addr onion_service_target;

src/torcontrol.h

@@ -27,6 +27,7 @@ static const bool DEFAULT_LISTEN_ONION = true;
 void StartTorControl(CService onion_service_target);
 void InterruptTorControl();
 void StopTorControl();
+void EnableTorControl(bool enable);
 
 CService DefaultOnionServiceTarget(uint16_t port);
 
@@ -118,13 +119,18 @@ class TorController
 
     /** Reconnect, after getting disconnected */
     void Reconnect();
+
+    /** Set network active state - controls whether to attempt connections */
+    void SetNetworkActive(bool active);
+
 private:
     struct event_base* base;
     const std::string m_tor_control_center;
     TorControlConnection conn;
     std::string private_key;
     std::string service_id;
     bool reconnect;
+    bool m_network_active{false};
     struct event *reconnect_ev = nullptr;
     float reconnect_timeout;
     CService service;