Merge pull request #237 from EinMByte/master

Fixes for #235 and #233.
Also tested by psi, and seems to be working fine.

BOB.cpp

@@ -524,9 +524,11 @@ namespace client
             SendReplyError ("malformed");
     }   
         
-    BOBCommandChannel::BOBCommandChannel (int port):
+    BOBCommandChannel::BOBCommandChannel(const std::string& address, int port)
-        m_IsRunning (false), m_Thread (nullptr),
+        : m_IsRunning (false), m_Thread (nullptr),
-        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)
+          )
     {
         // command -> handler
         m_CommandHandlers[BOB_COMMAND_ZAP] = &BOBCommandSession::ZapCommandHandler; 

BOB.h

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

ClientContext.cpp

@@ -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,16 +104,20 @@ 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)
+        if(i2pcontrolPort) {
-        {
+            m_I2PControlService = new I2PControlService(
-            m_I2PControlService = new I2PControlService (i2pcontrolPort);
+                i2p::util::config::GetArg("-i2pcontroladdress", "127.0.0.1"),
+                i2pcontrolPort
+            );
             m_I2PControlService->Start();
             LogPrint("I2PControl started");
         }
@@ -259,43 +279,46 @@ namespace client
     void ClientContext::ReadTunnels ()
     {
         boost::property_tree::ptree pt;
-        try
+        try {
-        {
+            boost::property_tree::read_ini(
-            boost::property_tree::read_ini (i2p::util::filesystem::GetFullPath (TUNNELS_CONFIG_FILENAME), pt);
+                i2p::util::filesystem::GetFullPath(TUNNELS_CONFIG_FILENAME),
-        }
+                pt
-        catch (std::exception& ex)
+            );
-        {
+        } 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 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)
                         localDestination = LoadLocalDestination (keys, false);
-                    auto clientTunnel = new I2PClientTunnel (dest, port, localDestination, destinationPort);
+
+                    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 (const std::exception& ex) {
-            catch (std::exception& ex)
-            {
                 LogPrint (eLogError, "Can't read tunnel ", name, " params: ", ex.what ());
             }
         }   

ClientContext.h

@@ -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";    

Daemon.cpp

@@ -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();

HTTPProxy.cpp

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

HTTPProxy.h

@@ -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:

HTTPServer.cpp

@@ -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)
     {
 

HTTPServer.h

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

I2PControl.cpp

@@ -22,9 +22,11 @@ namespace i2p
 {
 namespace client
 {
-    I2PControlService::I2PControlService (int port):
+    I2PControlService::I2PControlService(const std::string& address, int port)
-        m_Password (I2P_CONTROL_DEFAULT_PASSWORD), m_IsRunning (false), m_Thread (nullptr),
+        : m_Password(I2P_CONTROL_DEFAULT_PASSWORD), m_IsRunning(false),
-        m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
+          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; 

I2PControl.h

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

I2PService.h

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

I2PTunnel.cpp

@@ -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): 
+    I2PClientTunnel::I2PClientTunnel(
-        TCPIPAcceptor (port,localDestination), m_Destination (destination), m_DestinationIdentHash (nullptr), m_DestinationPort (destinationPort)
+        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 ()

I2PTunnel.h

@@ -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 ();

Makefile

@@ -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

README.md

@@ -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.
@@ -118,6 +137,7 @@ tunnels.cfg (filename of this config is subject of change):
     ; 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

SAM.cpp

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

SAM.h

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

SOCKS.cpp

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

SOCKS.h

@@ -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: