mirrors/i2pd
2
0
Fork 0
mirror of https://github.com/PurpleI2P/i2pd synced 2024-11-13 01:20:22 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #237 from EinMByte/master

Browse Source 
Fixes for #235 and #233.
Also tested by psi, and seems to be working fine.
This commit is contained in:
EinMByte 2015-07-27 18:46:15 +02:00
commit 3f3103572a
20 changed files with 169 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
BOB.cpp
View File

@ -524,9 +524,11 @@ namespace client
SendReplyError ("malformed");
}
BOBCommandChannel::BOBCommandChannel (int port):
m_IsRunning (false), m_Thread (nullptr),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
BOBCommandChannel::BOBCommandChannel(const std::string& address, int port)
: m_IsRunning (false), m_Thread (nullptr),
m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
boost::asio::ip::address::from_string(address), port)
)
{
// command -> handler
m_CommandHandlers[BOB_COMMAND_ZAP] = &BOBCommandSession::ZapCommandHandler;

2
BOB.h
View File

@ -199,7 +199,7 @@ namespace client
{
public:
BOBCommandChannel (int port);
BOBCommandChannel(const std::string& address, int port);
~BOBCommandChannel ();
void Start ();

99
ClientContext.cpp
View File

@ -42,10 +42,18 @@ namespace client
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 = new i2p::proxy::HTTPProxy(
i2p::util::config::GetArg("-httpproxyaddress", "127.0.0.1"),
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 = new i2p::proxy::SOCKSProxy(
i2p::util::config::GetArg("-socksproxyaddress", "127.0.0.1"),
i2p::util::config::GetArg("-socksproxyport", 4447),
localDestination
);
m_SocksProxy->Start();
LogPrint("SOCKS Proxy Started");
@ -58,9 +66,15 @@ namespace client
if (ircKeys.length () > 0)
localDestination = LoadLocalDestination (ircKeys, false);
auto ircPort = i2p::util::config::GetArg("-ircport", 6668);
auto ircTunnel = new I2PClientTunnel (ircDestination, ircPort, localDestination);
auto ircTunnel = new I2PClientTunnel(
ircDestination, i2p::util::config::GetArg("-ircaddress", "127.0.0.1"),
ircPort, localDestination
);
ircTunnel->Start ();
m_ClientTunnels.insert (std::make_pair(ircPort, std::unique_ptr<I2PClientTunnel>(ircTunnel)));
// TODO: allow muliple tunnels on the same port (but on a different address)
m_ClientTunnels.insert(std::make_pair(
ircPort, std::unique_ptr<I2PClientTunnel>(ircTunnel)
));
LogPrint("IRC tunnel started");
}
std::string eepKeys = i2p::util::config::GetArg("-eepkeys", "");
@ -79,7 +93,9 @@ namespace client
int samPort = i2p::util::config::GetArg("-samport", 0);
if (samPort)
{
m_SamBridge = new SAMBridge (samPort);
m_SamBridge = new SAMBridge(
i2p::util::config::GetArg("-samaddress", "127.0.0.1"), samPort
);
m_SamBridge->Start ();
LogPrint("SAM bridge started");
}
@ -88,17 +104,21 @@ namespace client
int bobPort = i2p::util::config::GetArg("-bobport", 0);
if (bobPort)
{
m_BOBCommandChannel = new BOBCommandChannel (bobPort);
m_BOBCommandChannel = new BOBCommandChannel(
i2p::util::config::GetArg("-bobaddress", "127.0.0.1"), bobPort
);
m_BOBCommandChannel->Start ();
LogPrint("BOB command channel started");
}
// I2P Control
int i2pcontrolPort = i2p::util::config::GetArg("-i2pcontrolport", 0);
if (i2pcontrolPort)
{
m_I2PControlService = new I2PControlService (i2pcontrolPort);
m_I2PControlService->Start ();
if(i2pcontrolPort) {
m_I2PControlService = new I2PControlService(
i2p::util::config::GetArg("-i2pcontroladdress", "127.0.0.1"),
i2pcontrolPort
);
m_I2PControlService->Start();
LogPrint("I2PControl started");
}
m_AddressBook.Start ();
@ -259,43 +279,46 @@ namespace client
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 ());
try {
boost::property_tree::read_ini(
i2p::util::filesystem::GetFullPath(TUNNELS_CONFIG_FILENAME),
pt
);
} catch(const std::exception& ex) {
LogPrint(eLogWarning, "Can't read ", TUNNELS_CONFIG_FILENAME, ": ", ex.what ());
return;
}
int numClientTunnels = 0, numServerTunnels = 0;
for (auto& section: pt)
{
for(auto& section: pt) {
std::string name = section.first;
try
{
try {
std::string type = section.second.get<std::string> (I2P_TUNNELS_SECTION_TYPE);
if (type == I2P_TUNNELS_SECTION_TYPE_CLIENT)
{
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::string address = section.second.get(
I2P_CLIENT_TUNNEL_ADDRESS, "127.0.0.1"
);
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)
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)
auto clientTunnel = new I2PClientTunnel(
dest, address, port, localDestination, destinationPort
);
// TODO: allow muliple tunnels on the same port (but on a different address)
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)
} 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);
@ -307,19 +330,16 @@ namespace client
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)
{
if (accessList.length () > 0) {
std::set<i2p::data::IdentHash> idents;
size_t pos = 0, comma;
do
{
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);
} while (comma != std::string::npos);
serverTunnel->SetAccessList (idents);
}
if (m_ServerTunnels.insert (std::make_pair (localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel))).second)
@ -327,13 +347,10 @@ namespace client
else
LogPrint (eLogError, "I2P server tunnel for destination ", m_AddressBook.ToAddress(localDestination->GetIdentHash ()), " already exists");
numServerTunnels++;
}
else
} else
LogPrint (eLogWarning, "Unknown section type=", type, " of ", name, " in ", TUNNELS_CONFIG_FILENAME);
}
catch (std::exception& ex)
{
} catch (const std::exception& ex) {
LogPrint (eLogError, "Can't read tunnel ", name, " params: ", ex.what ());
}
}

