Rewrite SOCKS proxy so it uses I2PTunnelConnection and I2PTunnel

SOCKS.cpp

@@ -3,10 +3,8 @@
 #include "NetDb.h"
 #include "Destination.h"
 #include "ClientContext.h"
+#include "I2PEndian.h"
 #include <cstring>
-#include <stdexcept>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/bind.hpp>
 
 namespace i2p
 {
@@ -21,46 +19,29 @@ namespace proxy
 		if(m_sock) {
 			if (m_state == INITIAL) {
 				m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size),
-						      boost::bind(&SOCKS4AHandler::HandleSockRecv, this,
+						      std::bind(&SOCKS4AHandler::HandleSockRecv, this,
-								  boost::asio::placeholders::error,
+								 std::placeholders::_1, std::placeholders::_2));
-								  boost::asio::placeholders::bytes_transferred));
 			} else {
-				m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size),
+				LogPrint("--- socks4a state?? ", m_state);
-						      boost::bind(&SOCKS4AHandler::HandleSockForward, this,
-								  boost::asio::placeholders::error,
-								  boost::asio::placeholders::bytes_transferred));
 			}
 		} else {
 			LogPrint("--- socks4a no socket for read");
 		}
 	}
 
-	void SOCKS4AHandler::AsyncStreamRead()
-	{
-		
-		LogPrint("--- socks4a async stream read");
-		if (m_stream) {
-			m_stream->AsyncReceive(
-				boost::asio::buffer(m_stream_buff, socks_buffer_size),
-				boost::bind(&SOCKS4AHandler::HandleStreamRecv, this,
-					    boost::asio::placeholders::error, 
-					    boost::asio::placeholders::bytes_transferred), socks_timeout);
-		} else {
-			LogPrint("--- socks4a no stream for read");
-		}
-	}
-
 	void SOCKS4AHandler::Terminate() {
 		CloseStream();
 		CloseSock();
-                delete this; // ew
+		delete this; // HACK: ew
 	}
 
 	void SOCKS4AHandler::SocksFailed()
 	{
 		LogPrint("--- socks4a failed");
-		m_sock->send(boost::asio::buffer("\x00\x5b 12345"));
+		//TODO: send the right response
-		Terminate();
+		boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5b 12345"),
+					 std::bind(&SOCKS4AHandler::SentSocksFailed, this,
+						     std::placeholders::_1));
 	}
 
 	void SOCKS4AHandler::CloseSock()
@@ -85,199 +66,160 @@ namespace proxy
 	const size_t socks_ident_size = 1024;
 	const size_t destb32_len = 52;
 
-	void SOCKS4AHandler::HandleSockForward(const boost::system::error_code & ecode, std::size_t len)
-	{
-		if(ecode) {
-			LogPrint("--- socks4a forward got error: ", ecode);
-			Terminate();
-			return;
-		}
-		
-		LogPrint("--- socks4a sock forward: ", len);
-		m_stream->Send(m_sock_buff, len);
-	}
-
 	void SOCKS4AHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
 	{
 		LogPrint("--- socks4a sock recv: ", len);
-		
+		//TODO: we may not have received all the data :(
 		if(ecode) {
 			LogPrint(" --- sock recv got error: ", ecode);
                         Terminate();
 			return;
 		}
 
-		if (m_state == INITIAL) {
-
 		char hostbuff[socks_hostname_size];
 		char identbuff[socks_ident_size];
 		std::memset(hostbuff, 0, sizeof(hostbuff));
 		std::memset(identbuff, 0, sizeof(hostbuff));
 		std::string dest;
-			// get port
+
 		uint16_t port = 0;
+		uint32_t address = 0;
 		uint16_t idx1 = 0;
 		uint16_t idx2 = 0;
 
-			LogPrint("--- socks4a state initial ", len);
+		LogPrint(eLogDebug,"--- socks4a state initial ", len);
 
 		// check valid request
 		if( m_sock_buff[0] != 4 || m_sock_buff[1] != 1 || m_sock_buff[len-1] ) {
-				LogPrint("--- socks4a rejected invalid");
+			LogPrint(eLogError,"--- socks4a rejected invalid");
 			SocksFailed();
 			return;
 		}
 
 		// get port
-			port = m_sock_buff[3] | m_sock_buff[2] << 8;
+		port = bufbe16toh(m_sock_buff + 2);
+		
+		// get address
+		address = bufbe32toh(m_sock_buff + 4);
+
+		// check valid request
+		if( address == 0 || address > 255 ) {
+			LogPrint(eLogError,"--- socks4a rejected because it's actually socks4");
+			SocksFailed();
+			return;
+		}
 
 		// read ident 
 		do {
-				LogPrint("--- socks4a ", (int) m_sock_buff[9+idx1]);
+			LogPrint(eLogDebug,"--- socks4a ", (int) m_sock_buff[9+idx1]);
 			identbuff[idx1] = m_sock_buff[8+idx1];
 		} while( identbuff[idx1++] && idx1 < socks_ident_size );
 
-			LogPrint("--- socks4a ident ", identbuff);
+		LogPrint(eLogInfo,"--- socks4a ident ", identbuff);
 		// read hostname
 		do {
 			hostbuff[idx2] = m_sock_buff[8+idx1+idx2];
 		} while( hostbuff[idx2++] && idx2 < socks_hostname_size );
 
-			LogPrint("--- socks4a requested ", hostbuff, ":" , port);
+		LogPrint(eLogInfo,"--- socks4a requested ", hostbuff, ":" , port);
 
 		dest = std::string(hostbuff);
-			if(dest.find(".b32.i2p") == std::string::npos) {
+		if(dest.find(".i2p") == std::string::npos) {
 			LogPrint("--- socks4a invalid hostname: ", dest);
 			SocksFailed();
 			return;
 		}
 		
-			if ( i2p::data::Base32ToByteStream(hostbuff, destb32_len, (uint8_t *) m_dest, 32) != 32 ) {
+		m_parent->GetLocalDestination ()->CreateStream (
-				LogPrint("--- sock4a invalid b32: ", dest);
+				std::bind (&SOCKS4AHandler::HandleStreamRequestComplete,
-			}
+				this, std::placeholders::_1), dest);
-			
-			LogPrint("--- sock4a find lease set");
-			m_ls = i2p::data::netdb.FindLeaseSet(m_dest);
-			if (!m_ls || m_ls->HasNonExpiredLeases()) {
-				i2p::client::context.GetSharedLocalDestination ()->RequestDestination (m_dest);
-				m_ls_timer.expires_from_now(boost::posix_time::seconds(socks_leaseset_timeout));
-				m_ls_timer.async_wait(boost::bind(&SOCKS4AHandler::LeaseSetTimeout, this, boost::asio::placeholders::error));
-			} else {
-				ConnectionSuccess();
-			}
-		} else {
-			LogPrint("--- socks4a state?? ", m_state);
-		}
-	}
-	
-	void SOCKS4AHandler::HandleStreamRecv(const boost::system::error_code & ecode, std::size_t len)
-	{
-		if(ecode) { LogPrint("--- socks4a stream recv error: ", ecode); m_state = END; }
-		switch(m_state) {
-		case INITIAL:
-		case END:
-			Terminate();
-                        return;
-		case OKAY:
-			LogPrint("--- socks4a stream recv ", len);
-			boost::asio::async_write(*m_sock, boost::asio::buffer(m_stream_buff, len), 
-						 boost::bind(&SOCKS4AHandler::StreamWrote, this, 
-							     boost::asio::placeholders::error));
-		}
-	}
-	
-	void SOCKS4AHandler::SockWrote(const boost::system::error_code & ecode)
-	{
-		LogPrint("--- socks4a sock wrote");
-		if(ecode) { LogPrint("--- socks4a SockWrote error: ",ecode); }
-		else { AsyncSockRead(); }
-	}
-
-	void SOCKS4AHandler::StreamWrote(const boost::system::error_code & ecode)
-	{
-		
-		LogPrint("--- socks4a stream wrote");
-		if(ecode) { LogPrint("--- socks4a StreamWrote error: ",ecode); }
-		else { AsyncStreamRead(); }
-	}
-
-	void SOCKS4AHandler::LeaseSetTimeout(const boost::system::error_code & ecode)
-	{
-		m_ls = i2p::data::netdb.FindLeaseSet(m_dest);
-		if(m_ls) {
-			ConnectionSuccess();
-		} else {
-			LogPrint("--- socks4a ls timeout");
-			SocksFailed();
-		}
 	}
 	
 	void SOCKS4AHandler::ConnectionSuccess()
 	{
-		LogPrint("--- socks4a connection success");
+		LogPrint(eLogInfo,"--- socks4a connection success");
+		//TODO: send the right response
 		boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5a 12345"),
-					 boost::bind(&SOCKS4AHandler::SentConnectionSuccess, this,
+					 std::bind(&SOCKS4AHandler::SentConnectionSuccess, this,
-						     boost::asio::placeholders::error));
+						     std::placeholders::_1));
+	}
+
+	void SOCKS4AHandler::SentSocksFailed(const boost::system::error_code & ecode)
+	{
+		if (!ecode) {
+			Terminate();
+		}
+		else
+		{
+			LogPrint (eLogError,"--- socks4a Closing socket after sending failure because: ", ecode.message ());
+			Terminate();
+		}
 	}
 	
 	void SOCKS4AHandler::SentConnectionSuccess(const boost::system::error_code & ecode)
-	{
-		LogPrint("--- socks4a making connection");
-		m_stream = i2p::client::context.GetSharedLocalDestination ()->CreateStream(*m_ls);
-		m_state = OKAY;
-		LogPrint("--- socks4a state is ", m_state);
-		AsyncSockRead();
-		AsyncStreamRead();
-	}
-
-	void SOCKS4AServer::Run()
-	{
-		LogPrint("--- socks4a run");
-		m_run = true;
-		while(m_run) {
-			try {
-				m_ios.run();
-			} catch (std::runtime_error & exc) {
-				LogPrint("--- socks4a exception: ", exc.what());
-			}
-		}
-	}
-	
-	void SOCKS4AServer::Accept()
-	{
-		m_new_sock = new boost::asio::ip::tcp::socket(m_ios);
-		m_acceptor.async_accept(*m_new_sock, 
-					boost::bind(
-						&SOCKS4AServer::HandleAccept, this, boost::asio::placeholders::error));
-	}
-
-	void SOCKS4AServer::Start()
-	{
-                m_run = true;
-		m_thread = new std::thread(std::bind(&SOCKS4AServer::Run, this));
-		m_acceptor.listen();
-		Accept();
-	}
-	
-	void SOCKS4AServer::Stop()
-	{
-		m_acceptor.close();
-		m_run = false;
-		m_ios.stop();
-		if (m_thread) {
-			m_thread->join();
-			delete m_thread;
-			m_thread = nullptr;
-		}
-	}
-		
-	void SOCKS4AServer::HandleAccept(const boost::system::error_code & ecode)
 	{
 		if (!ecode) {
-			LogPrint("--- socks4a accepted");
+			LogPrint (eLogInfo,"--- socks4a New I2PTunnel connection");
-			new SOCKS4AHandler(&m_ios, m_new_sock);
+			auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, m_stream);
+			m_parent->AddConnection (connection);
+			connection->I2PConnect ();
+		}
+		else
+		{
+			LogPrint (eLogError,"--- socks4a Closing socket after sending success because: ", ecode.message ());
+			Terminate();
+		}
+	}
+	
+	void SOCKS4AHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+	{
+		if (stream)
+		{
+			m_stream = stream;
+			ConnectionSuccess();
+		}
+		else
+		{
+			LogPrint (eLogError,"--- socks4a Issue when creating the stream, check the previous warnings for more info.");
+			SocksFailed();
+		}
+	}
+
+
+	void SOCKS4AServer::Start ()
+	{
+		m_Acceptor.listen ();
+		Accept ();
+	}
+
+	void SOCKS4AServer::Stop ()
+	{
+		m_Acceptor.close();
+		m_Timer.cancel ();
+		ClearConnections ();
+	}
+
+	void SOCKS4AServer::Accept ()
+	{
+		auto newSocket = new boost::asio::ip::tcp::socket (GetService ());
+		m_Acceptor.async_accept (*newSocket, std::bind (&SOCKS4AServer::HandleAccept, this,
+			std::placeholders::_1, newSocket));
+	}	
+
+	void SOCKS4AServer::HandleAccept (const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket)
+	{
+		if (!ecode)
+		{
+			LogPrint(eLogDebug,"--- socks4a accepted");
+			new SOCKS4AHandler(this, socket);
 			Accept();
 		}
+		else
+		{
+			LogPrint (eLogError,"--- socks4a Closing socket on accept because: ", ecode.message ());
+			delete socket;
 		}
+	}
+
 }
 }

SOCKS.h

@@ -1,13 +1,11 @@
 #ifndef SOCKS4A_H__
 #define SOCKS4A_H__
 
-#include <thread>
-#include <boost/asio.hpp>
-#include <vector>
-#include <mutex>
 #include <memory>
+#include <boost/asio.hpp>
 #include "Identity.h"
 #include "Streaming.h"
+#include "I2PTunnel.h"
 
 namespace i2p
 {
@@ -16,6 +14,7 @@ namespace proxy
 
 	const size_t socks_buffer_size = 8192;
 
+	class SOCKS4AServer;
 	class SOCKS4AHandler {
 
 		private:
@@ -27,68 +26,53 @@ namespace proxy
 
             void GotClientRequest(boost::system::error_code & ecode, std::string & host, uint16_t port);
             void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
-            void HandleSockForward(const boost::system::error_code & ecode, std::size_t bytes_transfered);
-            void HandleStreamRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
             void Terminate();
             void CloseSock();
             void CloseStream();
             void AsyncSockRead();
-            void AsyncStreamRead();
             void SocksFailed();
-            void LeaseSetTimeout(const boost::system::error_code & ecode);
+            void SentSocksFailed(const boost::system::error_code & ecode);
-            void StreamWrote(const boost::system::error_code & ecode);		  
-            void SockWrote(const boost::system::error_code & ecode);
             void SentConnectionSuccess(const boost::system::error_code & ecode);
             void ConnectionSuccess();
+            void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
             
             uint8_t m_sock_buff[socks_buffer_size];
-            uint8_t m_stream_buff[socks_buffer_size];
             
-            boost::asio::io_service * m_ios;
+	    SOCKS4AServer * m_parent;
             boost::asio::ip::tcp::socket * m_sock;
-            boost::asio::deadline_timer m_ls_timer;
             std::shared_ptr<i2p::stream::Stream> m_stream;
-            i2p::data::LeaseSet * m_ls;
-            i2p::data::IdentHash m_dest;
             state m_state;
 		
             
 		public:
-			SOCKS4AHandler(boost::asio::io_service * ios, boost::asio::ip::tcp::socket * sock) : 
+			SOCKS4AHandler(SOCKS4AServer * parent, boost::asio::ip::tcp::socket * sock) : 
-				m_ios(ios), m_sock(sock), m_ls_timer(*ios),
+				m_parent(parent), m_sock(sock), m_stream(nullptr), m_state(INITIAL)
-				m_stream(nullptr), m_ls(nullptr), m_state(INITIAL) { AsyncSockRead(); }
+				{ AsyncSockRead(); }
 
 			~SOCKS4AHandler() { CloseSock(); CloseStream(); }
 			bool isComplete() { return m_state == END; }
 	};
 
-	class SOCKS4AServer {
+	class SOCKS4AServer: public i2p::client::I2PTunnel
+	{
 		public:
-			SOCKS4AServer(int port) : m_run(false), 
+			SOCKS4AServer(int port) : I2PTunnel(nullptr),
-									  m_thread(nullptr), 
+				m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)),
-									  m_work(m_ios),
+				m_Timer (GetService ()) {};
-									  m_acceptor(m_ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
-									  m_new_sock(nullptr) { }
 			~SOCKS4AServer() { Stop(); }
-			void Start();
-			void Stop();
 
-			boost::asio::io_service& GetService () { return m_ios; };	
+			void Start ();
+			void Stop ();
 
 		private:
 
-			void Run();
 			void Accept();
-			void HandleAccept(const boost::system::error_code& ecode);
+			void HandleAccept(const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket);
-
-			bool m_run;
-			std::thread * m_thread;
-			boost::asio::io_service m_ios;
-			boost::asio::io_service::work m_work;
-            boost::asio::ip::tcp::acceptor m_acceptor;
-			boost::asio::ip::tcp::socket * m_new_sock;
 
+		private:
 
+			boost::asio::ip::tcp::acceptor m_Acceptor;
+			boost::asio::deadline_timer m_Timer;
 	};	
 
 	typedef SOCKS4AServer SOCKSProxy;