refactor: remove tr_isSession() (#3638)

libtransmission/announcer.cc

@@ -198,7 +198,7 @@ static tr_scrape_info* tr_announcerGetScrapeInfo(tr_announcer* announcer, tr_int
 
 void tr_announcerInit(tr_session* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     auto* a = new tr_announcer{ session };
 

libtransmission/net.cc

@@ -234,7 +234,7 @@ static socklen_t setup_sockaddr(tr_address const* addr, tr_port port, struct soc
 
 static tr_socket_t createSocket(tr_session* session, int domain, int type)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     auto const sockfd = socket(domain, type, 0);
     if (sockfd == TR_BAD_SOCKET)
@@ -537,7 +537,7 @@ bool tr_net_hasIPv6(tr_port port)
 
 tr_socket_t tr_netAccept(tr_session* session, tr_socket_t listening_sockfd, tr_address* addr, tr_port* port)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(addr != nullptr);
     TR_ASSERT(port != nullptr);
 

libtransmission/peer-mgr.cc

@@ -1240,7 +1240,7 @@ static bool on_handshake_done(tr_handshake_result const& result)
 
 void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const* addr, tr_port port, struct tr_peer_socket const socket)
 {
-    TR_ASSERT(tr_isSession(manager->session));
+    TR_ASSERT(manager->session != nullptr);
     auto const lock = manager->unique_lock();
 
     tr_session* session = manager->session;
@@ -2537,7 +2537,7 @@ void pumpAllPeers(tr_peerMgr* mgr)
 
 void queuePulse(tr_session* session, tr_direction dir)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(tr_isDirection(dir));
 
     if (session->queueEnabled(dir))

libtransmission/session.cc

@@ -584,7 +584,6 @@ tr_session* tr_sessionInit(char const* config_dir, bool message_queueing_enabled
     session->udp_socket = TR_BAD_SOCKET;
     session->udp6_socket = TR_BAD_SOCKET;
     session->cache = std::make_unique<Cache>(session->torrents(), 1024 * 1024 * 2);
-    session->magicNumber = SESSION_MAGIC_NUMBER;
     bandwidthGroupRead(session, config_dir);
 
     /* nice to start logging at the very beginning */
@@ -1130,21 +1129,21 @@ void tr_sessionSet(tr_session* session, tr_variant* settings)
 
 void tr_sessionSetDownloadDir(tr_session* session, char const* dir)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->setDownloadDir(dir != nullptr ? dir : "");
 }
 
 char const* tr_sessionGetDownloadDir(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->downloadDir().c_str();
 }
 
 char const* tr_sessionGetConfigDir(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->configDir().c_str();
 }
@@ -1155,14 +1154,14 @@ char const* tr_sessionGetConfigDir(tr_session const* session)
 
 void tr_sessionSetIncompleteFileNamingEnabled(tr_session* session, bool b)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->isIncompleteFileNamingEnabled = b;
 }
 
 bool tr_sessionIsIncompleteFileNamingEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isIncompleteFileNamingEnabled;
 }
@@ -1173,28 +1172,28 @@ bool tr_sessionIsIncompleteFileNamingEnabled(tr_session const* session)
 
 void tr_sessionSetIncompleteDir(tr_session* session, char const* dir)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->setIncompleteDir(dir != nullptr ? dir : "");
 }
 
 char const* tr_sessionGetIncompleteDir(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->incompleteDir().c_str();
 }
 
 void tr_sessionSetIncompleteDirEnabled(tr_session* session, bool b)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->useIncompleteDir(b);
 }
 
 bool tr_sessionIsIncompleteDirEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->useIncompleteDir();
 }
