* add websocks

* enable socks, websocks and httpproxy as client tunnels

* remove old websocks config

ClientContext.cpp

@@ -8,6 +8,8 @@
 #include "Identity.h"
 #include "util.h"
 #include "ClientContext.h"
+#include "SOCKS.h"
+#include "WebSocks.h"
 
 namespace i2p
 {
@@ -424,7 +426,11 @@ namespace client
 			try
 			{
 				std::string type = section.second.get<std::string> (I2P_TUNNELS_SECTION_TYPE);
-				if (type == I2P_TUNNELS_SECTION_TYPE_CLIENT || type == I2P_TUNNELS_SECTION_TYPE_UDPCLIENT)
+				if (type == I2P_TUNNELS_SECTION_TYPE_CLIENT
+						|| type == I2P_TUNNELS_SECTION_TYPE_SOCKS
+						|| type == I2P_TUNNELS_SECTION_TYPE_WEBSOCKS
+						|| type == I2P_TUNNELS_SECTION_TYPE_HTTPPROXY
+						|| type == I2P_TUNNELS_SECTION_TYPE_UDPCLIENT)
 				{
 					// mandatory params
 					std::string dest = section.second.get<std::string> (I2P_CLIENT_TUNNEL_DESTINATION);
@@ -466,19 +472,45 @@ namespace client
 							LogPrint(eLogError, "Clients: I2P Client forward for endpoint ", end, " already exists");
 
 					} else {
+						boost::asio::ip::tcp::endpoint clientEndpoint;
+						I2PService * clientTunnel = nullptr;
+						if (type == I2P_TUNNELS_SECTION_TYPE_SOCKS)
+						{
+							// socks proxy
+							clientTunnel = new i2p::proxy::SOCKSProxy(address, port, "", destinationPort, localDestination);
+							clientEndpoint = ((i2p::proxy::SOCKSProxy*)clientTunnel)->GetAcceptor().local_endpoint();
+						}
+						else if (type == I2P_TUNNELS_SECTION_TYPE_HTTPPROXY)
+						{
+							// http proxy
+							clientTunnel = new i2p::proxy::HTTPProxy(address, port, localDestination);
+							clientEndpoint = ((i2p::proxy::HTTPProxy*)clientTunnel)->GetAcceptor().local_endpoint();
+						}
+						else if (type == I2P_TUNNELS_SECTION_TYPE_WEBSOCKS)
+						{
+							// websocks proxy
+							clientTunnel = new WebSocks(address, port, localDestination);;
+							clientEndpoint = ((WebSocks*)clientTunnel)->GetLocalEndpoint();
+						}
+						else
+						{
 							// tcp client
-						auto clientTunnel = new I2PClientTunnel (name, dest, address, port, localDestination, destinationPort);
+							clientTunnel = new I2PClientTunnel (name, dest, address, port, localDestination, destinationPort);
-						if (m_ClientTunnels.insert (std::make_pair (clientTunnel->GetAcceptor ().local_endpoint (), 
+							clientEndpoint = ((I2PClientTunnel*)clientTunnel)->GetAcceptor().local_endpoint();
-							std::unique_ptr<I2PClientTunnel>(clientTunnel))).second)
+						}
+						if (m_ClientTunnels.insert (std::make_pair (clientEndpoint,	std::unique_ptr<I2PService>(clientTunnel))).second)
 						{
 							clientTunnel->Start ();
 							numClientTunnels++;
 						}
 						else
-							LogPrint (eLogError, "Clients: I2P client tunnel for endpoint ", clientTunnel->GetAcceptor ().local_endpoint (), " already exists");
+							LogPrint (eLogError, "Clients: I2P client tunnel for endpoint ", clientEndpoint, "already exists");
 					}
 				}
-				else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER || type == I2P_TUNNELS_SECTION_TYPE_HTTP || type == I2P_TUNNELS_SECTION_TYPE_IRC || type == I2P_TUNNELS_SECTION_TYPE_UDPSERVER)
+				else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER
+								 || type == I2P_TUNNELS_SECTION_TYPE_HTTP
+								 || type == I2P_TUNNELS_SECTION_TYPE_IRC
+								 || type == I2P_TUNNELS_SECTION_TYPE_UDPSERVER)
 				{	
 					// mandatory params
 					std::string host = section.second.get<std::string> (I2P_SERVER_TUNNEL_HOST);

ClientContext.h

@@ -26,6 +26,9 @@ namespace client
 	const char I2P_TUNNELS_SECTION_TYPE_IRC[] = "irc";
 	const char I2P_TUNNELS_SECTION_TYPE_UDPCLIENT[] = "udpclient";
 	const char I2P_TUNNELS_SECTION_TYPE_UDPSERVER[] = "udpserver";
+	const char I2P_TUNNELS_SECTION_TYPE_SOCKS[] = "socks";
+	const char I2P_TUNNELS_SECTION_TYPE_WEBSOCKS[] = "websocks";
+	const char I2P_TUNNELS_SECTION_TYPE_HTTPPROXY[] = "httpproxy";
 	const char I2P_CLIENT_TUNNEL_PORT[] = "port";
 	const char I2P_CLIENT_TUNNEL_ADDRESS[] = "address";
 	const char I2P_CLIENT_TUNNEL_DESTINATION[] = "destination";
@@ -93,7 +96,7 @@ namespace client
 
 			i2p::proxy::HTTPProxy * m_HttpProxy;
 			i2p::proxy::SOCKSProxy * m_SocksProxy;
-			std::map<boost::asio::ip::tcp::endpoint, std::unique_ptr<I2PClientTunnel> > m_ClientTunnels; // local endpoint->tunnel
+			std::map<boost::asio::ip::tcp::endpoint, std::unique_ptr<I2PService> > m_ClientTunnels; // local endpoint->tunnel
 			std::map<std::pair<i2p::data::IdentHash, int>, std::unique_ptr<I2PServerTunnel> > m_ServerTunnels; // <destination,port>->tunnel
 
 			std::mutex m_ForwardsMutex;			 

Config.cpp

@@ -203,12 +203,6 @@ namespace config {
       ("websockets.address", value<std::string>()->default_value("127.0.0.1"), "address to bind websocket server on")
       ("websockets.port", value<uint16_t>()->default_value(7666), "port to bind websocket server on");
 
-		options_description websocks("WebSOCKS options");
-    websocks.add_options()
-      ("websocks.enabled", value<bool>()->default_value(false), "enable WebSOCKS server")
-      ("websocks.address", value<std::string>()->default_value("127.0.0.1"), "address to bind WebSOCKS server on")
-      ("websocks.port", value<uint16_t>()->default_value(7666), "port to bind WebSOCKS server on");
-
     m_OptionsDesc
       .add(general)
 	  .add(limits)	
@@ -225,7 +219,6 @@ namespace config {
       .add(addressbook)	
       .add(trust)
       .add(websocket)
-			.add(websocks)
       ;
   }
 

Daemon.cpp

@@ -27,7 +27,6 @@
 
 #include "Event.h"
 #include "Websocket.h"
-#include "WebSocks.h"
 
 namespace i2p
 {
@@ -44,7 +43,6 @@ namespace i2p
 			std::unique_ptr<i2p::transport::UPnP> UPnP;
 #ifdef WITH_EVENTS
 			std::unique_ptr<i2p::event::WebsocketServer> m_WebsocketServer;
-			std::unique_ptr<i2p::client::WebSocks> m_WebSocksServer;
 #endif
 		};
 
@@ -309,15 +307,6 @@ namespace i2p
 				d.m_WebsocketServer->Start();
 				i2p::event::core.SetListener(d.m_WebsocketServer->ToListener());
 			}
-			bool websocks; i2p::config::GetOption("websocks.enabled", websocks);
-			if (websocks) {
-				std::string websocksAddr; i2p::config::GetOption("websocks.address", websocksAddr);
-				uint16_t websocksPort; i2p::config::GetOption("websocks.port", websocksPort);
-				LogPrint(eLogInfo, "Daemon: starting up WebSOCKS server at ", websocksAddr, ":", websocksPort);
-				d.m_WebSocksServer = std::unique_ptr<i2p::client::WebSocks>(new i2p::client::WebSocks(websocksAddr, websocksPort));
-				d.m_WebSocksServer->Start();
-			}
-			
 #endif
 			return true;
 		}