1
ClientContext.h
View File

@ -22,6 +22,7 @@ namespace client
const char I2P_TUNNELS_SECTION_TYPE_SERVER[] = "server";
const char I2P_TUNNELS_SECTION_TYPE_HTTP[] = "http";
const char I2P_CLIENT_TUNNEL_PORT[] = "port";
const char I2P_CLIENT_TUNNEL_ADDRESS[] = "address";
const char I2P_CLIENT_TUNNEL_DESTINATION[] = "destination";
const char I2P_CLIENT_TUNNEL_KEYS[] = "keys";
const char I2P_CLIENT_TUNNEL_DESTINATION_PORT[] = "destinationport";

5
Daemon.cpp
View File

@ -106,7 +106,10 @@ namespace i2p
StartLog (""); // write to stdout
}
d.httpServer = new i2p::util::HTTPServer(i2p::util::config::GetArg("-httpport", 7070));
d.httpServer = new i2p::util::HTTPServer(
i2p::util::config::GetArg("-httpaddress", "127.0.0.1"),
i2p::util::config::GetArg("-httpport", 7070)
);
d.httpServer->Start();
LogPrint("HTTP Server started");
i2p::data::netdb.Start();

4
HTTPProxy.cpp
View File

@ -285,8 +285,8 @@ namespace proxy
}
}
HTTPProxyServer::HTTPProxyServer(int port, std::shared_ptr<i2p::client::ClientDestination> localDestination):
TCPIPAcceptor(port, localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination ())
HTTPProxyServer::HTTPProxyServer(const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination):
TCPIPAcceptor(address, port, localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination ())
{
}

2
HTTPProxy.h
View File