@@ -1205,7 +1204,7 @@ bool tr_sessionIsIncompleteDirEnabled(tr_session const* session)
 
 static void peerPortChanged(tr_session* const session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     close_incoming_peer_port(session);
     open_incoming_peer_port(session);
@@ -1227,7 +1226,7 @@ static void setPeerPort(tr_session* session, tr_port port)
 
 void tr_sessionSetPeerPort(tr_session* session, uint16_t hport)
 {
-    if (auto const port = tr_port::fromHost(hport); tr_isSession(session) && session->private_peer_port != port)
+    if (auto const port = tr_port::fromHost(hport); session != nullptr && session->private_peer_port != port)
     {
         setPeerPort(session, port);
     }
@@ -1235,7 +1234,7 @@ void tr_sessionSetPeerPort(tr_session* session, uint16_t hport)
 
 uint16_t tr_sessionGetPeerPort(tr_session const* session)
 {
-    return tr_isSession(session) ? session->public_peer_port.host() : 0U;
+    return session != nullptr ? session->public_peer_port.host() : 0U;
 }
 
 uint16_t tr_sessionSetPeerPortRandom(tr_session* session)
@@ -1247,21 +1246,21 @@ uint16_t tr_sessionSetPeerPortRandom(tr_session* session)
 
 void tr_sessionSetPeerPortRandomOnStart(tr_session* session, bool random)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->isPortRandom = random;
 }
 
 bool tr_sessionGetPeerPortRandomOnStart(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isPortRandom;
 }
 
 tr_port_forwarding tr_sessionGetPortForwarding(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return tr_port_forwarding(tr_sharedTraversalStatus(session->shared));
 }
@@ -1272,28 +1271,28 @@ tr_port_forwarding tr_sessionGetPortForwarding(tr_session const* session)
 
 void tr_sessionSetRatioLimited(tr_session* session, bool isLimited)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->isRatioLimited = isLimited;
 }
 
 void tr_sessionSetRatioLimit(tr_session* session, double desiredRatio)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->desiredRatio = desiredRatio;
 }
 
 bool tr_sessionIsRatioLimited(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isRatioLimited;
 }
 
 double tr_sessionGetRatioLimit(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->desiredRatio;
 }
@@ -1304,28 +1303,28 @@ double tr_sessionGetRatioLimit(tr_session const* session)
 
 void tr_sessionSetIdleLimited(tr_session* session, bool isLimited)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->isIdleLimited = isLimited;
 }
 
 void tr_sessionSetIdleLimit(tr_session* session, uint16_t idleMinutes)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->idleLimitMinutes = idleMinutes;
 }
 
 bool tr_sessionIsIdleLimited(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isIdleLimited;
 }
 
 uint16_t tr_sessionGetIdleLimit(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->idleLimitMinutes;
 }
