diff --git a/I2PTunnel.cpp b/I2PTunnel.cpp index e0200da1..e003f7e9 100644 --- a/I2PTunnel.cpp +++ b/I2PTunnel.cpp @@ -73,7 +73,7 @@ namespace client void I2PTunnelConnection::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred) { if (ecode) - { + { LogPrint ("I2PTunnel read error: ", ecode.message ()); if (ecode != boost::asio::error::operation_aborted) Terminate (); @@ -169,8 +169,7 @@ namespace client I2PClientTunnel::I2PClientTunnel (const std::string& destination, int port, ClientDestination * localDestination): I2PTunnel (localDestination), m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)), - m_Timer (GetService ()), m_Destination (destination), m_DestinationIdentHash (nullptr), - m_RemoteLeaseSet (nullptr) + m_Timer (GetService ()), m_Destination (destination), m_DestinationIdentHash (nullptr) { } diff --git a/I2PTunnel.h b/I2PTunnel.h index a6748ced..2a941f35 100644 --- a/I2PTunnel.h +++ b/I2PTunnel.h @@ -101,7 +101,6 @@ namespace client boost::asio::deadline_timer m_Timer; std::string m_Destination; const i2p::data::IdentHash * m_DestinationIdentHash; - const i2p::data::LeaseSet * m_RemoteLeaseSet; }; class I2PServerTunnel: public I2PTunnel diff --git a/SOCKS.cpp b/SOCKS.cpp index d4c755ac..74887462 100644 --- a/SOCKS.cpp +++ b/SOCKS.cpp @@ -3,10 +3,8 @@ #include "NetDb.h" #include "Destination.h" #include "ClientContext.h" +#include "I2PEndian.h" #include -#include -#include -#include namespace i2p { @@ -14,55 +12,38 @@ namespace proxy { const uint8_t socks_leaseset_timeout = 10; const uint8_t socks_timeout = 60; - + void SOCKS4AHandler::AsyncSockRead() { LogPrint("--- socks4a async sock read"); 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, - boost::asio::placeholders::error, - boost::asio::placeholders::bytes_transferred)); - } else { - m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size), - boost::bind(&SOCKS4AHandler::HandleSockForward, this, - boost::asio::placeholders::error, - boost::asio::placeholders::bytes_transferred)); + std::bind(&SOCKS4AHandler::HandleSockRecv, this, + std::placeholders::_1, std::placeholders::_2)); + } else { + LogPrint("--- socks4a state?? ", m_state); } } 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; // HACK: ew } - void SOCKS4AHandler::Terminate() { - CloseStream(); - CloseSock(); - delete this; // ew - } - void SOCKS4AHandler::SocksFailed() { LogPrint("--- socks4a failed"); - m_sock->send(boost::asio::buffer("\x00\x5b 12345")); - Terminate(); + //TODO: send the right response + boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5b 12345"), + std::bind(&SOCKS4AHandler::SentSocksFailed, this, + std::placeholders::_1)); } - + void SOCKS4AHandler::CloseSock() { if (m_sock) { @@ -73,211 +54,172 @@ namespace proxy } } - void SOCKS4AHandler::CloseStream() - { - if (m_stream) { - LogPrint("--- socks4a close stream"); - m_stream.reset (); - } - } + void SOCKS4AHandler::CloseStream() + { + if (m_stream) { + LogPrint("--- socks4a close stream"); + m_stream.reset (); + } + } const size_t socks_hostname_size = 1024; 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; - 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; - uint16_t idx1 = 0; - uint16_t idx2 = 0; - - LogPrint("--- socks4a state initial ", len); + uint16_t port = 0; + uint32_t address = 0; + uint16_t idx1 = 0; + uint16_t idx2 = 0; - // check valid request - if( m_sock_buff[0] != 4 || m_sock_buff[1] != 1 || m_sock_buff[len-1] ) { - LogPrint("--- socks4a rejected invalid"); - SocksFailed(); - return; - } + LogPrint(eLogDebug,"--- socks4a state initial ", len); - // get port - port = m_sock_buff[3] | m_sock_buff[2] << 8; + // check valid request + if( m_sock_buff[0] != 4 || m_sock_buff[1] != 1 || m_sock_buff[len-1] ) { + LogPrint(eLogError,"--- socks4a rejected invalid"); + SocksFailed(); + return; + } - // read ident - do { - LogPrint("--- socks4a ", (int) m_sock_buff[9+idx1]); - identbuff[idx1] = m_sock_buff[8+idx1]; - } while( identbuff[idx1++] && idx1 < socks_ident_size ); + // get port + port = bufbe16toh(m_sock_buff + 2); + + // get address + address = bufbe32toh(m_sock_buff + 4); - LogPrint("--- socks4a ident ", identbuff); - // read hostname - do { - hostbuff[idx2] = m_sock_buff[8+idx1+idx2]; - } while( hostbuff[idx2++] && idx2 < socks_hostname_size ); + // check valid request + if( address == 0 || address > 255 ) { + LogPrint(eLogError,"--- socks4a rejected because it's actually socks4"); + SocksFailed(); + return; + } - LogPrint("--- socks4a requested ", hostbuff, ":" , port); + // read ident + do { + LogPrint(eLogDebug,"--- socks4a ", (int) m_sock_buff[9+idx1]); + identbuff[idx1] = m_sock_buff[8+idx1]; + } while( identbuff[idx1++] && idx1 < socks_ident_size ); - dest = std::string(hostbuff); - if(dest.find(".b32.i2p") == std::string::npos) { - LogPrint("--- socks4a invalid hostname: ", dest); - SocksFailed(); - return; - } - - if ( i2p::data::Base32ToByteStream(hostbuff, destb32_len, (uint8_t *) m_dest, 32) != 32 ) { - LogPrint("--- sock4a invalid b32: ", 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); + LogPrint(eLogInfo,"--- socks4a ident ", identbuff); + // read hostname + do { + hostbuff[idx2] = m_sock_buff[8+idx1+idx2]; + } while( hostbuff[idx2++] && idx2 < socks_hostname_size ); + + LogPrint(eLogInfo,"--- socks4a requested ", hostbuff, ":" , port); + + dest = std::string(hostbuff); + if(dest.find(".i2p") == std::string::npos) { + LogPrint("--- socks4a invalid hostname: ", dest); + SocksFailed(); + return; } + + m_parent->GetLocalDestination ()->CreateStream ( + std::bind (&SOCKS4AHandler::HandleStreamRequestComplete, + this, std::placeholders::_1), dest); } - void SOCKS4AHandler::HandleStreamRecv(const boost::system::error_code & ecode, std::size_t len) + void SOCKS4AHandler::ConnectionSuccess() + { + LogPrint(eLogInfo,"--- socks4a connection success"); + //TODO: send the right response + boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5a 12345"), + std::bind(&SOCKS4AHandler::SentConnectionSuccess, this, + std::placeholders::_1)); + } + + void SOCKS4AHandler::SentSocksFailed(const boost::system::error_code & ecode) { - if(ecode) { LogPrint("--- socks4a stream recv error: ", ecode); m_state = END; } - switch(m_state) { - case INITIAL: - case END: + if (!ecode) { + Terminate(); + } + else + { + LogPrint (eLogError,"--- socks4a Closing socket after sending failure because: ", ecode.message ()); 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) + void SOCKS4AHandler::SentConnectionSuccess(const boost::system::error_code & ecode) { - - LogPrint("--- socks4a stream wrote"); - if(ecode) { LogPrint("--- socks4a StreamWrote error: ",ecode); } - else { AsyncStreamRead(); } + if (!ecode) { + LogPrint (eLogInfo,"--- socks4a New I2PTunnel connection"); + auto connection = std::make_shared((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::LeaseSetTimeout(const boost::system::error_code & ecode) + + void SOCKS4AHandler::HandleStreamRequestComplete (std::shared_ptr stream) { - m_ls = i2p::data::netdb.FindLeaseSet(m_dest); - if(m_ls) { + if (stream) + { + m_stream = stream; ConnectionSuccess(); - } else { - LogPrint("--- socks4a ls timeout"); + } + else + { + LogPrint (eLogError,"--- socks4a Issue when creating the stream, check the previous warnings for more info."); SocksFailed(); } } - void SOCKS4AHandler::ConnectionSuccess() - { - LogPrint("--- socks4a connection success"); - boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5a 12345"), - boost::bind(&SOCKS4AHandler::SentConnectionSuccess, this, - boost::asio::placeholders::error)); - } - void SOCKS4AHandler::SentConnectionSuccess(const boost::system::error_code & ecode) + void SOCKS4AServer::Start () { - LogPrint("--- socks4a making connection"); - m_stream = i2p::client::context.GetSharedLocalDestination ()->CreateStream(*m_ls); - m_state = OKAY; - LogPrint("--- socks4a state is ", m_state); - AsyncSockRead(); - AsyncStreamRead(); + m_Acceptor.listen (); + Accept (); } - 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() + void SOCKS4AServer::Stop () { - 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)); + m_Acceptor.close(); + m_Timer.cancel (); + ClearConnections (); } - void SOCKS4AServer::Start() + void SOCKS4AServer::Accept () { - 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) + 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("--- socks4a accepted"); - new SOCKS4AHandler(&m_ios, m_new_sock); + if (!ecode) + { + LogPrint(eLogDebug,"--- socks4a accepted"); + new SOCKS4AHandler(this, socket); Accept(); } + else + { + LogPrint (eLogError,"--- socks4a Closing socket on accept because: ", ecode.message ()); + delete socket; + } } + } } diff --git a/SOCKS.h b/SOCKS.h index f08910db..66e62f66 100644 --- a/SOCKS.h +++ b/SOCKS.h @@ -1,13 +1,11 @@ #ifndef SOCKS4A_H__ #define SOCKS4A_H__ -#include -#include -#include -#include #include +#include #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,69 +26,54 @@ 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 StreamWrote(const boost::system::error_code & ecode); - void SockWrote(const boost::system::error_code & ecode); + void SentSocksFailed(const boost::system::error_code & ecode); void SentConnectionSuccess(const boost::system::error_code & ecode); void ConnectionSuccess(); + void HandleStreamRequestComplete (std::shared_ptr 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 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) : - m_ios(ios), m_sock(sock), m_ls_timer(*ios), - m_stream(nullptr), m_ls(nullptr), m_state(INITIAL) { AsyncSockRead(); } + SOCKS4AHandler(SOCKS4AServer * parent, boost::asio::ip::tcp::socket * sock) : + m_parent(parent), m_sock(sock), m_stream(nullptr), m_state(INITIAL) + { 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), - m_thread(nullptr), - m_work(m_ios), - m_acceptor(m_ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)), - m_new_sock(nullptr) { } + SOCKS4AServer(int port) : I2PTunnel(nullptr), + m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)), + m_Timer (GetService ()) {}; ~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); - - 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; - + void HandleAccept(const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket); - }; + private: + + boost::asio::ip::tcp::acceptor m_Acceptor; + boost::asio::deadline_timer m_Timer; + }; typedef SOCKS4AServer SOCKSProxy; }