@ -16,7 +16,7 @@ namespace proxy
{
public:
HTTPProxyServer(int port, std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
HTTPProxyServer(const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
~HTTPProxyServer() {};
protected:

4
HTTPServer.cpp
View File

@ -1042,9 +1042,9 @@ namespace util
std::bind (&HTTPConnection::HandleWriteReply, shared_from_this (), std::placeholders::_1));
}
HTTPServer::HTTPServer (int port):
HTTPServer::HTTPServer (const std::string& address, int port):
m_Thread (nullptr), m_Work (m_Service),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4 (), port)),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint (boost::asio::ip::address::from_string(address), port)),
m_NewSocket (nullptr)
{

2
HTTPServer.h
View File

@ -107,7 +107,7 @@ namespace util
{
public:
HTTPServer (int port);
HTTPServer (const std::string& address, int port);
virtual ~HTTPServer ();
void Start ();

10
I2PControl.cpp
View File

@ -22,10 +22,12 @@ namespace i2p
{
namespace client
{
I2PControlService::I2PControlService (int port):
m_Password (I2P_CONTROL_DEFAULT_PASSWORD), m_IsRunning (false), m_Thread (nullptr),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
m_ShutdownTimer (m_Service)
I2PControlService::I2PControlService(const std::string& address, int port)
: m_Password(I2P_CONTROL_DEFAULT_PASSWORD), m_IsRunning(false),
m_Thread(nullptr), m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
boost::asio::ip::address::from_string(address), port)
),
m_ShutdownTimer (m_Service)
{
m_MethodHandlers[I2P_CONTROL_METHOD_AUTHENTICATE] = &I2PControlService::AuthenticateHandler;
m_MethodHandlers[I2P_CONTROL_METHOD_ECHO] = &I2PControlService::EchoHandler;

2
I2PControl.h
View File

@ -66,7 +66,7 @@ namespace client
{
public:
I2PControlService (int port);
I2PControlService(const std::string& address, int port);
~I2PControlService ();
void Start ();

14
I2PService.h
View File

@ -81,14 +81,12 @@ namespace client
class TCPIPAcceptor: public I2PService
{
public:
TCPIPAcceptor (int port, std::shared_ptr<ClientDestination> localDestination = nullptr) :
I2PService(localDestination),
m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4 (), port)),
m_Timer (GetService ()) {}
TCPIPAcceptor (int port, i2p::data::SigningKeyType kt) :
I2PService(kt),
m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4 (), port)),
m_Timer (GetService ()) {}
TCPIPAcceptor(const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination = nullptr)
: I2PService(localDestination), m_Acceptor(GetService(), boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(address), port)),
m_Timer (GetService()) {}
TCPIPAcceptor(const std::string& address, int port, i2p::data::SigningKeyType kt)
: I2PService(kt), m_Acceptor(GetService(), boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(address), port)),
m_Timer(GetService()) {}
virtual ~TCPIPAcceptor () { TCPIPAcceptor::Stop(); }
//If you override this make sure you call it from the children
void Start ();

8
I2PTunnel.cpp
View File

@ -256,8 +256,12 @@ namespace client
Done(shared_from_this());
}
I2PClientTunnel::I2PClientTunnel (const std::string& destination, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort):
TCPIPAcceptor (port,localDestination), m_Destination (destination), m_DestinationIdentHash (nullptr), m_DestinationPort (destinationPort)
I2PClientTunnel::I2PClientTunnel(
const std::string& destination, const std::string& address, int port,
std::shared_ptr<ClientDestination> localDestination, int destinationPort
)
: TCPIPAcceptor(address, port, localDestination), m_Destination(destination),
m_DestinationIdentHash(nullptr), m_DestinationPort(destinationPort)
{}
void I2PClientTunnel::Start ()

5
I2PTunnel.h
View File