@@ -1342,7 +1341,7 @@ bool tr_sessionGetActiveSpeedLimit_Bps(tr_session const* session, tr_direction d
 {
     bool isLimited = true;
 
-    if (!tr_isSession(session))
+    if (session == nullptr)
     {
         return false;
     }
@@ -1411,7 +1410,7 @@ static void turtleUpdateTable(struct tr_turtle_info* t)
 
 static void altSpeedToggled(tr_session* const session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     updateBandwidth(session, TR_UP);
     updateBandwidth(session, TR_DOWN);
@@ -1426,7 +1425,7 @@ static void altSpeedToggled(tr_session* const session)
 
 static void useAltSpeed(tr_session* s, struct tr_turtle_info* t, bool enabled, bool byUser)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(t != nullptr);
 
     if (t->isEnabled != enabled)
@@ -1503,7 +1502,7 @@ static void turtleBootstrap(tr_session* session, struct tr_turtle_info* turtle)
 
 static void tr_sessionSetSpeedLimit_Bps(tr_session* s, tr_direction d, unsigned int Bps)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(tr_isDirection(d));
 
     s->speedLimit_Bps[d] = Bps;
@@ -1518,7 +1517,7 @@ void tr_sessionSetSpeedLimit_KBps(tr_session* s, tr_direction d, unsigned int KB
 
 unsigned int tr_sessionGetSpeedLimit_Bps(tr_session const* s, tr_direction d)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(tr_isDirection(d));
 
     return s->speedLimit_Bps[d];
@@ -1531,7 +1530,7 @@ unsigned int tr_sessionGetSpeedLimit_KBps(tr_session const* s, tr_direction d)
 
 void tr_sessionLimitSpeed(tr_session* s, tr_direction d, bool b)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(tr_isDirection(d));
 
     s->speedLimitEnabled[d] = b;
@@ -1541,7 +1540,7 @@ void tr_sessionLimitSpeed(tr_session* s, tr_direction d, bool b)
 
 bool tr_sessionIsSpeedLimited(tr_session const* s, tr_direction d)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(tr_isDirection(d));
 
     return s->speedLimitEnabled[d];
@@ -1553,7 +1552,7 @@ bool tr_sessionIsSpeedLimited(tr_session const* s, tr_direction d)
 
 static void tr_sessionSetAltSpeed_Bps(tr_session* s, tr_direction d, unsigned int Bps)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(tr_isDirection(d));
 
     s->turtle.speedLimit_Bps[d] = Bps;
@@ -1568,7 +1567,7 @@ void tr_sessionSetAltSpeed_KBps(tr_session* s, tr_direction d, unsigned int KBps
 
 static unsigned int tr_sessionGetAltSpeed_Bps(tr_session const* s, tr_direction d)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(tr_isDirection(d));
 
     return s->turtle.speedLimit_Bps[d];
@@ -1597,7 +1596,7 @@ static void userPokedTheClock(tr_session* s, struct tr_turtle_info* t)
 
 void tr_sessionUseAltSpeedTime(tr_session* s, bool b)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     struct tr_turtle_info* t = &s->turtle;
 
@@ -1610,14 +1609,14 @@ void tr_sessionUseAltSpeedTime(tr_session* s, bool b)
 
 bool tr_sessionUsesAltSpeedTime(tr_session const* s)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     return s->turtle.isClockEnabled;
 }
 
 void tr_sessionSetAltSpeedBegin(tr_session* s, int minutes_since_midnight)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(minutes_since_midnight >= 0);
     TR_ASSERT(minutes_since_midnight < 60 * 24);
 
@@ -1630,14 +1629,14 @@ void tr_sessionSetAltSpeedBegin(tr_session* s, int minutes_since_midnight)
 
 int tr_sessionGetAltSpeedBegin(tr_session const* s)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     return s->turtle.beginMinute;
 }
 
 void tr_sessionSetAltSpeedEnd(tr_session* s, int minutes_since_midnight)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
     TR_ASSERT(minutes_since_midnight >= 0);
     TR_ASSERT(minutes_since_midnight < 60 * 24);
 
@@ -1650,14 +1649,14 @@ void tr_sessionSetAltSpeedEnd(tr_session* s, int minutes_since_midnight)
 
 int tr_sessionGetAltSpeedEnd(tr_session const* s)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     return s->turtle.endMinute;
 }
 
 void tr_sessionSetAltSpeedDay(tr_session* s, tr_sched_day days)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     if (s->turtle.days != days)
     {
@@ -1668,7 +1667,7 @@ void tr_sessionSetAltSpeedDay(tr_session* s, tr_sched_day days)
 
 tr_sched_day tr_sessionGetAltSpeedDay(tr_session const* s)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     return s->turtle.days;
 }
@@ -1680,14 +1679,14 @@ void tr_sessionUseAltSpeed(tr_session* session, bool enabled)
 
 bool tr_sessionUsesAltSpeed(tr_session const* s)
 {
-    TR_ASSERT(tr_isSession(s));
+    TR_ASSERT(s != nullptr);
 
     return s->turtle.isEnabled;
 }
 
 void tr_sessionSetAltSpeedFunc(tr_session* session, tr_altSpeedFunc func, void* userData)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->turtle.callback = func;
     session->turtle.callbackUserData = userData;
@@ -1699,28 +1698,28 @@ void tr_sessionSetAltSpeedFunc(tr_session* session, tr_altSpeedFunc func, void*
 
 void tr_sessionSetPeerLimit(tr_session* session, uint16_t max_global_peers)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->peer_limit_ = max_global_peers;
 }
 
 uint16_t tr_sessionGetPeerLimit(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->peerLimit();
 }
 
 void tr_sessionSetPeerLimitPerTorrent(tr_session* session, uint16_t max_peers)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->peer_limit_per_torrent_ = max_peers;
 }
 
 uint16_t tr_sessionGetPeerLimitPerTorrent(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->peerLimitPerTorrent();
 }
@@ -1731,28 +1730,28 @@ uint16_t tr_sessionGetPeerLimitPerTorrent(tr_session const* session)
 
 void tr_sessionSetPaused(tr_session* session, bool is_paused)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->should_pause_added_torrents_ = is_paused;
 }
 
 bool tr_sessionGetPaused(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->shouldPauseAddedTorrents();
 }
 
 void tr_sessionSetDeleteSource(tr_session* session, bool delete_source)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->should_delete_source_torrents_ = delete_source;
 }
 
 bool tr_sessionGetDeleteSource(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->shouldDeleteSource();
 }
