/*
* Copyright ( c ) 2013 - 2024 , The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/
# include "Log.h"
# include "Base.h"
# include "I2NPProtocol.h"
# include "Transports.h"
# include "NetDb.hpp"
# include "NetDbRequests.h"
# include "ECIESX25519AEADRatchetSession.h"
# include "RouterContext.h"
namespace i2p
{
namespace data
{
RequestedDestination : : RequestedDestination ( const IdentHash & destination , bool isExploratory , bool direct ) :
m_Destination ( destination ) , m_IsExploratory ( isExploratory ) , m_IsDirect ( direct ) , m_IsActive ( true ) ,
m_CreationTime ( i2p : : util : : GetSecondsSinceEpoch ( ) ) , m_LastRequestTime ( 0 ) , m_NumAttempts ( 0 )
{
if ( i2p : : context . IsFloodfill ( ) )
m_ExcludedPeers . insert ( i2p : : context . GetIdentHash ( ) ) ; // exclude self if floodfill
}
RequestedDestination : : ~ RequestedDestination ( )
{
if ( m_RequestComplete ) m_RequestComplete ( nullptr ) ;
}
std : : shared_ptr < I2NPMessage > RequestedDestination : : CreateRequestMessage ( std : : shared_ptr < const RouterInfo > router ,
std : : shared_ptr < const i2p : : tunnel : : InboundTunnel > replyTunnel )
{
std : : lock_guard < std : : mutex > l ( m_ExcludedPeersMutex ) ;
std : : shared_ptr < I2NPMessage > msg ;
if ( replyTunnel )
msg = i2p : : CreateRouterInfoDatabaseLookupMsg ( m_Destination ,
replyTunnel - > GetNextIdentHash ( ) , replyTunnel - > GetNextTunnelID ( ) , m_IsExploratory ,
& m_ExcludedPeers ) ;
else
msg = i2p : : CreateRouterInfoDatabaseLookupMsg ( m_Destination , i2p : : context . GetIdentHash ( ) , 0 , m_IsExploratory , & m_ExcludedPeers ) ;
if ( router )
m_ExcludedPeers . insert ( router - > GetIdentHash ( ) ) ;
m_LastRequestTime = i2p : : util : : GetSecondsSinceEpoch ( ) ;
m_NumAttempts + + ;
return msg ;
}
std : : shared_ptr < I2NPMessage > RequestedDestination : : CreateRequestMessage ( const IdentHash & floodfill )
{
std : : lock_guard < std : : mutex > l ( m_ExcludedPeersMutex ) ;
auto msg = i2p : : CreateRouterInfoDatabaseLookupMsg ( m_Destination ,
i2p : : context . GetRouterInfo ( ) . GetIdentHash ( ) , 0 , false , & m_ExcludedPeers ) ;
m_ExcludedPeers . insert ( floodfill ) ;
m_NumAttempts + + ;
m_LastRequestTime = i2p : : util : : GetSecondsSinceEpoch ( ) ;
return msg ;
}
bool RequestedDestination : : IsExcluded ( const IdentHash & ident ) const
{
std : : lock_guard < std : : mutex > l ( m_ExcludedPeersMutex ) ;
return m_ExcludedPeers . count ( ident ) ;
}
void RequestedDestination : : ClearExcludedPeers ( )
{
std : : lock_guard < std : : mutex > l ( m_ExcludedPeersMutex ) ;
m_ExcludedPeers . clear ( ) ;
}
std : : unordered_set < IdentHash > RequestedDestination : : GetExcludedPeers ( ) const
{
std : : lock_guard < std : : mutex > l ( m_ExcludedPeersMutex ) ;
return m_ExcludedPeers ;
}
void RequestedDestination : : Success ( std : : shared_ptr < RouterInfo > r )
{
if ( m_IsActive )
{
m_IsActive = false ;
if ( m_RequestComplete )
{
m_RequestComplete ( r ) ;
m_RequestComplete = nullptr ;
}
}
}
void RequestedDestination : : Fail ( )
{
if ( m_IsActive )
{
m_IsActive = false ;
if ( m_RequestComplete )
{
m_RequestComplete ( nullptr ) ;
m_RequestComplete = nullptr ;
}
}
}
NetDbRequests : : NetDbRequests ( ) :
RunnableServiceWithWork ( " NetDbReq " ) ,
m_ManageRequestsTimer ( GetIOService ( ) )
{
}
NetDbRequests : : ~ NetDbRequests ( )
{
Stop ( ) ;
}
void NetDbRequests : : Start ( )
{
m_LastPoolCleanUpTime = i2p : : util : : GetSecondsSinceEpoch ( ) ;
if ( ! IsRunning ( ) )
{
StartIOService ( ) ;
ScheduleManageRequests ( ) ;
}
}
void NetDbRequests : : Stop ( )
{
if ( IsRunning ( ) )
{
m_ManageRequestsTimer . cancel ( ) ;
StopIOService ( ) ;
m_RequestedDestinations . clear ( ) ;
m_RequestedDestinationsPool . CleanUpMt ( ) ;
}
}
std : : shared_ptr < RequestedDestination > NetDbRequests : : CreateRequest ( const IdentHash & destination ,
bool isExploratory , bool direct , RequestedDestination : : RequestComplete requestComplete )
{
// request RouterInfo directly
auto dest = m_RequestedDestinationsPool . AcquireSharedMt ( destination , isExploratory , direct ) ;
dest - > SetRequestComplete ( requestComplete ) ;
{
std : : unique_lock < std : : mutex > l ( m_RequestedDestinationsMutex ) ;
auto ret = m_RequestedDestinations . emplace ( destination , dest ) ;
if ( ! ret . second ) // not inserted
{
dest - > SetRequestComplete ( nullptr ) ; // don't call requestComplete in destructor
dest = ret . first - > second ; // existing one
if ( requestComplete & & dest - > IsActive ( ) )
{
auto prev = dest - > GetRequestComplete ( ) ;
if ( prev ) // if already set
dest - > SetRequestComplete (
[ requestComplete , prev ] ( std : : shared_ptr < RouterInfo > r )
{
prev ( r ) ; // call previous
requestComplete ( r ) ; // then new
} ) ;
else
dest - > SetRequestComplete ( requestComplete ) ;
}
return nullptr ;
}
}
return dest ;
}
void NetDbRequests : : RequestComplete ( const IdentHash & ident , std : : shared_ptr < RouterInfo > r )
{
std : : shared_ptr < RequestedDestination > request ;
{
std : : unique_lock < std : : mutex > l ( m_RequestedDestinationsMutex ) ;
auto it = m_RequestedDestinations . find ( ident ) ;
if ( it ! = m_RequestedDestinations . end ( ) )
{
request = it - > second ;
if ( request - > IsExploratory ( ) )
m_RequestedDestinations . erase ( it ) ;
// otherwise cache for a while
}
}
if ( request )
{
if ( r )
request - > Success ( r ) ;
else
request - > Fail ( ) ;
}
}
std : : shared_ptr < RequestedDestination > NetDbRequests : : FindRequest ( const IdentHash & ident ) const
{
std : : unique_lock < std : : mutex > l ( m_RequestedDestinationsMutex ) ;
auto it = m_RequestedDestinations . find ( ident ) ;
if ( it ! = m_RequestedDestinations . end ( ) )
return it - > second ;
return nullptr ;
}
void NetDbRequests : : ManageRequests ( )
{
uint64_t ts = i2p : : util : : GetSecondsSinceEpoch ( ) ;
if ( ts > m_LastPoolCleanUpTime + REQUESTED_DESTINATIONS_POOL_CLEANUP_INTERVAL )
{
m_RequestedDestinationsPool . CleanUpMt ( ) ;
m_LastPoolCleanUpTime = ts ;
}
std : : unique_lock < std : : mutex > l ( m_RequestedDestinationsMutex ) ;
for ( auto it = m_RequestedDestinations . begin ( ) ; it ! = m_RequestedDestinations . end ( ) ; )
{
auto & dest = it - > second ;
if ( dest - > IsActive ( ) | | ts < dest - > GetCreationTime ( ) + REQUEST_CACHE_TIME )
{
if ( ! dest - > IsExploratory ( ) )
{
// regular request
bool done = false ;
if ( ts < dest - > GetCreationTime ( ) + MAX_REQUEST_TIME )
{
if ( ts > dest - > GetLastRequestTime ( ) + MIN_REQUEST_TIME ) // try next floodfill if no response after min interval
done = ! SendNextRequest ( dest ) ;
}
else // request is expired
done = true ;
if ( done )
dest - > Fail ( ) ;
it + + ;
}
else
{
// exploratory
if ( ts > = dest - > GetCreationTime ( ) + MAX_EXPLORATORY_REQUEST_TIME )
{
dest - > Fail ( ) ;
it = m_RequestedDestinations . erase ( it ) ; // delete expired exploratory request right a way
}
else
it + + ;
}
}
else
it = m_RequestedDestinations . erase ( it ) ;
}
}
bool NetDbRequests : : SendNextRequest ( std : : shared_ptr < RequestedDestination > dest )
{
if ( ! dest | | ! dest - > IsActive ( ) ) return false ;
bool ret = true ;
auto count = dest - > GetNumAttempts ( ) ;
if ( ! dest - > IsExploratory ( ) & & count < MAX_NUM_REQUEST_ATTEMPTS )
{
auto nextFloodfill = netdb . GetClosestFloodfill ( dest - > GetDestination ( ) , dest - > GetExcludedPeers ( ) ) ;
if ( nextFloodfill )
{
bool direct = dest - > IsDirect ( ) ;
if ( direct & & ! nextFloodfill - > IsReachableFrom ( i2p : : context . GetRouterInfo ( ) ) & &
! i2p : : transport : : transports . IsConnected ( nextFloodfill - > GetIdentHash ( ) ) )
direct = false ; // floodfill can't be reached directly
if ( direct )
{
if ( CheckLogLevel ( eLogDebug ) )
LogPrint ( eLogDebug , " NetDbReq: Try " , dest - > GetDestination ( ) . ToBase64 ( ) , " at " , count , " floodfill " , nextFloodfill - > GetIdentHash ( ) . ToBase64 ( ) , " directly " ) ;
auto msg = dest - > CreateRequestMessage ( nextFloodfill - > GetIdentHash ( ) ) ;
auto s = shared_from_this ( ) ;
msg - > onDrop = [ s , dest ] ( ) { if ( dest - > IsActive ( ) ) s - > SendNextRequest ( dest ) ; } ;
i2p : : transport : : transports . SendMessage ( nextFloodfill - > GetIdentHash ( ) , msg ) ;
}
else
{
auto pool = i2p : : tunnel : : tunnels . GetExploratoryPool ( ) ;
if ( pool )
{
auto outbound = pool - > GetNextOutboundTunnel ( ) ;
auto inbound = pool - > GetNextInboundTunnel ( ) ;
if ( nextFloodfill & & outbound & & inbound )
{
if ( CheckLogLevel ( eLogDebug ) )
LogPrint ( eLogDebug , " NetDbReq: Try " , dest - > GetDestination ( ) . ToBase64 ( ) , " at " , count , " floodfill " , nextFloodfill - > GetIdentHash ( ) . ToBase64 ( ) , " through tunnels " ) ;
auto msg = dest - > CreateRequestMessage ( nextFloodfill , inbound ) ;
auto s = shared_from_this ( ) ;
msg - > onDrop = [ s , dest ] ( ) { if ( dest - > IsActive ( ) ) s - > SendNextRequest ( dest ) ; } ;
outbound - > SendTunnelDataMsgTo ( nextFloodfill - > GetIdentHash ( ) , 0 ,
i2p : : garlic : : WrapECIESX25519MessageForRouter ( msg , nextFloodfill - > GetIdentity ( ) - > GetEncryptionPublicKey ( ) ) ) ;
}
else
{
ret = false ;
if ( ! inbound ) LogPrint ( eLogWarning , " NetDbReq: No inbound tunnels " ) ;
if ( ! outbound ) LogPrint ( eLogWarning , " NetDbReq: No outbound tunnels " ) ;
}
}
else
{
ret = false ;
LogPrint ( eLogWarning , " NetDbReq: Exploratory pool is not ready " ) ;
}
}
}
else
{
ret = false ;
LogPrint ( eLogWarning , " NetDbReq: No more floodfills for " , dest - > GetDestination ( ) . ToBase64 ( ) , " after " , count , " attempts " ) ;
}
}
else
{
if ( ! dest - > IsExploratory ( ) )
LogPrint ( eLogWarning , " NetDbReq: " , dest - > GetDestination ( ) . ToBase64 ( ) , " not found after " , MAX_NUM_REQUEST_ATTEMPTS , " attempts " ) ;
ret = false ;
}
return ret ;
}
void NetDbRequests : : ScheduleManageRequests ( )
{
m_ManageRequestsTimer . expires_from_now ( boost : : posix_time : : seconds ( MANAGE_REQUESTS_INTERVAL ) ) ;
m_ManageRequestsTimer . async_wait ( std : : bind ( & NetDbRequests : : HandleManageRequestsTimer ,
this , std : : placeholders : : _1 ) ) ;
}
void NetDbRequests : : HandleManageRequestsTimer ( const boost : : system : : error_code & ecode )
{
if ( ecode ! = boost : : asio : : error : : operation_aborted )
{
if ( i2p : : tunnel : : tunnels . GetExploratoryPool ( ) ) // expolratory pool is ready?
ManageRequests ( ) ;
ScheduleManageRequests ( ) ;
}
}
void NetDbRequests : : PostDatabaseSearchReplyMsg ( std : : shared_ptr < const I2NPMessage > msg )
{
GetIOService ( ) . post ( [ this , msg ] ( )
{
HandleDatabaseSearchReplyMsg ( msg ) ;
} ) ;
}
void NetDbRequests : : HandleDatabaseSearchReplyMsg ( std : : shared_ptr < const I2NPMessage > msg )
{
const uint8_t * buf = msg - > GetPayload ( ) ;
char key [ 48 ] ;
int l = i2p : : data : : ByteStreamToBase64 ( buf , 32 , key , 48 ) ;
key [ l ] = 0 ;
size_t num = buf [ 32 ] ; // num
LogPrint ( eLogDebug , " NetDbReq: DatabaseSearchReply for " , key , " num= " , num ) ;
IdentHash ident ( buf ) ;
auto dest = FindRequest ( ident ) ;
if ( dest & & dest - > IsActive ( ) )
{
if ( ! dest - > IsExploratory ( ) & & ( num > 0 | | dest - > GetNumAttempts ( ) < 3 ) ) // before 3-rd attempt might be just bad luck
{
// try to send next requests
if ( ! SendNextRequest ( dest ) )
RequestComplete ( ident , nullptr ) ;
}
else
// no more requests for destination possible. delete it
RequestComplete ( ident , nullptr ) ;
}
else /*if (!m_FloodfillBootstrap)*/
{
LogPrint ( eLogInfo , " NetDbReq: Unsolicited or late database search reply for " , key ) ;
return ;
}
// try responses
if ( num > NETDB_MAX_NUM_SEARCH_REPLY_PEER_HASHES )
{
LogPrint ( eLogWarning , " NetDbReq: Too many peer hashes " , num , " in database search reply, Reduced to " , NETDB_MAX_NUM_SEARCH_REPLY_PEER_HASHES ) ;
num = NETDB_MAX_NUM_SEARCH_REPLY_PEER_HASHES ;
}
for ( size_t i = 0 ; i < num ; i + + )
{
const uint8_t * router = buf + 33 + i * 32 ;
char peerHash [ 48 ] ;
int l1 = i2p : : data : : ByteStreamToBase64 ( router , 32 , peerHash , 48 ) ;
peerHash [ l1 ] = 0 ;
LogPrint ( eLogDebug , " NetDbReq: " , i , " : " , peerHash ) ;
auto r = netdb . FindRouter ( router ) ;
if ( ! r | | i2p : : util : : GetMillisecondsSinceEpoch ( ) > r - > GetTimestamp ( ) + 3600 * 1000LL )
{
// router with ident not found or too old (1 hour)
LogPrint ( eLogDebug , " NetDbReq: Found new/outdated router. Requesting RouterInfo... " ) ;
/* if(m_FloodfillBootstrap)
RequestDestinationFrom ( router , m_FloodfillBootstrap - > GetIdentHash ( ) , true ) ;
else */ if ( ! IsRouterBanned ( router ) )
netdb . RequestDestination ( router ) ;
else
LogPrint ( eLogDebug , " NetDbReq: Router " , peerHash , " is banned. Skipped " ) ;
}
else
LogPrint ( eLogDebug , " NetDbReq: [:|||:] " ) ;
}
}
}
}