mirror of https://github.com/PurpleI2P/i2pd
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
11 KiB
C++
329 lines
11 KiB
C++
#include <fstream>
|
|
#include <iostream>
|
|
#include <boost/property_tree/ptree.hpp>
|
|
#include <boost/property_tree/ini_parser.hpp>
|
|
#include "util.h"
|
|
#include "Log.h"
|
|
#include "Identity.h"
|
|
#include "ClientContext.h"
|
|
|
|
namespace i2p
|
|
{
|
|
namespace client
|
|
{
|
|
ClientContext context;
|
|
|
|
ClientContext::ClientContext (): m_SharedLocalDestination (nullptr),
|
|
m_HttpProxy (nullptr), m_SocksProxy (nullptr), m_SamBridge (nullptr),
|
|
m_BOBCommandChannel (nullptr)
|
|
{
|
|
}
|
|
|
|
ClientContext::~ClientContext ()
|
|
{
|
|
delete m_HttpProxy;
|
|
delete m_SocksProxy;
|
|
delete m_SamBridge;
|
|
delete m_BOBCommandChannel;
|
|
}
|
|
|
|
void ClientContext::Start ()
|
|
{
|
|
if (!m_SharedLocalDestination)
|
|
{
|
|
m_SharedLocalDestination = CreateNewLocalDestination (); // non-public, DSA
|
|
m_Destinations[m_SharedLocalDestination->GetIdentity ()->GetIdentHash ()] = m_SharedLocalDestination;
|
|
m_SharedLocalDestination->Start ();
|
|
}
|
|
|
|
std::shared_ptr<ClientDestination> localDestination;
|
|
// proxies
|
|
std::string proxyKeys = i2p::util::config::GetArg("-proxykeys", "");
|
|
if (proxyKeys.length () > 0)
|
|
localDestination = LoadLocalDestination (proxyKeys, false);
|
|
m_HttpProxy = new i2p::proxy::HTTPProxy(i2p::util::config::GetArg("-httpproxyport", 4446), localDestination);
|
|
m_HttpProxy->Start();
|
|
LogPrint("HTTP Proxy started");
|
|
m_SocksProxy = new i2p::proxy::SOCKSProxy(i2p::util::config::GetArg("-socksproxyport", 4447), localDestination);
|
|
m_SocksProxy->Start();
|
|
LogPrint("SOCKS Proxy Started");
|
|
|
|
// I2P tunnels
|
|
std::string ircDestination = i2p::util::config::GetArg("-ircdest", "");
|
|
if (ircDestination.length () > 0) // ircdest is presented
|
|
{
|
|
localDestination = nullptr;
|
|
std::string ircKeys = i2p::util::config::GetArg("-irckeys", "");
|
|
if (ircKeys.length () > 0)
|
|
localDestination = LoadLocalDestination (ircKeys, false);
|
|
auto ircPort = i2p::util::config::GetArg("-ircport", 6668);
|
|
auto ircTunnel = new I2PClientTunnel (ircDestination, ircPort, localDestination);
|
|
ircTunnel->Start ();
|
|
m_ClientTunnels.insert (std::make_pair(ircPort, std::unique_ptr<I2PClientTunnel>(ircTunnel)));
|
|
LogPrint("IRC tunnel started");
|
|
}
|
|
std::string eepKeys = i2p::util::config::GetArg("-eepkeys", "");
|
|
if (eepKeys.length () > 0) // eepkeys file is presented
|
|
{
|
|
localDestination = LoadLocalDestination (eepKeys, true);
|
|
auto serverTunnel = new I2PServerTunnel (i2p::util::config::GetArg("-eephost", "127.0.0.1"),
|
|
i2p::util::config::GetArg("-eepport", 80), localDestination);
|
|
serverTunnel->Start ();
|
|
m_ServerTunnels.insert (std::make_pair(localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel)));
|
|
LogPrint("Server tunnel started");
|
|
}
|
|
ReadTunnels ();
|
|
|
|
// SAM
|
|
int samPort = i2p::util::config::GetArg("-samport", 0);
|
|
if (samPort)
|
|
{
|
|
m_SamBridge = new SAMBridge (samPort);
|
|
m_SamBridge->Start ();
|
|
LogPrint("SAM bridge started");
|
|
}
|
|
|
|
// BOB
|
|
int bobPort = i2p::util::config::GetArg("-bobport", 0);
|
|
if (bobPort)
|
|
{
|
|
m_BOBCommandChannel = new BOBCommandChannel (bobPort);
|
|
m_BOBCommandChannel->Start ();
|
|
LogPrint("BOB command channel started");
|
|
}
|
|
|
|
m_AddressBook.Start ();
|
|
}
|
|
|
|
void ClientContext::Stop ()
|
|
{
|
|
m_HttpProxy->Stop();
|
|
delete m_HttpProxy;
|
|
m_HttpProxy = nullptr;
|
|
LogPrint("HTTP Proxy stopped");
|
|
m_SocksProxy->Stop();
|
|
delete m_SocksProxy;
|
|
m_SocksProxy = nullptr;
|
|
LogPrint("SOCKS Proxy stopped");
|
|
for (auto& it: m_ClientTunnels)
|
|
{
|
|
it.second->Stop ();
|
|
LogPrint("I2P client tunnel on port ", it.first, " stopped");
|
|
}
|
|
m_ClientTunnels.clear ();
|
|
for (auto& it: m_ServerTunnels)
|
|
{
|
|
it.second->Stop ();
|
|
LogPrint("I2P server tunnel stopped");
|
|
}
|
|
m_ServerTunnels.clear ();
|
|
if (m_SamBridge)
|
|
{
|
|
m_SamBridge->Stop ();
|
|
delete m_SamBridge;
|
|
m_SamBridge = nullptr;
|
|
LogPrint("SAM brdige stopped");
|
|
}
|
|
if (m_BOBCommandChannel)
|
|
{
|
|
m_BOBCommandChannel->Stop ();
|
|
delete m_BOBCommandChannel;
|
|
m_BOBCommandChannel = nullptr;
|
|
LogPrint("BOB command channel stopped");
|
|
}
|
|
m_AddressBook.Stop ();
|
|
for (auto it: m_Destinations)
|
|
it.second->Stop ();
|
|
m_Destinations.clear ();
|
|
m_SharedLocalDestination = nullptr;
|
|
}
|
|
|
|
std::shared_ptr<ClientDestination> ClientContext::LoadLocalDestination (const std::string& filename, bool isPublic)
|
|
{
|
|
i2p::data::PrivateKeys keys;
|
|
std::string fullPath = i2p::util::filesystem::GetFullPath (filename);
|
|
std::ifstream s(fullPath.c_str (), std::ifstream::binary);
|
|
if (s.is_open ())
|
|
{
|
|
s.seekg (0, std::ios::end);
|
|
size_t len = s.tellg();
|
|
s.seekg (0, std::ios::beg);
|
|
uint8_t * buf = new uint8_t[len];
|
|
s.read ((char *)buf, len);
|
|
keys.FromBuffer (buf, len);
|
|
delete[] buf;
|
|
LogPrint ("Local address ", m_AddressBook.ToAddress(keys.GetPublic ()->GetIdentHash ()), " loaded");
|
|
}
|
|
else
|
|
{
|
|
LogPrint ("Can't open file ", fullPath, " Creating new one");
|
|
keys = i2p::data::PrivateKeys::CreateRandomKeys (i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256);
|
|
std::ofstream f (fullPath, std::ofstream::binary | std::ofstream::out);
|
|
size_t len = keys.GetFullLen ();
|
|
uint8_t * buf = new uint8_t[len];
|
|
len = keys.ToBuffer (buf, len);
|
|
f.write ((char *)buf, len);
|
|
delete[] buf;
|
|
|
|
LogPrint ("New private keys file ", fullPath, " for ", m_AddressBook.ToAddress(keys.GetPublic ()->GetIdentHash ()), " created");
|
|
}
|
|
|
|
std::shared_ptr<ClientDestination> localDestination = nullptr;
|
|
std::unique_lock<std::mutex> l(m_DestinationsMutex);
|
|
auto it = m_Destinations.find (keys.GetPublic ()->GetIdentHash ());
|
|
if (it != m_Destinations.end ())
|
|
{
|
|
LogPrint (eLogWarning, "Local destination ", m_AddressBook.ToAddress(keys.GetPublic ()->GetIdentHash ()), " alreday exists");
|
|
localDestination = it->second;
|
|
}
|
|
else
|
|
{
|
|
localDestination = std::make_shared<ClientDestination> (keys, isPublic);
|
|
m_Destinations[localDestination->GetIdentHash ()] = localDestination;
|
|
localDestination->Start ();
|
|
}
|
|
return localDestination;
|
|
}
|
|
|
|
std::shared_ptr<ClientDestination> ClientContext::CreateNewLocalDestination (bool isPublic, i2p::data::SigningKeyType sigType,
|
|
const std::map<std::string, std::string> * params)
|
|
{
|
|
i2p::data::PrivateKeys keys = i2p::data::PrivateKeys::CreateRandomKeys (sigType);
|
|
auto localDestination = std::make_shared<ClientDestination> (keys, isPublic, params);
|
|
std::unique_lock<std::mutex> l(m_DestinationsMutex);
|
|
m_Destinations[localDestination->GetIdentHash ()] = localDestination;
|
|
localDestination->Start ();
|
|
return localDestination;
|
|
}
|
|
|
|
void ClientContext::DeleteLocalDestination (std::shared_ptr<ClientDestination> destination)
|
|
{
|
|
if (!destination) return;
|
|
auto it = m_Destinations.find (destination->GetIdentHash ());
|
|
if (it != m_Destinations.end ())
|
|
{
|
|
auto d = it->second;
|
|
{
|
|
std::unique_lock<std::mutex> l(m_DestinationsMutex);
|
|
m_Destinations.erase (it);
|
|
}
|
|
d->Stop ();
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<ClientDestination> ClientContext::CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic,
|
|
const std::map<std::string, std::string> * params)
|
|
{
|
|
auto it = m_Destinations.find (keys.GetPublic ()->GetIdentHash ());
|
|
if (it != m_Destinations.end ())
|
|
{
|
|
LogPrint ("Local destination ", m_AddressBook.ToAddress(keys.GetPublic ()->GetIdentHash ()), " exists");
|
|
if (!it->second->IsRunning ())
|
|
{
|
|
it->second->Start ();
|
|
return it->second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
auto localDestination = std::make_shared<ClientDestination> (keys, isPublic, params);
|
|
std::unique_lock<std::mutex> l(m_DestinationsMutex);
|
|
m_Destinations[keys.GetPublic ()->GetIdentHash ()] = localDestination;
|
|
localDestination->Start ();
|
|
return localDestination;
|
|
}
|
|
|
|
std::shared_ptr<ClientDestination> ClientContext::FindLocalDestination (const i2p::data::IdentHash& destination) const
|
|
{
|
|
auto it = m_Destinations.find (destination);
|
|
if (it != m_Destinations.end ())
|
|
return it->second;
|
|
return nullptr;
|
|
}
|
|
|
|
void ClientContext::ReadTunnels ()
|
|
{
|
|
boost::property_tree::ptree pt;
|
|
try
|
|
{
|
|
boost::property_tree::read_ini (i2p::util::filesystem::GetFullPath (TUNNELS_CONFIG_FILENAME), pt);
|
|
}
|
|
catch (std::exception& ex)
|
|
{
|
|
LogPrint (eLogWarning, "Can't read ", TUNNELS_CONFIG_FILENAME, ": ", ex.what ());
|
|
return;
|
|
}
|
|
|
|
int numClientTunnels = 0, numServerTunnels = 0;
|
|
for (auto& section: pt)
|
|
{
|
|
std::string name = section.first;
|
|
try
|
|
{
|
|
std::string type = section.second.get<std::string> (I2P_TUNNELS_SECTION_TYPE);
|
|
if (type == I2P_TUNNELS_SECTION_TYPE_CLIENT)
|
|
{
|
|
// mandatory params
|
|
std::string dest = section.second.get<std::string> (I2P_CLIENT_TUNNEL_DESTINATION);
|
|
int port = section.second.get<int> (I2P_CLIENT_TUNNEL_PORT);
|
|
// optional params
|
|
std::string keys = section.second.get (I2P_CLIENT_TUNNEL_KEYS, "");
|
|
int destinationPort = section.second.get (I2P_CLIENT_TUNNEL_DESTINATION_PORT, 0);
|
|
|
|
std::shared_ptr<ClientDestination> localDestination = nullptr;
|
|
if (keys.length () > 0)
|
|
localDestination = LoadLocalDestination (keys, false);
|
|
auto clientTunnel = new I2PClientTunnel (dest, port, localDestination, destinationPort);
|
|
if (m_ClientTunnels.insert (std::make_pair (port, std::unique_ptr<I2PClientTunnel>(clientTunnel))).second)
|
|
clientTunnel->Start ();
|
|
else
|
|
LogPrint (eLogError, "I2P client tunnel with port ", port, " already exists");
|
|
numClientTunnels++;
|
|
}
|
|
else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER || type == I2P_TUNNELS_SECTION_TYPE_HTTP)
|
|
{
|
|
// mandatory params
|
|
std::string host = section.second.get<std::string> (I2P_SERVER_TUNNEL_HOST);
|
|
int port = section.second.get<int> (I2P_SERVER_TUNNEL_PORT);
|
|
std::string keys = section.second.get<std::string> (I2P_SERVER_TUNNEL_KEYS);
|
|
// optional params
|
|
int inPort = section.second.get (I2P_SERVER_TUNNEL_INPORT, 0);
|
|
std::string accessList = section.second.get (I2P_SERVER_TUNNEL_ACCESS_LIST, "");
|
|
|
|
auto localDestination = LoadLocalDestination (keys, true);
|
|
I2PServerTunnel * serverTunnel = (type == I2P_TUNNELS_SECTION_TYPE_HTTP) ? new I2PServerTunnelHTTP (host, port, localDestination, inPort) : new I2PServerTunnel (host, port, localDestination, inPort);
|
|
if (accessList.length () > 0)
|
|
{
|
|
std::set<i2p::data::IdentHash> idents;
|
|
size_t pos = 0, comma;
|
|
do
|
|
{
|
|
comma = accessList.find (',', pos);
|
|
i2p::data::IdentHash ident;
|
|
ident.FromBase32 (accessList.substr (pos, comma != std::string::npos ? comma - pos : std::string::npos));
|
|
idents.insert (ident);
|
|
pos = comma + 1;
|
|
}
|
|
while (comma != std::string::npos);
|
|
serverTunnel->SetAccessList (idents);
|
|
}
|
|
if (m_ServerTunnels.insert (std::make_pair (localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel))).second)
|
|
serverTunnel->Start ();
|
|
else
|
|
LogPrint (eLogError, "I2P server tunnel for destination ", m_AddressBook.ToAddress(localDestination->GetIdentHash ()), " already exists");
|
|
numServerTunnels++;
|
|
}
|
|
else
|
|
LogPrint (eLogWarning, "Unknown section type=", type, " of ", name, " in ", TUNNELS_CONFIG_FILENAME);
|
|
|
|
}
|
|
catch (std::exception& ex)
|
|
{
|
|
LogPrint (eLogError, "Can't read tunnel ", name, " params: ", ex.what ());
|
|
}
|
|
}
|
|
LogPrint (eLogInfo, numClientTunnels, " I2P client tunnels created");
|
|
LogPrint (eLogInfo, numServerTunnels, " I2P server tunnels created");
|
|
}
|
|
}
|
|
}
|