@@ -1763,12 +1762,12 @@ bool tr_sessionGetDeleteSource(tr_session const* session)
 
 unsigned int tr_sessionGetPieceSpeed_Bps(tr_session const* session, tr_direction dir)
 {
-    return tr_isSession(session) ? session->top_bandwidth_.getPieceSpeedBytesPerSecond(0, dir) : 0;
+    return session != nullptr ? session->top_bandwidth_.getPieceSpeedBytesPerSecond(0, dir) : 0;
 }
 
 static unsigned int tr_sessionGetRawSpeed_Bps(tr_session const* session, tr_direction dir)
 {
-    return tr_isSession(session) ? session->top_bandwidth_.getRawSpeedBytesPerSecond(0, dir) : 0;
+    return session != nullptr ? session->top_bandwidth_.getRawSpeedBytesPerSecond(0, dir) : 0;
 }
 
 double tr_sessionGetRawSpeed_KBps(tr_session const* session, tr_direction dir)
@@ -1778,12 +1777,12 @@ double tr_sessionGetRawSpeed_KBps(tr_session const* session, tr_direction dir)
 
 int tr_sessionCountTorrents(tr_session const* session)
 {
-    return tr_isSession(session) ? std::size(session->torrents()) : 0;
+    return session != nullptr ? std::size(session->torrents()) : 0;
 }
 
 std::vector<tr_torrent*> tr_sessionGetTorrents(tr_session* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     auto const n = std::size(session->torrents());
     auto torrents = std::vector<tr_torrent*>{ n };
@@ -1890,7 +1889,7 @@ static auto constexpr ShutdownMaxSeconds = time_t{ 20 };
 
 void tr_sessionClose(tr_session* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     time_t const deadline = time(nullptr) + ShutdownMaxSeconds;
 
@@ -1966,7 +1965,7 @@ struct sessionLoadTorrentsData
 
 static void sessionLoadTorrents(struct sessionLoadTorrentsData* const data)
 {
-    TR_ASSERT(tr_isSession(data->session));
+    TR_ASSERT(data->session != nullptr);
 
     auto const& dirname = data->session->torrentDir();
     auto const info = tr_sys_path_get_info(dirname);
@@ -2046,14 +2045,14 @@ tr_torrent** tr_sessionLoadTorrents(tr_session* session, tr_ctor* ctor, int* set
 
 void tr_sessionSetPexEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->isPexEnabled = enabled;
 }
 
 bool tr_sessionIsPexEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isPexEnabled;
 }
@@ -2065,14 +2064,14 @@ bool tr_sessionAllowsDHT(tr_session const* session)
 
 bool tr_sessionIsDHTEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isDHTEnabled;
 }
 
 static void toggleDHTImpl(tr_session* const session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     tr_udpUninit(session);
     session->isDHTEnabled = !session->isDHTEnabled;
@@ -2081,7 +2080,7 @@ static void toggleDHTImpl(tr_session* const session)
 
 void tr_sessionSetDHTEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     if (enabled != session->isDHTEnabled)
     {
@@ -2095,7 +2094,7 @@ void tr_sessionSetDHTEnabled(tr_session* session, bool enabled)
 
 bool tr_sessionIsUTPEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
 #ifdef WITH_UTP
     return session->isUTPEnabled;
@@ -2106,7 +2105,7 @@ bool tr_sessionIsUTPEnabled(tr_session const* session)
 
 static void toggle_utp(tr_session* const session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->isUTPEnabled = !session->isUTPEnabled;
 
@@ -2120,7 +2119,7 @@ static void toggle_utp(tr_session* const session)
 
 void tr_sessionSetUTPEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     if (enabled != session->isUTPEnabled)
     {
@@ -2134,7 +2133,7 @@ void tr_sessionSetUTPEnabled(tr_session* session, bool enabled)
 
 static void toggleLPDImpl(tr_session* const session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     if (session->isLPDEnabled)
     {
@@ -2151,7 +2150,7 @@ static void toggleLPDImpl(tr_session* const session)
 
 void tr_sessionSetLPDEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     if (enabled != session->isLPDEnabled)
     {
@@ -2161,7 +2160,7 @@ void tr_sessionSetLPDEnabled(tr_session* session, bool enabled)
 
 bool tr_sessionIsLPDEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->isLPDEnabled;
 }
@@ -2177,14 +2176,14 @@ bool tr_sessionAllowsLPD(tr_session const* session)
 
 void tr_sessionSetCacheLimit_MB(tr_session* session, int mb)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->cache->setLimit(tr_toMemBytes(mb));
 }
 
 int tr_sessionGetCacheLimit_MB(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return tr_toMemMB(session->cache->getLimit());
 }
@@ -2215,7 +2214,7 @@ void tr_session::setDefaultTrackers(std::string_view trackers)
 
 void tr_sessionSetDefaultTrackers(tr_session* session, char const* trackers)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->setDefaultTrackers(trackers != nullptr ? trackers : "");
 }
@@ -2251,7 +2250,7 @@ void tr_sessionSetPortForwardingEnabled(tr_session* session, bool enabled)
 
 bool tr_sessionIsPortForwardingEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return tr_sharedTraversalIsEnabled(session->shared);
 }
@@ -2355,7 +2354,7 @@ void tr_sessionReloadBlocklists(tr_session* session)
 
 size_t tr_blocklistGetRuleCount(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     auto& src = session->blocklists;
     return std::accumulate(std::begin(src), std::end(src), 0, [](int sum, auto& cur) { return sum + cur->getRuleCount(); });
@@ -2363,7 +2362,7 @@ size_t tr_blocklistGetRuleCount(tr_session const* session)
 
 bool tr_blocklistIsEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->useBlocklist();
 }
@@ -2377,14 +2376,14 @@ void tr_session::useBlocklist(bool enabled)
 
 void tr_blocklistSetEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->useBlocklist(enabled);
 }
 
 bool tr_blocklistExists(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return !std::empty(session->blocklists);
 }
@@ -2455,21 +2454,21 @@ bool tr_session::useRpcWhitelist() const
 
 void tr_sessionSetRPCEnabled(tr_session* session, bool is_enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_server_->setEnabled(is_enabled);
 }
 
 bool tr_sessionIsRPCEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->isEnabled();
 }
 
 void tr_sessionSetRPCPort(tr_session* session, uint16_t hport)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     if (session->rpc_server_)
     {
@@ -2479,28 +2478,28 @@ void tr_sessionSetRPCPort(tr_session* session, uint16_t hport)
 
 uint16_t tr_sessionGetRPCPort(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_ ? session->rpc_server_->port().host() : uint16_t{};
 }
 
 void tr_sessionSetRPCUrl(tr_session* session, char const* url)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_server_->setUrl(url != nullptr ? url : "");
 }
 
 char const* tr_sessionGetRPCUrl(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->url().c_str();
 }
 
 void tr_sessionSetRPCCallback(tr_session* session, tr_rpc_func func, void* user_data)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_func = func;
     session->rpc_func_user_data = user_data;
@@ -2508,70 +2507,70 @@ void tr_sessionSetRPCCallback(tr_session* session, tr_rpc_func func, void* user_
 
 void tr_sessionSetRPCWhitelist(tr_session* session, char const* whitelist)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->setRpcWhitelist(whitelist != nullptr ? whitelist : "");
 }
 
 char const* tr_sessionGetRPCWhitelist(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->whitelist().c_str();
 }
 
 void tr_sessionSetRPCWhitelistEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->useRpcWhitelist(enabled);
 }
 
 bool tr_sessionGetRPCWhitelistEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->useRpcWhitelist();
 }
 
 void tr_sessionSetRPCPassword(tr_session* session, char const* password)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_server_->setPassword(password != nullptr ? password : "");
 }
 
 char const* tr_sessionGetRPCPassword(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->getSaltedPassword().c_str();
 }
 
 void tr_sessionSetRPCUsername(tr_session* session, char const* username)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_server_->setUsername(username != nullptr ? username : "");
 }
 
 char const* tr_sessionGetRPCUsername(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->username().c_str();
 }
 
 void tr_sessionSetRPCPasswordEnabled(tr_session* session, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_server_->setPasswordEnabled(enabled);
 }
 
 bool tr_sessionIsRPCPasswordEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->isPasswordEnabled();
 }
@@ -2582,7 +2581,7 @@ bool tr_sessionIsRPCPasswordEnabled(tr_session const* session)
 
 void tr_sessionSetScriptEnabled(tr_session* session, TrScript type, bool enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(type < TR_SCRIPT_N_TYPES);
 
     session->useScript(type, enabled);
@@ -2590,7 +2589,7 @@ void tr_sessionSetScriptEnabled(tr_session* session, TrScript type, bool enabled
 
 bool tr_sessionIsScriptEnabled(tr_session const* session, TrScript type)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(type < TR_SCRIPT_N_TYPES);
 
     return session->useScript(type);
@@ -2598,7 +2597,7 @@ bool tr_sessionIsScriptEnabled(tr_session const* session, TrScript type)
 
 void tr_sessionSetScript(tr_session* session, TrScript type, char const* script)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(type < TR_SCRIPT_N_TYPES);
 
     session->setScript(type, script != nullptr ? script : "");
@@ -2606,7 +2605,7 @@ void tr_sessionSetScript(tr_session* session, TrScript type, char const* script)
 
 char const* tr_sessionGetScript(tr_session const* session, TrScript type)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(type < TR_SCRIPT_N_TYPES);
 
     return session->script(type).c_str();
@@ -2618,7 +2617,7 @@ char const* tr_sessionGetScript(tr_session const* session, TrScript type)
 
 void tr_sessionSetQueueSize(tr_session* session, tr_direction dir, int max_simultaneous_seed_torrents)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(tr_isDirection(dir));
 
     session->queue_size_[dir] = max_simultaneous_seed_torrents;
@@ -2626,7 +2625,7 @@ void tr_sessionSetQueueSize(tr_session* session, tr_direction dir, int max_simul
 
 int tr_sessionGetQueueSize(tr_session const* session, tr_direction dir)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(tr_isDirection(dir));
 
     return session->queueSize(dir);
@@ -2634,7 +2633,7 @@ int tr_sessionGetQueueSize(tr_session const* session, tr_direction dir)
 
 void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_limit_simultaneous_seed_torrents)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(tr_isDirection(dir));
 
     session->queue_enabled_[dir] = do_limit_simultaneous_seed_torrents;
@@ -2642,7 +2641,7 @@ void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_li
 
 bool tr_sessionGetQueueEnabled(tr_session const* session, tr_direction dir)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(tr_isDirection(dir));
 
     return session->queueEnabled(dir);
@@ -2650,7 +2649,7 @@ bool tr_sessionGetQueueEnabled(tr_session const* session, tr_direction dir)
 
 void tr_sessionSetQueueStalledMinutes(tr_session* session, int minutes)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(minutes > 0);
 
     session->queue_stalled_minutes_ = minutes;
@@ -2658,28 +2657,28 @@ void tr_sessionSetQueueStalledMinutes(tr_session* session, int minutes)
 
 void tr_sessionSetQueueStalledEnabled(tr_session* session, bool is_enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->queue_stalled_enabled_ = is_enabled;
 }
 
 bool tr_sessionGetQueueStalledEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->queueStalledEnabled();
 }
 
 int tr_sessionGetQueueStalledMinutes(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->queueStalledMinutes();
 }
 
 void tr_sessionSetAntiBruteForceThreshold(tr_session* session, int max_bad_requests)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(max_bad_requests > 0);
 
     session->rpc_server_->setAntiBruteForceLimit(max_bad_requests);
@@ -2687,28 +2686,28 @@ void tr_sessionSetAntiBruteForceThreshold(tr_session* session, int max_bad_reque
 
 int tr_sessionGetAntiBruteForceThreshold(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->getAntiBruteForceLimit();
 }
 
 void tr_sessionSetAntiBruteForceEnabled(tr_session* session, bool is_enabled)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     session->rpc_server_->setAntiBruteForceEnabled(is_enabled);
 }
 
 bool tr_sessionGetAntiBruteForceEnabled(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     return session->rpc_server_->isAntiBruteForceEnabled();
 }
 
 std::vector<tr_torrent*> tr_sessionGetNextQueuedTorrents(tr_session* session, tr_direction direction, size_t num_wanted)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(tr_isDirection(direction));
 
     // build an array of the candidates

libtransmission/session.h

@@ -479,8 +479,6 @@ public:
 
     struct tr_turtle_info turtle;
 
-    int magicNumber = 0;
-
     struct evdns_base* evdns_base = nullptr;
     struct tr_event_handle* events = nullptr;
 
@@ -758,16 +756,6 @@ int tr_sessionCountTorrents(tr_session const* session);
 
 std::vector<tr_torrent*> tr_sessionGetTorrents(tr_session* session);
 
-enum
-{
-    SESSION_MAGIC_NUMBER = 3845,
-};
-
-constexpr bool tr_isSession(tr_session const* session)
-{
-    return session != nullptr && session->magicNumber == SESSION_MAGIC_NUMBER;
-}
-
 constexpr bool tr_isPriority(tr_priority_t p)
 {
     return p == TR_PRI_LOW || p == TR_PRI_NORMAL || p == TR_PRI_HIGH;

libtransmission/torrent.cc

@@ -864,7 +864,7 @@ tr_torrent* tr_torrentNew(tr_ctor* ctor, tr_torrent** setme_duplicate_of)
 {
     TR_ASSERT(ctor != nullptr);
     auto* const session = tr_ctorGetSession(ctor);
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     // is the metainfo valid?
     auto metainfo = tr_ctorStealMetainfo(ctor);
@@ -1614,7 +1614,7 @@ void tr_torrentFree(tr_torrent* tor)
     {
         tr_session* session = tor->session;
 
-        TR_ASSERT(tr_isSession(session));
+        TR_ASSERT(session != nullptr);
 
         auto const lock = tor->unique_lock();
 

libtransmission/torrent.h

@@ -755,7 +755,7 @@ private:
 
 constexpr bool tr_isTorrent(tr_torrent const* tor)
 {
-    return tor != nullptr && tr_isSession(tor->session);
+    return tor != nullptr && tor->session != nullptr;
 }
 
 /**

libtransmission/tr-dht.cc

@@ -680,7 +680,7 @@ void tr_dhtUpkeep(tr_session* session)
 
 void tr_dhtCallback(unsigned char* buf, int buflen, struct sockaddr* from, socklen_t fromlen, void* sv)
 {
-    TR_ASSERT(tr_isSession(static_cast<tr_session*>(sv)));
+    TR_ASSERT(sv != nullptr);
 
     if (sv != session_)
     {

libtransmission/tr-lpd.cc

@@ -553,7 +553,7 @@ static int tr_lpdAnnounceMore(time_t const now, int const interval)
 {
     int announcesSent = 0;
 
-    if (!tr_isSession(session))
+    if (session == nullptr)
     {
         return -1;
     }
@@ -629,7 +629,7 @@ static void on_upkeep_timer()
 * @see DoS */
 static void event_callback(evutil_socket_t /*s*/, short type, void* /*user_data*/)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     /* do not allow announces to be processed if LPD is disabled */
     if (!tr_sessionAllowsLPD(session))

libtransmission/tr-udp.cc

@@ -224,7 +224,7 @@ FAIL:
 
 static void event_callback(evutil_socket_t s, [[maybe_unused]] short type, void* vsession)
 {
-    TR_ASSERT(tr_isSession(static_cast<tr_session*>(vsession)));
+    TR_ASSERT(vsession != nullptr);
     TR_ASSERT(type == EV_READ);
 
     unsigned char buf[4096];

libtransmission/tr-utp.cc

@@ -131,7 +131,7 @@ static uint64 utp_callback(utp_callback_arguments* args)
 {
     auto* const session = static_cast<tr_session*>(utp_context_get_userdata(args->context));
 
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(session->utp_context == args->context);
 
     switch (args->callback_type)

libtransmission/trevent.cc

@@ -231,7 +231,7 @@ void tr_eventInit(tr_session* session)
 
 void tr_eventClose(tr_session* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
 
     auto* events = session->events;
     if (events == nullptr)
@@ -250,7 +250,7 @@ void tr_eventClose(tr_session* session)
 
 bool tr_amInEventThread(tr_session const* session)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     TR_ASSERT(session->events != nullptr);
 
     return std::this_thread::get_id() == session->events->thread_id;
@@ -262,7 +262,7 @@ bool tr_amInEventThread(tr_session const* session)
 
 void tr_runInEventThread(tr_session* session, std::function<void(void)>&& func)
 {
-    TR_ASSERT(tr_isSession(session));
+    TR_ASSERT(session != nullptr);
     auto* events = session->events;
     TR_ASSERT(events != nullptr);