I2PService.h

@@ -122,9 +122,10 @@ namespace client
 
 			const boost::asio::ip::tcp::acceptor& GetAcceptor () const { return m_Acceptor; };
 
+    virtual const char* GetName() { return "Generic TCP/IP accepting daemon"; }
+
 		protected:
 			virtual std::shared_ptr<I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket) = 0;
-			virtual const char* GetName() { return "Generic TCP/IP accepting daemon"; }
 		private:
 			void Accept();
 			void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket);

WebSocks.cpp

@@ -27,8 +27,9 @@ namespace client
 	typedef std::function<void(std::shared_ptr<i2p::stream::Stream>)> StreamConnectFunc;
 
 
-  struct IWebSocksConn
+	struct IWebSocksConn : public I2PServiceHandler
 	{
+		IWebSocksConn(I2PService * parent) : I2PServiceHandler(parent) {}
 		virtual void Close() = 0;
 		virtual void GotMessage(const websocketpp::connection_hdl & conn, WebSocksServerImpl::message_ptr msg) = 0;
 	};
@@ -50,6 +51,7 @@ namespace client
 		typedef ServerImpl::message_ptr MessagePtr;
 
 		WebSocksImpl(const std::string & addr, int port) :
+			Parent(nullptr),
 			m_Run(false),
 			m_Addr(addr),
 			m_Port(port),
@@ -57,8 +59,12 @@ namespace client
 		{
 			m_Server.init_asio();
 			m_Server.set_open_handler(std::bind(&WebSocksImpl::ConnOpened, this, std::placeholders::_1));
-      i2p::data::PrivateKeys k = i2p::data::PrivateKeys::CreateRandomKeys(i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519);
+		}
-      m_Dest = std::make_shared<ClientDestination>(k, false);
+
+		void InitializeDestination(WebSocks * parent)
+		{
+			Parent = parent;
+			m_Dest = Parent->GetLocalDestination();
 		}
 
 		ServerImpl::connection_ptr GetConn(const websocketpp::connection_hdl & conn)
@@ -87,7 +93,9 @@ namespace client
 
 		void ConnOpened(websocketpp::connection_hdl conn)
 		{
-      m_Conns.push_back(CreateWebSocksConn(conn, this));
+			auto ptr = CreateWebSocksConn(conn, this);
+			Parent->AddHandler(ptr);
+			m_Conns.push_back(ptr);
 		}
 
 		void Start()
@@ -123,6 +131,13 @@ namespace client
 			m_Thread = nullptr;
 		}
 
+		boost::asio::ip::tcp::endpoint GetLocalEndpoint()
+		{
+			return boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(m_Addr), m_Port);
+		}
+
+		WebSocks * Parent;
+
 	private:
 		std::vector<WebSocksConn_ptr> m_Conns;
 		bool m_Run;
@@ -133,7 +148,7 @@ namespace client
 		Destination_t m_Dest;
 	};
 
-  struct WebSocksConn : public IWebSocksConn
+	struct WebSocksConn : public IWebSocksConn , public std::enable_shared_from_this<WebSocksConn>
 	{
 		enum ConnState
 		{
@@ -161,6 +176,7 @@ namespace client
 		uint8_t m_RecvBuf[2048];
 
 		WebSocksConn(const ServerConn & conn, WebSocksImpl * parent) :
+			IWebSocksConn(parent->Parent),
 			m_Conn(conn),
 			m_Stream(nullptr),
 			m_State(eWSCInitial),
@@ -240,6 +256,9 @@ namespace client
 			case eWSCClose:
 				if(state == eWSCEnd) {
 					LogPrint(eLogDebug, "websocks: socket ended");
+					Kill();
+					auto me = shared_from_this();
+					Done(me);
 				} else {
 					LogPrint(eLogWarning, "websocks: invalid state change ", m_State, " -> ", state);
 				}
@@ -383,7 +402,7 @@ namespace client
 	class WebSocksImpl
 	{
 	public:
-		WebSocksImpl(const std::string & addr, int port)
+		WebSocksImpl(const std::string & addr, int port) : m_Addr(addr), m_Port(port)
 		{
 		}
 
@@ -398,9 +417,20 @@ namespace client
 
 		void Stop()
 		{
-
 		}
 
+		void InitializeDestination(WebSocks * parent)
+		{
+		}
+
+		boost::asio::ip::tcp::endpoint GetLocalEndpoint()
+		{
+			return boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(m_Addr), m_Port);
+		}
+
+		std::string m_Addr;
+		int m_Port;
+
 	};
 }
 }
@@ -410,17 +440,28 @@ namespace i2p
 {
 namespace client
 {
-	WebSocks::WebSocks(const std::string & addr, int port) : m_Impl(new WebSocksImpl(addr, port)) {}
+	WebSocks::WebSocks(const std::string & addr, int port, std::shared_ptr<ClientDestination> localDestination) : m_Impl(new WebSocksImpl(addr, port))
+	{
+		m_Impl->InitializeDestination(this);
+	}
 	WebSocks::~WebSocks() { delete m_Impl; }
 
 	void WebSocks::Start()
 	{
 		m_Impl->Start();
+		GetLocalDestination()->Start();
+	}
+
+	boost::asio::ip::tcp::endpoint WebSocks::GetLocalEndpoint() const
+	{
+		return m_Impl->GetLocalEndpoint();
 	}
 
 	void WebSocks::Stop()
 	{
 		m_Impl->Stop();
+		GetLocalDestination()->Stop();
 	}
 }
 }
+

WebSocks.h

@@ -1,6 +1,9 @@
 #ifndef WEBSOCKS_H_
 #define WEBSOCKS_H_
 #include <string>
+#include <memory>
+#include "I2PService.h"
+#include "Destination.h"
 
 namespace i2p
 {
@@ -10,15 +13,19 @@ namespace client
 	class WebSocksImpl;
 
 	/** @brief websocket socks proxy server */
-  class WebSocks
+	class WebSocks : public i2p::client::I2PService
 	{
 	public:
-    WebSocks(const std::string & addr, int port);
+		WebSocks(const std::string & addr, int port, std::shared_ptr<ClientDestination> localDestination);
 		~WebSocks();
 
 		void Start();
 		void Stop();
 
+		boost::asio::ip::tcp::endpoint GetLocalEndpoint() const;
+
+		const char * GetName() { return "WebSOCKS Proxy"; }
+
 	private:
 		WebSocksImpl * m_Impl;
 	};

android/jni/Android.mk

@@ -59,6 +59,7 @@ LOCAL_SRC_FILES := DaemonAndroid.cpp i2pd_android.cpp \
     ../../TunnelPool.cpp \
 	../../Timestamp.cpp \
 	../../Event.cpp \
+	../../WebSocks.cpp \
 ../../BloomFilter.cpp \
     ../../util.cpp \
      ../../i2pd.cpp ../../UPnP.cpp