refactor: session private fields (#3961)

* refactor: make tr_session.private_peer_port a private field

chore: make tr_session.public_peer_port a private field

* refactor: make tr_session.web_ a private field

* refactor: make tr_session.lpd_ a private field

* refactor: make tr_session.bind_ipv4_ private

refactor: make tr_session.bind_ipv6_ private

* refactor: make tr_session.bandwidth_groups_ private; add const accessor

* refactor: make tr_session.port_forwarding_ private

* refactor: make tr_session.peerMgr private pt 1: add tr_session::addIncoming()

* refactor: make tr_session.peerMgr private pt 1: add tr_session::addTorrent()

* refactor: make tr_session.peer_mgr_ private

* refactor: make tr_session.setPeerPort() private

libtransmission/announcer-http.cc

@@ -432,7 +432,7 @@ void tr_tracker_http_announce(
     auto do_make_request = [&](std::string_view const& protocol_name, tr_web::FetchOptions&& opt)
     {
         tr_logAddTrace(fmt::format("Sending {} announce to libcurl: '{}'", protocol_name, opt.url), request->log_name);
-        session->web->fetch(std::move(opt));
+        session->fetch(std::move(opt));
     };
 
     auto const ipv6 = tr_globalIPv6(session);
@@ -686,5 +686,5 @@ void tr_tracker_http_scrape(
     options.timeout_secs = 30L;
     options.sndbuf = 4096;
     options.rcvbuf = 4096;
-    session->web->fetch(std::move(options));
+    session->fetch(std::move(options));
 }

libtransmission/peer-mgr.cc

@@ -1237,19 +1237,19 @@ static bool on_handshake_done(tr_handshake_result const& result)
     return success;
 }
 
-void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const* addr, tr_port port, struct tr_peer_socket const socket)
+void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const& addr, tr_port port, struct tr_peer_socket const socket)
 {
     TR_ASSERT(manager->session != nullptr);
     auto const lock = manager->unique_lock();
 
     tr_session* session = manager->session;
 
-    if (session->addressIsBlocked(*addr))
+    if (session->addressIsBlocked(addr))
     {
-        tr_logAddTrace(fmt::format("Banned IP address '{}' tried to connect to us", addr->readable(port)));
+        tr_logAddTrace(fmt::format("Banned IP address '{}' tried to connect to us", addr.readable(port)));
         tr_netClosePeerSocket(session, socket);
     }
-    else if (manager->incoming_handshakes.contains(*addr))
+    else if (manager->incoming_handshakes.contains(addr))
     {
         tr_netClosePeerSocket(session, socket);
     }
@@ -1257,11 +1257,11 @@ void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const* addr, tr_port
     {
         auto* const handshake = tr_handshakeNew(
             std::make_unique<tr_handshake_mediator_impl>(*session),
-            tr_peerIo::newIncoming(session, &session->top_bandwidth_, addr, port, tr_time(), socket),
+            tr_peerIo::newIncoming(session, &session->top_bandwidth_, &addr, port, tr_time(), socket),
             session->encryptionMode(),
             on_handshake_done,
             manager);
-        manager->incoming_handshakes.add(*addr, handshake);
+        manager->incoming_handshakes.add(addr, handshake);
     }
 }
 

libtransmission/peer-mgr.h