@ -86,7 +86,10 @@ namespace client
public:
I2PClientTunnel (const std::string& destination, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort = 0);
I2PClientTunnel(
const std::string& destination, const std::string& address, int port,
std::shared_ptr<ClientDestination> localDestination, int destinationPort = 0
);
~I2PClientTunnel () {}
void Start ();

6
Makefile
View File

@ -23,10 +23,12 @@ else # win32
DAEMON_SRC += DaemonWin32.cpp
endif
all: mk_build_dir $(SHLIB) $(I2PD) $(TESTS)
all: mk_build_dir $(SHLIB) $(I2PD)
tests: mk_build_test_dir $(TESTS)
mk_build_dir:
mkdir -p obj
mk_build_test_dir:
mkdir -p obj/tests
api: $(SHLIB)
@ -74,8 +76,10 @@ dist:
--prefix=i2pd_$(LATEST_TAG)/ $(LATEST_TAG) -o i2pd_$(LATEST_TAG).tar.gz
.PHONY: all
.PHONY: tests
.PHONY: clean
.PHONY: deps
.PHONY: dist
.PHONY: api
.PHONY: mk_build_dir
.PHONY: mk_build_test_dir

82
README.md
View File

@ -66,6 +66,18 @@ After that, go to the webconsole and add it behind the url. (Remove http:// from
This should resulting in for example:
http://localhost:7070/4oes3rlgrpbkmzv4lqcfili23h3cvpwslqcfjlk6vvguxyggspwa.b32.i2p
Building Unit Tests
-------------------
To build unit tests, you'll need to install the boost unit test framework.
On Ubuntu/Debian based
* sudo apt-get install libboost-test-dev
To build the tests, run
$ make tests
Cmdline options
---------------
@ -73,6 +85,7 @@ Cmdline options
* --host= - The external IP (deprecated).
* --port= - The port to listen on
* --httpport= - The http port to listen on
* --httpaddress= - The ip address for the HTTP server, 127.0.0.1 by default
* --log= - Enable or disable logging to file. 1 for yes, 0 for no.
* --daemon= - Enable or disable daemon mode. 1 for yes, 0 for no.
* --service= - 1 if uses system folders (/var/run/i2pd.pid, /var/log/i2pd.log, /var/lib/i2pd).
@ -80,9 +93,12 @@ Cmdline options
* --floodfill= - 1 if router is floodfill, off by default
* --bandwidth= - L if bandwidth is limited to 32Kbs/sec, O if not. Always O if floodfill, otherwise L by default.
* --httpproxyport= - The port to listen on (HTTP Proxy)
* --httpproxyaddress= - The address to listen on (HTTP Proxy)
* --socksproxyport= - The port to listen on (SOCKS Proxy)
* --socksproxyaddress= - The address to listen on (SOCKS Proxy)
* --proxykeys= - optional keys file for proxy's local destination
* --ircport= - The local port of IRC tunnel to listen on. 6668 by default
* --irchost= - The adddress of IRC tunnel to listen on, 127.0.0.1 by default
* --ircdest= - I2P destination address of IRC server. For example irc.postman.i2p
* --irckeys= - optional keys file for tunnel's local destination
* --eepkeys= - File name containing destination keys, for example privKeys.dat.
@ -90,8 +106,11 @@ Cmdline options
* --eephost= - Address incoming trafic forward to. 127.0.0.1 by default
* --eepport= - Port incoming trafic forward to. 80 by default
* --samport= - Port of SAM bridge. Usually 7656. SAM is off if not specified
* --samhost= - Address of SAM bridge, 127.0.0.1 by default (only used if SAM is on)
* --bobport= - Port of BOB command channel. Usually 2827. BOB is off if not specified
* --bobaddress= - Address of BOB service, 127.0.0.1 by default (only used if BOB is on)
* --i2pcontrolport= - Port of I2P control service. Usually 7650. I2PControl is off if not specified
* --i2pcontroladdress= - Address of I2P control service, 127.0.0.1 by default (only used if I2PControl is on)
* --conf= - Config file (default: ~/.i2pd/i2p.conf or /var/lib/i2pd/i2p.conf)
This parameter will be silently ignored if the specified config file does not exist.
Options specified on the command line take precedence over those in the config file.
@ -110,34 +129,35 @@ i2p.conf:
tunnels.cfg (filename of this config is subject of change):
; outgoing tunnel sample, to remote service
; mandatory parameters:
; * type -- always "client"
; * port -- local port to listen to
; * destination -- i2p hostname
; optional parameters (may be omitted)
; * keys -- our identity, if unset, will be generated on every startup,
; if set and file missing, keys will be generated and placed to this file
[IRC]
type = client
port = 6668
destination = irc.echelon.i2p
keys = irc-keys.dat
; incoming tunnel sample, for local service
; mandatory parameters:
; * type -- always "server"
; * host -- ip address of our service
; * port -- port of our service
; * keys -- file with LeaseSet of address in i2p
; optional parameters (may be omitted)
; * inport -- optional, i2p service port, if unset - the same as 'port'
; * accesslist -- comma-separated list of i2p addresses, allowed to connect
; every address is b32 without '.b32.i2p' part
[LOCALSITE]
type = server
host = 127.0.0.1
port = 80
keys = site-keys.dat
inport = 81
accesslist = <b32>[,<b32>]
; outgoing tunnel sample, to remote service
; mandatory parameters:
; * type -- always "client"
; * port -- local port to listen to
; * destination -- i2p hostname
; optional parameters (may be omitted)
; * keys -- our identity, if unset, will be generated on every startup,
; if set and file missing, keys will be generated and placed to this file
; * address -- address to listen on, 127.0.0.1 by default
[IRC]
type = client
port = 6668
destination = irc.echelon.i2p
keys = irc-keys.dat
; incoming tunnel sample, for local service
; mandatory parameters:
; * type -- always "server"
; * host -- ip address of our service
; * port -- port of our service
; * keys -- file with LeaseSet of address in i2p
; optional parameters (may be omitted)
; * inport -- optional, i2p service port, if unset - the same as 'port'
; * accesslist -- comma-separated list of i2p addresses, allowed to connect
; every address is b32 without '.b32.i2p' part
[LOCALSITE]
type = server
host = 127.0.0.1
port = 80
keys = site-keys.dat
inport = 81
accesslist = <b32>[,<b32>]

11
SAM.cpp
View File

@ -684,10 +684,13 @@ namespace client
sockets.clear ();
}
SAMBridge::SAMBridge (int port):
m_IsRunning (false), m_Thread (nullptr),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
m_DatagramEndpoint (boost::asio::ip::udp::v4 (), port-1), m_DatagramSocket (m_Service, m_DatagramEndpoint)
SAMBridge::SAMBridge(const std::string& address, int port)
: m_IsRunning (false), m_Thread (nullptr),
m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
boost::asio::ip::address::from_string(address), port)
),
m_DatagramEndpoint(boost::asio::ip::address::from_string(address), port - 1),
m_DatagramSocket(m_Service, m_DatagramEndpoint)
{
}

2
SAM.h
View File

@ -146,7 +146,7 @@ namespace client
{
public:
SAMBridge (int port);
SAMBridge(const std::string& address, int port);
~SAMBridge ();
void Start ();

7
SOCKS.cpp
View File

@ -560,8 +560,11 @@ namespace proxy
}
}
SOCKSServer::SOCKSServer(int port, std::shared_ptr<i2p::client::ClientDestination> localDestination) :
TCPIPAcceptor (port, localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination ())
SOCKSServer::SOCKSServer(const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination)
: TCPIPAcceptor(
address, port,
localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination()
)
{
}

3
SOCKS.h
View File

@ -15,7 +15,8 @@ namespace proxy
{
public:
SOCKSServer(int port, std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
SOCKSServer(const std::string& address, int port,
std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
~SOCKSServer() {};
protected: