Implement #243, separate core/client (PCH support dropped for now)

client/I2PTunnel.cpp

@@ -0,0 +1,405 @@
+#include <cassert>
+#include "util/Log.h"
+#include "Destination.h"
+#include "ClientContext.h"
+#include "I2PTunnel.h"
+
+namespace i2p
+{
+namespace client
+{
+    I2PTunnelConnection::I2PTunnelConnection (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+        std::shared_ptr<const i2p::data::LeaseSet> leaseSet, int port): 
+        I2PServiceHandler(owner), m_Socket (socket), m_RemoteEndpoint (socket->remote_endpoint ()),
+        m_IsQuiet (true)
+    {
+        m_Stream = GetOwner()->GetLocalDestination ()->CreateStream (leaseSet, port);
+    }   
+
+    I2PTunnelConnection::I2PTunnelConnection (I2PService * owner,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, std::shared_ptr<i2p::stream::Stream> stream):
+        I2PServiceHandler(owner), m_Socket (socket), m_Stream (stream),
+        m_RemoteEndpoint (socket->remote_endpoint ()), m_IsQuiet (true)
+    {
+    }
+
+    I2PTunnelConnection::I2PTunnelConnection (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::asio::ip::tcp::endpoint& target, bool quiet):
+        I2PServiceHandler(owner), m_Socket (socket), m_Stream (stream),
+        m_RemoteEndpoint (target), m_IsQuiet (quiet)
+    {
+    }
+
+    I2PTunnelConnection::~I2PTunnelConnection ()
+    {
+    }   
+
+    void I2PTunnelConnection::I2PConnect (const uint8_t * msg, size_t len)
+    {
+        if (m_Stream)
+        {
+            if (msg)
+                m_Stream->Send (msg, len); // connect and send
+            else    
+                m_Stream->Send (m_Buffer, 0); // connect
+        }
+        StreamReceive ();
+        Receive ();
+    }
+        
+    void I2PTunnelConnection::Connect ()
+    {
+        if (m_Socket)
+            m_Socket->async_connect (m_RemoteEndpoint, std::bind (&I2PTunnelConnection::HandleConnect,
+                shared_from_this (), std::placeholders::_1));
+    }   
+        
+    void I2PTunnelConnection::Terminate ()
+    {
+        if (Kill()) return;
+        if (m_Stream)
+        {
+            m_Stream->Close ();
+            m_Stream.reset ();
+        }   
+        m_Socket->close ();
+        Done(shared_from_this ());
+    }           
+
+    void I2PTunnelConnection::Receive ()
+    {
+        m_Socket->async_read_some (boost::asio::buffer(m_Buffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE),                
+            std::bind(&I2PTunnelConnection::HandleReceived, shared_from_this (), 
+            std::placeholders::_1, std::placeholders::_2));
+    }   
+    
+    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 ();
+        }
+        else
+        {   
+            if (m_Stream)
+            {   
+                auto s = shared_from_this ();
+                m_Stream->AsyncSend (m_Buffer, bytes_transferred,
+                    [s](const boost::system::error_code& ecode)
+                    {
+                        if (!ecode)
+                            s->Receive ();
+                        else
+                            s->Terminate ();
+                    });
+            }   
+        }
+    }   
+
+    void I2PTunnelConnection::HandleWrite (const boost::system::error_code& ecode)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel write error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+            StreamReceive ();
+    }
+
+    void I2PTunnelConnection::StreamReceive ()
+    {
+        if (m_Stream)
+            m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE),
+                std::bind (&I2PTunnelConnection::HandleStreamReceive, shared_from_this (),
+                    std::placeholders::_1, std::placeholders::_2),
+                I2P_TUNNEL_CONNECTION_MAX_IDLE);
+    }   
+
+    void I2PTunnelConnection::HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel stream read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+            Write (m_StreamBuffer, bytes_transferred);
+    }
+
+    void I2PTunnelConnection::Write (const uint8_t * buf, size_t len)
+    {
+        m_Socket->async_send (boost::asio::buffer (buf, len),
+            std::bind (&I2PTunnelConnection::HandleWrite, shared_from_this (), std::placeholders::_1));
+    }
+
+    void I2PTunnelConnection::HandleConnect (const boost::system::error_code& ecode)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel connect error: ", ecode.message ());
+            Terminate ();
+        }
+        else
+        {
+            LogPrint ("I2PTunnel connected");
+            if (m_IsQuiet)
+                StreamReceive ();
+            else
+            {
+                // send destination first like received from I2P
+                std::string dest = m_Stream->GetRemoteIdentity ().ToBase64 ();
+                dest += "\n";
+                memcpy (m_StreamBuffer, dest.c_str (), dest.size ());
+                HandleStreamReceive (boost::system::error_code (), dest.size ());
+            }   
+            Receive (); 
+        }
+    }
+
+    I2PTunnelConnectionHTTP::I2PTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+        const boost::asio::ip::tcp::endpoint& target, const std::string& host):
+        I2PTunnelConnection (owner, stream, socket, target), m_Host (host), m_HeaderSent (false)
+    {
+    }
+
+    void I2PTunnelConnectionHTTP::Write (const uint8_t * buf, size_t len)
+    {
+        if (m_HeaderSent)
+            I2PTunnelConnection::Write (buf, len);
+        else
+        {   
+            m_InHeader.clear ();
+            m_InHeader.write ((const char *)buf, len);
+            std::string line;
+            bool endOfHeader = false;
+            while (!endOfHeader)
+            {
+                std::getline(m_InHeader, line);
+                if (!m_InHeader.fail ())
+                {
+                    if (line.find ("Host:") != std::string::npos)
+                        m_OutHeader << "Host: " << m_Host << "\r\n";
+                    else
+                        m_OutHeader << line << "\n";
+                    if (line == "\r") endOfHeader = true;
+                }
+                else
+                    break;
+            }
+
+            if (endOfHeader)
+            {
+                m_OutHeader << m_InHeader.str (); // data right after header
+                m_HeaderSent = true;
+                I2PTunnelConnection::Write ((uint8_t *)m_OutHeader.str ().c_str (), m_OutHeader.str ().length ());
+            }
+        }   
+    }
+
+    /* This handler tries to stablish a connection with the desired server and dies if it fails to do so */
+    class I2PClientTunnelHandler: public I2PServiceHandler, public std::enable_shared_from_this<I2PClientTunnelHandler>
+    {
+        public:
+            I2PClientTunnelHandler (I2PClientTunnel * parent, i2p::data::IdentHash destination,
+                int destinationPort, std::shared_ptr<boost::asio::ip::tcp::socket> socket):
+                I2PServiceHandler(parent), m_DestinationIdentHash(destination), 
+                m_DestinationPort (destinationPort), m_Socket(socket) {};
+            void Handle();
+            void Terminate();
+        private:
+            void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
+            i2p::data::IdentHash m_DestinationIdentHash;
+            int m_DestinationPort;
+            std::shared_ptr<boost::asio::ip::tcp::socket> m_Socket;
+    };
+
+    void I2PClientTunnelHandler::Handle()
+    {
+        GetOwner()->GetLocalDestination ()->CreateStream ( 
+            std::bind (&I2PClientTunnelHandler::HandleStreamRequestComplete, shared_from_this(), std::placeholders::_1), 
+            m_DestinationIdentHash, m_DestinationPort);
+    }
+
+    void I2PClientTunnelHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream)
+        {
+            if (Kill()) return;
+            LogPrint (eLogInfo,"New I2PTunnel connection");
+            auto connection = std::make_shared<I2PTunnelConnection>(GetOwner(), m_Socket, stream);
+            GetOwner()->AddHandler (connection);
+            connection->I2PConnect ();
+            Done(shared_from_this());
+        }
+        else
+        {
+            LogPrint (eLogError,"I2P Client Tunnel Issue when creating the stream, check the previous warnings for more info.");
+            Terminate();
+        }
+    }
+
+    void I2PClientTunnelHandler::Terminate()
+    {
+        if (Kill()) return;
+        if (m_Socket)
+        {
+            m_Socket->close();
+            m_Socket = nullptr;
+        }
+        Done(shared_from_this());
+    }
+
+    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 ()
+    {
+        TCPIPAcceptor::Start ();
+        GetIdentHash();
+    }
+
+    void I2PClientTunnel::Stop ()
+    {
+        TCPIPAcceptor::Stop();
+        auto *originalIdentHash = m_DestinationIdentHash;
+        m_DestinationIdentHash = nullptr;
+        delete originalIdentHash;
+    }
+
+    /* HACK: maybe we should create a caching IdentHash provider in AddressBook */
+    const i2p::data::IdentHash * I2PClientTunnel::GetIdentHash ()
+    {
+        if (!m_DestinationIdentHash)
+        {
+            i2p::data::IdentHash identHash;
+            if (i2p::client::context.GetAddressBook ().GetIdentHash (m_Destination, identHash))
+                m_DestinationIdentHash = new i2p::data::IdentHash (identHash);
+            else
+                LogPrint (eLogWarning,"Remote destination ", m_Destination, " not found");
+        }
+        return m_DestinationIdentHash;
+    }
+
+    std::shared_ptr<I2PServiceHandler> I2PClientTunnel::CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+    {
+        const i2p::data::IdentHash *identHash = GetIdentHash();
+        if (identHash)
+            return  std::make_shared<I2PClientTunnelHandler>(this, *identHash, m_DestinationPort, socket);
+        else
+            return nullptr;
+    }
+
+    I2PServerTunnel::I2PServerTunnel (const std::string& address, int port, 
+        std::shared_ptr<ClientDestination> localDestination, int inport): 
+        I2PService (localDestination), m_Address (address), m_Port (port), m_IsAccessList (false)
+    {
+        m_PortDestination = localDestination->CreateStreamingDestination (inport > 0 ? inport : port);
+    }
+    
+    void I2PServerTunnel::Start ()
+    {
+        m_Endpoint.port (m_Port);   
+        boost::system::error_code ec;
+        auto addr = boost::asio::ip::address::from_string (m_Address, ec);
+        if (!ec)    
+        {
+            m_Endpoint.address (addr);
+            Accept ();
+        }
+        else
+        {
+            auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(GetService ());
+            resolver->async_resolve (boost::asio::ip::tcp::resolver::query (m_Address, ""), 
+                std::bind (&I2PServerTunnel::HandleResolve, this, 
+                    std::placeholders::_1, std::placeholders::_2, resolver));
+        }   
+    }
+
+    void I2PServerTunnel::Stop ()
+    {
+        ClearHandlers ();
+    }   
+
+    void I2PServerTunnel::HandleResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it, 
+        std::shared_ptr<boost::asio::ip::tcp::resolver> resolver)
+    {   
+        if (!ecode)
+        {   
+            auto addr = (*it).endpoint ().address ();
+            LogPrint (eLogInfo, "server tunnel ", (*it).host_name (), " has been resolved to ", addr);  
+            m_Endpoint.address (addr);
+            Accept ();  
+        }   
+        else
+            LogPrint (eLogError, "Unable to resolve server tunnel address: ", ecode.message ());
+    }
+
+    void I2PServerTunnel::SetAccessList (const std::set<i2p::data::IdentHash>& accessList)
+    {
+        m_AccessList = accessList;
+        m_IsAccessList = true;      
+    }
+
+    void I2PServerTunnel::Accept ()
+    {
+        if (m_PortDestination)
+            m_PortDestination->SetAcceptor (std::bind (&I2PServerTunnel::HandleAccept, this, std::placeholders::_1));
+
+        auto localDestination = GetLocalDestination (); 
+        if (localDestination)
+        {
+            if (!localDestination->IsAcceptingStreams ()) // set it as default if not set yet
+                localDestination->AcceptStreams (std::bind (&I2PServerTunnel::HandleAccept, this, std::placeholders::_1));
+        }
+        else
+            LogPrint ("Local destination not set for server tunnel");
+    }
+
+    void I2PServerTunnel::HandleAccept (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream)
+        {   
+            if (m_IsAccessList)
+            {
+                if (!m_AccessList.count (stream->GetRemoteIdentity ().GetIdentHash ()))
+                {
+                    LogPrint (eLogWarning, "Address ", stream->GetRemoteIdentity ().GetIdentHash ().ToBase32 (), " is not in white list. Incoming connection dropped");
+                    stream->Close ();
+                    return;
+                }
+            }
+            CreateI2PConnection (stream);
+        }   
+    }
+
+    void I2PServerTunnel::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        auto conn = std::make_shared<I2PTunnelConnection> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint ());
+        AddHandler (conn);
+        conn->Connect ();
+    }
+
+    I2PServerTunnelHTTP::I2PServerTunnelHTTP (const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, int inport):
+        I2PServerTunnel (address, port, localDestination, inport)
+    {
+    }
+
+    void I2PServerTunnelHTTP::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        auto conn = std::make_shared<I2PTunnelConnectionHTTP> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint (), GetAddress ());
+        AddHandler (conn);
+        conn->Connect ();
+    }
+}       
+}