@@ -121,7 +121,7 @@ void tr_peerMgrClientSentRequests(tr_torrent* torrent, tr_peer* peer, tr_block_s
 
 [[nodiscard]] size_t tr_peerMgrCountActiveRequestsToPeer(tr_torrent const* torrent, tr_peer const* peer);
 
-void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const* addr, tr_port port, struct tr_peer_socket const socket);
+void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const& addr, tr_port port, struct tr_peer_socket const socket);
 
 [[nodiscard]] std::vector<tr_pex> tr_peerMgrCompactToPex(
     void const* compact,

libtransmission/rpcimpl.cc

@@ -1363,7 +1363,7 @@ static char const* portTest(
 {
     auto const port = session->peerPort();
     auto const url = fmt::format(FMT_STRING("https://portcheck.transmissionbt.com/{:d}"), port.host());
-    session->web->fetch({ url, onPortTested, idle_data });
+    session->fetch({ url, onPortTested, idle_data });
     return nullptr;
 }
 
@@ -1449,7 +1449,7 @@ static char const* blocklistUpdate(
     tr_variant* /*args_out*/,
     struct tr_rpc_idle_data* idle_data)
 {
-    session->web->fetch({ session->blocklistUrl(), onBlocklistFetched, idle_data });
+    session->fetch({ session->blocklistUrl(), onBlocklistFetched, idle_data });
     return nullptr;
 }
 
@@ -1654,7 +1654,7 @@ static char const* torrentAdd(tr_session* session, tr_variant* args_in, tr_varia
         auto* const d = new add_torrent_idle_data{ idle_data, ctor };
         auto options = tr_web::FetchOptions{ filename, onMetadataFetched, d };
         options.cookies = cookies;
-        session->web->fetch(std::move(options));
+        session->fetch(std::move(options));
     }
     else
     {
@@ -1708,7 +1708,7 @@ static char const* groupGet(tr_session* s, tr_variant* args_in, tr_variant* args
     }
 
     auto* const list = tr_variantDictAddList(args_out, TR_KEY_group, 1);
-    for (auto const& [name, group] : s->bandwidth_groups_)
+    for (auto const& [name, group] : s->bandwidthGroups())
     {
         if (names.empty() || names.count(name.sv()) > 0)
         {

libtransmission/session.cc

@@ -242,7 +242,7 @@ void tr_session::WebMediator::run(tr_web::FetchDoneFunc&& func, tr_web::FetchRes
 
 void tr_sessionFetch(tr_session* session, tr_web::FetchOptions&& options)
 {
-    session->web->fetch(std::move(options));
+    session->fetch(std::move(options));
 }
 
 /***
@@ -268,7 +268,7 @@ void tr_sessionSetEncryption(tr_session* session, tr_encryption_mode mode)
 ****
 ***/
 
-void tr_bindinfo::close()
+void tr_session::tr_bindinfo::close()
 {
     if (ev_ != nullptr)
     {
@@ -295,53 +295,35 @@ static void acceptIncomingPeer(evutil_socket_t fd, short /*what*/, void* vsessio
     {
         tr_logAddTrace(fmt::format("new incoming connection {} ({})", client_socket, client_addr.readable(client_port)));
 
-        tr_peerMgrAddIncoming(session->peerMgr, &client_addr, client_port, tr_peer_socket_tcp_create(client_socket));
+        session->addIncoming(client_addr, client_port, tr_peer_socket_tcp_create(client_socket));
     }
 }
 
-void tr_bindinfo::bindAndListenForIncomingPeers(tr_session* session)
+void tr_session::tr_bindinfo::bindAndListenForIncomingPeers(tr_session* session)
 {
     TR_ASSERT(session->allowsTCP());
 
-    socket_ = tr_netBindTCP(&addr_, session->private_peer_port, false);
+    socket_ = tr_netBindTCP(&addr_, session->private_peer_port_, false);
 
     if (socket_ != TR_BAD_SOCKET)
     {
         tr_logAddInfo(fmt::format(
             _("Listening to incoming peer connections on {hostport}"),
-            fmt::arg("hostport", addr_.readable(session->private_peer_port))));
+            fmt::arg("hostport", addr_.readable(session->private_peer_port_))));
         ev_ = event_new(session->eventBase(), socket_, EV_READ | EV_PERSIST, acceptIncomingPeer, session);
         event_add(ev_, nullptr);
     }
 }
 
-static void close_incoming_peer_port(tr_session* session)
-{
-    session->bind_ipv4.close();
-    session->bind_ipv6.close();
-}
-
-static void open_incoming_peer_port(tr_session* session)
-{
-    TR_ASSERT(session->allowsTCP());
-
-    session->bind_ipv4.bindAndListenForIncomingPeers(session);
-
-    if (tr_net_hasIPv6(session->private_peer_port))
-    {
-        session->bind_ipv6.bindAndListenForIncomingPeers(session);
-    }
-}
-
 tr_session::PublicAddressResult tr_session::publicAddress(tr_address_type type) const noexcept
 {
     switch (type)
     {
     case TR_AF_INET:
-        return { bind_ipv4.addr_, bind_ipv4.addr_.readable() == DefaultBindAddressIpv4 };
+        return { bind_ipv4_.addr_, bind_ipv4_.addr_.readable() == DefaultBindAddressIpv4 };
 
     case TR_AF_INET6:
-        return { bind_ipv6.addr_, bind_ipv6.addr_.readable() == DefaultBindAddressIpv6 };
+        return { bind_ipv6_.addr_, bind_ipv6_.addr_.readable() == DefaultBindAddressIpv6 };
 
     default:
         TR_ASSERT_MSG(false, "invalid type");
@@ -510,8 +492,8 @@ void tr_sessionGetSettings(tr_session const* s, tr_variant* setme_dictionary)
     tr_variantDictAddBool(d, TR_KEY_speed_limit_up_enabled, s->isSpeedLimited(TR_UP));
     tr_variantDictAddStr(d, TR_KEY_umask, fmt::format("{:#o}", s->umask_));
     tr_variantDictAddInt(d, TR_KEY_upload_slots_per_torrent, s->uploadSlotsPerTorrent());
-    tr_variantDictAddStr(d, TR_KEY_bind_address_ipv4, s->bind_ipv4.readable());
-    tr_variantDictAddStr(d, TR_KEY_bind_address_ipv6, s->bind_ipv6.readable());
+    tr_variantDictAddStr(d, TR_KEY_bind_address_ipv4, s->bind_ipv4_.readable());
+    tr_variantDictAddStr(d, TR_KEY_bind_address_ipv6, s->bind_ipv6_.readable());
     tr_variantDictAddBool(d, TR_KEY_start_added_torrents, !s->shouldPauseAddedTorrents());
     tr_variantDictAddBool(d, TR_KEY_trash_original_torrent_files, tr_sessionGetDeleteSource(s));
     tr_variantDictAddInt(d, TR_KEY_anti_brute_force_threshold, tr_sessionGetAntiBruteForceThreshold(s));
@@ -728,7 +710,7 @@ void tr_session::initImpl(init_data& data)
 
     tr_logSetQueueEnabled(data.message_queuing_enabled);
 
-    this->peerMgr = tr_peerMgrNew(this);
+    this->peer_mgr_ = tr_peerMgrNew(this);
 
     this->port_forwarding_ = tr_port_forwarding::create(port_forwarding_mediator_);
 
@@ -748,7 +730,7 @@ void tr_session::initImpl(init_data& data)
 
     this->udp_core_ = std::make_unique<tr_session::tr_udp_core>(*this);
 
-    this->web = tr_web::create(this->web_mediator_);
+    this->web_ = tr_web::create(this->web_mediator_);
 
     if (this->allowsLPD())
     {
@@ -763,7 +745,6 @@ void tr_session::initImpl(init_data& data)
 }
 
 static void turtleBootstrap(tr_session* /*session*/, struct tr_turtle_info* /*turtle*/);
-static void setPeerPort(tr_session* session, tr_port port);
 
 void tr_session::setImpl(init_data& data)
 {
@@ -952,7 +933,7 @@ void tr_session::setImpl(init_data& data)
 
     /* public addresses */
 
-    close_incoming_peer_port(this);
+    closePeerPort();
 
     auto address = tr_inaddr_any;
 
@@ -964,7 +945,7 @@ void tr_session::setImpl(init_data& data)
         }
     }
 
-    this->bind_ipv4 = tr_bindinfo{ address };
+    this->bind_ipv4_ = tr_bindinfo{ address };
 
     address = tr_in6addr_any;
 
@@ -976,7 +957,7 @@ void tr_session::setImpl(init_data& data)
         }
     }
 
-    this->bind_ipv6 = tr_bindinfo{ address };
+    this->bind_ipv6_ = tr_bindinfo{ address };
 
     /* incoming peer port */
     if (tr_variantDictFindInt(settings, TR_KEY_peer_port_random_low, &i))
@@ -995,14 +976,14 @@ void tr_session::setImpl(init_data& data)
     }
 
     {
-        auto peer_port = this->private_peer_port;
+        auto peer_port = this->private_peer_port_;
 
         if (auto port = int64_t{}; tr_variantDictFindInt(settings, TR_KEY_peer_port, &port))
         {
             peer_port.setHost(static_cast<uint16_t>(port));
         }
 
-        ::setPeerPort(this, isPortRandom() ? randomPort() : peer_port);
+        setPeerPort(isPortRandom() ? randomPort() : peer_port);
     }
 
     if (auto val = bool{}; tr_variantDictFindBool(settings, TR_KEY_port_forwarding_enabled, &val))
@@ -1251,44 +1232,46 @@ bool tr_sessionIsIncompleteDirEnabled(tr_session const* session)
 ****  Peer Port
 ***/
 
-static void peerPortChanged(tr_session* const session)
+void tr_session::setPeerPort(tr_port port_in)
 {
-    TR_ASSERT(session != nullptr);
-
-    close_incoming_peer_port(session);
-
-    if (session->allowsTCP())
+    auto const in_session_thread = [this](tr_port port)
     {
-        open_incoming_peer_port(session);
-    }
+        private_peer_port_ = port;
+        public_peer_port_ = port;
 
-    session->port_forwarding_->portChanged();
+        closePeerPort();
 
-    for (auto* const tor : session->torrents())
-    {
-        tr_torrentChangeMyPort(tor);
-    }
-}
+        if (allowsTCP())
+        {
+            bind_ipv4_.bindAndListenForIncomingPeers(this);
 
-static void setPeerPort(tr_session* session, tr_port port)
-{
-    session->private_peer_port = port;
-    session->public_peer_port = port;
+            if (tr_net_hasIPv6(private_peer_port_))
+            {
+                bind_ipv6_.bindAndListenForIncomingPeers(this);
+            }
+        }
 
-    tr_runInEventThread(session, peerPortChanged, session);
+        port_forwarding_->portChanged();
+
+        for (auto* const tor : torrents())
+        {
+            tr_torrentChangeMyPort(tor);
+        }
+    };
+
+    tr_runInEventThread(this, in_session_thread, port_in);
 }
 
 void tr_sessionSetPeerPort(tr_session* session, uint16_t hport)
 {
-    if (auto const port = tr_port::fromHost(hport); session != nullptr && session->private_peer_port != port)
-    {
-        setPeerPort(session, port);
-    }
+    TR_ASSERT(session != nullptr);
+
+    session->setPeerPort(tr_port::fromHost(hport));
 }
 
 uint16_t tr_sessionGetPeerPort(tr_session const* session)
 {
-    return session != nullptr ? session->public_peer_port.host() : 0U;
+    return session != nullptr ? session->public_peer_port_.host() : 0U;
 }
 
 uint16_t tr_sessionSetPeerPortRandom(tr_session* session)
@@ -1814,7 +1797,7 @@ void tr_session::closeImplStart()
     verifier_.reset();
     port_forwarding_.reset();
 
-    close_incoming_peer_port(this);
+    closePeerPort();
     this->rpc_server_.reset();
 
     /* Close the torrents. Get the most active ones first so that
@@ -1845,7 +1828,7 @@ void tr_session::closeImplStart()
 
     /* and this goes *after* announcer close so that
        it won't be idle until the announce events are sent... */
-    this->web->closeSoon();
+    this->web_->closeSoon();
 
     this->cache.reset();
 
@@ -1878,7 +1861,7 @@ void tr_session::closeImplFinish()
     this->udp_core_.reset();
 
     stats().saveIfDirty();
-    tr_peerMgrFree(peerMgr);
+    tr_peerMgrFree(peer_mgr_);
     tr_utpClose(this);
     blocklists_.clear();
     openFiles().closeAll();
@@ -1914,7 +1897,7 @@ void tr_sessionClose(tr_session* session)
      * so we need to keep the transmission thread alive
      * for a bit while they tell the router & tracker
      * that we're closing now */
-    while ((session->port_forwarding_ || !session->web->isClosed() || session->announcer != nullptr ||
+    while ((session->port_forwarding_ || !session->web_->isClosed() || session->announcer != nullptr ||
             session->announcer_udp != nullptr) &&
            !deadlineReached(deadline))
     {
@@ -1927,7 +1910,7 @@ void tr_sessionClose(tr_session* session)
         tr_wait_msec(50);
     }
 
-    session->web.reset();
+    session->web_.reset();
 
     /* close the libtransmission thread */
     tr_eventClose(session);
@@ -2255,7 +2238,7 @@ void tr_sessionReloadBlocklists(tr_session* session)
     session->blocklists_.clear();
     session->blocklists_ = BlocklistFile::loadBlocklists(session->configDir(), session->useBlocklist());
 
-    tr_peerMgrOnBlocklistChanged(session->peerMgr);
+    tr_peerMgrOnBlocklistChanged(session->peer_mgr_);
 }
 
 size_t tr_blocklistGetRuleCount(tr_session const* session)
@@ -2706,7 +2689,7 @@ static void bandwidthGroupRead(tr_session* session, std::string_view config_dir)
 
 static int bandwidthGroupWrite(tr_session const* session, std::string_view config_dir)
 {
-    auto const& groups = session->bandwidth_groups_;
+    auto const& groups = session->bandwidthGroups();
 
     auto groups_dict = tr_variant{};
     tr_variantInitDict(&groups_dict, std::size(groups));
@@ -2853,3 +2836,15 @@ tr_session::tr_session(std::string_view config_dir)
 
     verifier_->addCallback(tr_torrentOnVerifyDone);
 }
+
+void tr_session::addIncoming(tr_address const& addr, tr_port port, struct tr_peer_socket const socket)
+{
+    tr_peerMgrAddIncoming(peer_mgr_, addr, port, socket);
+}
+
+void tr_session::addTorrent(tr_torrent* tor)
+{
+    tor->unique_id_ = torrents().add(tor);
+
+    tr_peerMgrAddTorrent(peer_mgr_, tor);
+}

libtransmission/session.h

@@ -75,27 +75,6 @@ class SessionTest;
 
 } // namespace libtransmission::test
 
-struct tr_bindinfo
-{
-    explicit tr_bindinfo(tr_address addr)
-        : addr_{ std::move(addr) }
-    {
-    }
-
-    void bindAndListenForIncomingPeers(tr_session* session);
-
-    void close();
-
-    [[nodiscard]] auto readable() const
-    {
-        return addr_.readable();
-    }
-
-    tr_address addr_;
-    struct event* ev_ = nullptr;
-    tr_socket_t socket_ = TR_BAD_SOCKET;
-};
-
 struct tr_turtle_info
 {
     /* TR_UP and TR_DOWN speed limits */
@@ -139,6 +118,27 @@ struct tr_turtle_info
 struct tr_session
 {
 private:
+    struct tr_bindinfo
+    {
+        explicit tr_bindinfo(tr_address addr)
+            : addr_{ std::move(addr) }
+        {
+        }
+
+        void bindAndListenForIncomingPeers(tr_session* session);
+
+        void close();
+
+        [[nodiscard]] auto readable() const
+        {
+            return addr_.readable();
+        }
+
+        tr_address addr_;
+        struct event* ev_ = nullptr;
+        tr_socket_t socket_ = TR_BAD_SOCKET;
+    };
+
     class PortForwardingMediator final : public tr_port_forwarding::Mediator
     {
     public:
@@ -149,12 +149,12 @@ private:
 
         [[nodiscard]] tr_address incomingPeerAddress() const override
         {
-            return session_.bind_ipv4.addr_;
+            return session_.bind_ipv4_.addr_;
         }
 
         [[nodiscard]] tr_port privatePeerPort() const override
         {
-            return session_.private_peer_port;
+            return session_.private_peer_port_;
         }
 
         [[nodiscard]] libtransmission::TimerMaker& timerMaker() override
@@ -164,8 +164,8 @@ private:
 
         void onPortForwarded(tr_port public_port, tr_port private_port) override
         {
-            session_.public_peer_port = public_port;
-            session_.private_peer_port = private_port;
+            session_.public_peer_port_ = public_port;
+            session_.private_peer_port_ = private_port;
         }
 
     private:
@@ -610,12 +610,7 @@ public:
 
     [[nodiscard]] constexpr tr_port peerPort() const noexcept
     {
-        return public_peer_port;
-    }
-
-    constexpr auto setPeerPort(tr_port port) noexcept
-    {
-        public_peer_port = port;
+        return public_peer_port_;
     }
 
     [[nodiscard]] constexpr auto queueEnabled(tr_direction dir) const noexcept
@@ -814,9 +809,31 @@ public:
         }
     }
 
+    void fetch(tr_web::FetchOptions options) const
+    {
+        web_->fetch(std::move(options));
+    }
+
+    [[nodiscard]] auto const& bandwidthGroups() const noexcept
+    {
+        return bandwidth_groups_;
+    }
+
+    void addIncoming(tr_address const& addr, tr_port port, struct tr_peer_socket const socket);
+
+    void addTorrent(tr_torrent* tor);
+
 private:
     [[nodiscard]] tr_port randomPort() const;
 
+    void setPeerPort(tr_port port);
+
+    void closePeerPort()
+    {
+        bind_ipv4_.close();
+        bind_ipv6_.close();
+    }
+
     struct init_data;
     void initImpl(init_data&);
     void setImpl(init_data&);
@@ -827,8 +844,11 @@ private:
     void onNowTimer();
 
     friend class libtransmission::test::SessionTest;
+    friend struct tr_bindinfo;
+
     friend bool tr_blocklistExists(tr_session const* session);
     friend bool tr_sessionGetAntiBruteForceEnabled(tr_session const* session);
+    friend bool tr_sessionIsPortForwardingEnabled(tr_session const* session);
     friend bool tr_sessionIsRPCEnabled(tr_session const* session);
     friend bool tr_sessionIsRPCPasswordEnabled(tr_session const* session);
     friend char const* tr_sessionGetRPCPassword(tr_session const* session);
@@ -837,7 +857,9 @@ private:
     friend int tr_sessionGetAntiBruteForceThreshold(tr_session const* session);
     friend size_t tr_blocklistGetRuleCount(tr_session const* session);
     friend size_t tr_blocklistSetContent(tr_session* session, char const* content_filename);
+    friend tr_port_forwarding_state tr_sessionGetPortForwarding(tr_session const* session);
     friend tr_session* tr_sessionInit(char const* config_dir, bool message_queueing_enabled, tr_variant* client_settings);
+    friend uint16_t tr_sessionGetPeerPort(tr_session const* session);
     friend uint16_t tr_sessionGetRPCPort(tr_session const* session);
     friend uint16_t tr_sessionSetPeerPortRandom(tr_session* session);
     friend void tr_sessionClose(tr_session* session);
@@ -857,8 +879,10 @@ private:
     friend void tr_sessionSetPaused(tr_session* session, bool is_paused);
     friend void tr_sessionSetPeerLimit(tr_session* session, uint16_t max_global_peers);
     friend void tr_sessionSetPeerLimitPerTorrent(tr_session* session, uint16_t max_peers);
+    friend void tr_sessionSetPeerPort(tr_session* session, uint16_t hport);
     friend void tr_sessionSetPeerPortRandomOnStart(tr_session* session, bool random);
     friend void tr_sessionSetPexEnabled(tr_session* session, bool enabled);
+    friend void tr_sessionSetPortForwardingEnabled(tr_session* session, bool enabled);
     friend void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_limit_simultaneous_seed_torrents);
     friend void tr_sessionSetQueueSize(tr_session* session, tr_direction dir, int max_simultaneous_seed_torrents);
     friend void tr_sessionSetQueueStalledEnabled(tr_session* session, bool is_enabled);
@@ -938,17 +962,15 @@ private:
 
     tr_preallocation_mode preallocation_mode_ = TR_PREALLOCATE_SPARSE;
 
-public:
     // The open port on the local machine for incoming peer requests
-    tr_port private_peer_port;
+    tr_port private_peer_port_;
 
     // The open port on the public device for incoming peer requests.
     // This is usually the same as private_peer_port but can differ
     // if the public device is a router and it decides to use a different
     // port than the one requested by Transmission.
-    tr_port public_peer_port;
+    tr_port public_peer_port_;
 
-private:
     tr_port random_port_low_;
     tr_port random_port_high_;
 
@@ -1009,10 +1031,10 @@ private:
 
     tr_session_id session_id_;
 
-public:
-    tr_bindinfo bind_ipv4 = tr_bindinfo{ tr_inaddr_any };
-    tr_bindinfo bind_ipv6 = tr_bindinfo{ tr_in6addr_any };
+    tr_bindinfo bind_ipv4_ = tr_bindinfo{ tr_inaddr_any };
+    tr_bindinfo bind_ipv6_ = tr_bindinfo{ tr_in6addr_any };
 
+public:
     struct tr_turtle_info turtle;
 
     /// other fields
@@ -1025,11 +1047,11 @@ public:
 
     std::unique_ptr<tr_udp_core> udp_core_;
 
-    struct tr_peerMgr* peerMgr = nullptr;
+private:
+    struct tr_peerMgr* peer_mgr_ = nullptr;
 
     std::unique_ptr<tr_port_forwarding> port_forwarding_;
 
-private:
     tr_torrents torrents_;
 
     tr_open_files open_files_;
@@ -1037,19 +1059,21 @@ private:
 public:
     std::unique_ptr<Cache> cache = std::make_unique<Cache>(torrents_, 1024 * 1024 * 2);
 
-    std::unique_ptr<tr_web> web;
+private:
+    std::unique_ptr<tr_web> web_;
 
     std::unique_ptr<tr_lpd> lpd_;
 
+public:
     struct tr_announcer* announcer = nullptr;
     struct tr_announcer_udp* announcer_udp = nullptr;
 
     // monitors the "global pool" speeds
     tr_bandwidth top_bandwidth_;
 
+private:
     std::vector<std::pair<tr_interned_string, std::unique_ptr<tr_bandwidth>>> bandwidth_groups_;
 
-private:
     std::vector<std::unique_ptr<BlocklistFile>> blocklists_;
 
     std::unique_ptr<tr_rpc_server> rpc_server_;

libtransmission/torrent.cc

@@ -712,9 +712,7 @@ static void torrentInit(tr_torrent* tor, tr_ctor const* ctor)
     auto const& labels = tr_ctorGetLabels(ctor);
     tor->setLabels(labels);
 
-    tor->unique_id_ = session->torrents().add(tor);
-
-    tr_peerMgrAddTorrent(session->peerMgr, tor);
+    session->addTorrent(tor);
 
     TR_ASSERT(tor->downloadedCur == 0);
     TR_ASSERT(tor->uploadedCur == 0);

libtransmission/tr-utp.cc

@@ -99,7 +99,7 @@ static void utp_on_accept(tr_session* const session, UTPSocket* const s)
         return;
     }
 
-    tr_peerMgrAddIncoming(session->peerMgr, &addr, port, tr_peer_socket_utp_create(s));
+    session->addIncoming(addr, port, tr_peer_socket_utp_create(s));
 }
 
 static void utp_send_to(

libtransmission/webseed.cc

@@ -525,7 +525,7 @@ void task_request_next_chunk(tr_webseed_task* task)
     options.range = fmt::format(FMT_STRING("{:d}-{:d}"), file_offset, file_offset + this_chunk - 1);
     options.speed_limit_tag = tor->id();
     options.buffer = task->content();
-    tor->session->web->fetch(std::move(options));
+    tor->session->fetch(std::move(options));
 }
 
 } // namespace