#include "util.h" #include "Log.h" #include "ClientContext.h" namespace i2p { namespace client { ClientContext context; ClientContext::ClientContext (): m_SharedLocalDestination (nullptr), m_HttpProxy (nullptr), m_SocksProxy (nullptr), m_IrcTunnel (nullptr), m_ServerTunnel (nullptr), m_SamBridge (nullptr) { } ClientContext::~ClientContext () { delete m_HttpProxy; delete m_SocksProxy; delete m_IrcTunnel; delete m_ServerTunnel; delete m_SamBridge; } void ClientContext::Start () { if (!m_SharedLocalDestination) { m_SharedLocalDestination = new i2p::stream::StreamingDestination (false, i2p::data::SIGNING_KEY_TYPE_DSA_SHA1); // non-public, DSA m_Destinations[m_SharedLocalDestination->GetIdentity ().GetIdentHash ()] = m_SharedLocalDestination; m_SharedLocalDestination->Start (); } m_HttpProxy = new i2p::proxy::HTTPProxy(i2p::util::config::GetArg("-httpproxyport", 4446)); m_HttpProxy->Start(); LogPrint("HTTP Proxy started"); m_SocksProxy = new i2p::proxy::SOCKSProxy(i2p::util::config::GetArg("-socksproxyport", 4447)); m_SocksProxy->Start(); LogPrint("SOCKS Proxy Started"); std::string ircDestination = i2p::util::config::GetArg("-ircdest", ""); if (ircDestination.length () > 0) // ircdest is presented { i2p::stream::StreamingDestination * localDestination = nullptr; std::string ircKeys = i2p::util::config::GetArg("-irckeys", ""); if (ircKeys.length () > 0) localDestination = i2p::client::context.LoadLocalDestination (ircKeys, false); m_IrcTunnel = new I2PClientTunnel (m_SocksProxy->GetService (), ircDestination, i2p::util::config::GetArg("-ircport", 6668), localDestination); m_IrcTunnel->Start (); LogPrint("IRC tunnel started"); } std::string eepKeys = i2p::util::config::GetArg("-eepkeys", ""); if (eepKeys.length () > 0) // eepkeys file is presented { auto localDestination = i2p::client::context.LoadLocalDestination (eepKeys, true); m_ServerTunnel = new I2PServerTunnel (m_SocksProxy->GetService (), i2p::util::config::GetArg("-eephost", "127.0.0.1"), i2p::util::config::GetArg("-eepport", 80), localDestination); m_ServerTunnel->Start (); LogPrint("Server tunnel started"); } int samPort = i2p::util::config::GetArg("-samport", 0); if (samPort) { m_SamBridge = new SAMBridge (samPort); m_SamBridge->Start (); LogPrint("SAM bridge started"); } } void ClientContext::Stop () { m_HttpProxy->Stop(); delete m_HttpProxy; m_HttpProxy = nullptr; LogPrint("HTTP Proxy stoped"); m_SocksProxy->Stop(); delete m_SocksProxy; m_SocksProxy = nullptr; LogPrint("SOCKS Proxy stoped"); if (m_IrcTunnel) { m_IrcTunnel->Stop (); delete m_IrcTunnel; m_IrcTunnel = nullptr; LogPrint("IRC tunnel stoped"); } if (m_ServerTunnel) { m_ServerTunnel->Stop (); delete m_ServerTunnel; m_ServerTunnel = nullptr; LogPrint("Server tunnel stoped"); } if (m_SamBridge) { m_SamBridge->Stop (); delete m_SamBridge; m_SamBridge = nullptr; LogPrint("SAM brdige stoped"); } for (auto it: m_Destinations) { it.second->Stop (); delete it.second; } m_Destinations.clear (); m_SharedLocalDestination = 0; // deleted through m_Destination } void ClientContext::LoadLocalDestinations () { int numDestinations = 0; boost::filesystem::path p (i2p::util::filesystem::GetDataDir()); boost::filesystem::directory_iterator end; for (boost::filesystem::directory_iterator it (p); it != end; ++it) { if (boost::filesystem::is_regular_file (*it) && it->path ().extension () == ".dat") { auto fullPath = #if BOOST_VERSION > 10500 it->path().string(); #else it->path(); #endif auto localDestination = new i2p::stream::StreamingDestination (fullPath, true); m_Destinations[localDestination->GetIdentHash ()] = localDestination; numDestinations++; } } if (numDestinations > 0) LogPrint (numDestinations, " local destinations loaded"); } i2p::stream::StreamingDestination * ClientContext::LoadLocalDestination (const std::string& filename, bool isPublic) { auto localDestination = new i2p::stream::StreamingDestination (i2p::util::filesystem::GetFullPath (filename), isPublic); std::unique_lock l(m_DestinationsMutex); m_Destinations[localDestination->GetIdentHash ()] = localDestination; localDestination->Start (); return localDestination; } i2p::stream::StreamingDestination * ClientContext::CreateNewLocalDestination (bool isPublic, i2p::data::SigningKeyType sigType) { auto localDestination = new i2p::stream::StreamingDestination (isPublic, sigType); std::unique_lock l(m_DestinationsMutex); m_Destinations[localDestination->GetIdentHash ()] = localDestination; localDestination->Start (); return localDestination; } void ClientContext::DeleteLocalDestination (i2p::stream::StreamingDestination * destination) { if (!destination) return; auto it = m_Destinations.find (destination->GetIdentHash ()); if (it != m_Destinations.end ()) { auto d = it->second; { std::unique_lock l(m_DestinationsMutex); m_Destinations.erase (it); } d->Stop (); delete d; } } i2p::stream::StreamingDestination * ClientContext::CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic) { auto it = m_Destinations.find (keys.GetPublic ().GetIdentHash ()); if (it != m_Destinations.end ()) { LogPrint ("Local destination ", keys.GetPublic ().GetIdentHash ().ToBase32 (), ".b32.i2p exists"); if (!it->second->IsRunning ()) { it->second->Start (); return it->second; } return nullptr; } auto localDestination = new i2p::stream::StreamingDestination (keys, isPublic); std::unique_lock l(m_DestinationsMutex); m_Destinations[keys.GetPublic ().GetIdentHash ()] = localDestination; localDestination->Start (); return localDestination; } i2p::stream::StreamingDestination * ClientContext::FindLocalDestination (const i2p::data::IdentHash& destination) const { auto it = m_Destinations.find (destination); if (it != m_Destinations.end ()) return it->second; return nullptr; } } }