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

core/Destination.h

@@ -0,0 +1,156 @@
+#ifndef DESTINATION_H__
+#define DESTINATION_H__
+
+#include <thread>
+#include <mutex>
+#include <memory>
+#include <map>
+#include <set>
+#include <string>
+#include <functional>
+#include <boost/asio.hpp>
+#include "Identity.h"
+#include "tunnel/TunnelPool.h"
+#include "crypto/CryptoConst.h"
+#include "LeaseSet.h"
+#include "Garlic.h"
+#include "NetDb.h"
+#include "Streaming.h"
+#include "Datagram.h"
+
+namespace i2p
+{
+namespace client
+{
+    const uint8_t PROTOCOL_TYPE_STREAMING = 6;
+    const uint8_t PROTOCOL_TYPE_DATAGRAM = 17;
+    const uint8_t PROTOCOL_TYPE_RAW = 18;   
+    const int PUBLISH_CONFIRMATION_TIMEOUT = 5; // in seconds
+    const int LEASESET_REQUEST_TIMEOUT = 5; // in seconds
+    const int MAX_LEASESET_REQUEST_TIMEOUT = 40; // in seconds
+    const int MAX_NUM_FLOODFILLS_PER_REQUEST = 7;
+    const int DESTINATION_CLEANUP_TIMEOUT = 20; // in minutes 
+    
+    // I2CP
+    const char I2CP_PARAM_INBOUND_TUNNEL_LENGTH[] = "inbound.length";
+    const int DEFAULT_INBOUND_TUNNEL_LENGTH = 3;
+    const char I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH[] = "outbound.length";
+    const int DEFAULT_OUTBOUND_TUNNEL_LENGTH = 3;
+    const char I2CP_PARAM_INBOUND_TUNNELS_QUANTITY[] = "inbound.quantity";
+    const int DEFAULT_INBOUND_TUNNELS_QUANTITY = 5;
+    const char I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY[] = "outbound.quantity";
+    const int DEFAULT_OUTBOUND_TUNNELS_QUANTITY = 5;
+    const char I2CP_PARAM_EXPLICIT_PEERS[] = "explicitPeers";
+    const int STREAM_REQUEST_TIMEOUT = 60; //in seconds
+
+    typedef std::function<void (std::shared_ptr<i2p::stream::Stream> stream)> StreamRequestComplete;
+
+    class ClientDestination: public i2p::garlic::GarlicDestination
+    {
+        typedef std::function<void (std::shared_ptr<i2p::data::LeaseSet> leaseSet)> RequestComplete;
+        // leaseSet = nullptr means not found
+        struct LeaseSetRequest
+        {
+            LeaseSetRequest (boost::asio::io_service& service): requestTime (0), requestTimeoutTimer (service) {};
+            std::set<i2p::data::IdentHash> excluded;
+            uint64_t requestTime;
+            boost::asio::deadline_timer requestTimeoutTimer;
+            RequestComplete requestComplete;
+        };  
+        
+        
+        public:
+
+            ClientDestination (const i2p::data::PrivateKeys& keys, bool isPublic, const std::map<std::string, std::string> * params = nullptr);
+            ~ClientDestination ();  
+
+            virtual void Start ();
+            virtual void Stop ();
+            bool IsRunning () const { return m_IsRunning; };
+            boost::asio::io_service& GetService () { return m_Service; };
+            std::shared_ptr<i2p::tunnel::TunnelPool> GetTunnelPool () { return m_Pool; }; 
+            bool IsReady () const { return m_LeaseSet && m_LeaseSet->HasNonExpiredLeases () && m_Pool->GetOutboundTunnels ().size () > 0; };
+            std::shared_ptr<const i2p::data::LeaseSet> FindLeaseSet (const i2p::data::IdentHash& ident);
+            bool RequestDestination (const i2p::data::IdentHash& dest, RequestComplete requestComplete = nullptr);
+            
+            // streaming
+            std::shared_ptr<i2p::stream::StreamingDestination> CreateStreamingDestination (int port); // additional
+            std::shared_ptr<i2p::stream::StreamingDestination> GetStreamingDestination (int port = 0) const;
+            // following methods operate with default streaming destination
+            void CreateStream (StreamRequestComplete streamRequestComplete, const i2p::data::IdentHash& dest, int port = 0);
+            std::shared_ptr<i2p::stream::Stream> CreateStream (std::shared_ptr<const i2p::data::LeaseSet> remote, int port = 0);
+            void AcceptStreams (const i2p::stream::StreamingDestination::Acceptor& acceptor);
+            void StopAcceptingStreams ();
+            bool IsAcceptingStreams () const;
+            
+            // datagram
+            i2p::datagram::DatagramDestination * GetDatagramDestination () const { return m_DatagramDestination; };
+            i2p::datagram::DatagramDestination * CreateDatagramDestination ();
+
+            // implements LocalDestination
+            const i2p::data::PrivateKeys& GetPrivateKeys () const { return m_Keys; };
+            const uint8_t * GetEncryptionPrivateKey () const { return m_EncryptionPrivateKey; };
+            const uint8_t * GetEncryptionPublicKey () const { return m_EncryptionPublicKey; };
+            
+            // implements GarlicDestination
+            std::shared_ptr<const i2p::data::LeaseSet> GetLeaseSet ();
+            std::shared_ptr<i2p::tunnel::TunnelPool> GetTunnelPool () const { return m_Pool; }
+            void HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from);
+
+            // override GarlicDestination
+            bool SubmitSessionKey (const uint8_t * key, const uint8_t * tag);
+            void ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg);
+            void ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);   
+            void SetLeaseSetUpdated ();
+
+            // I2CP
+            void HandleDataMessage (const uint8_t * buf, size_t len);
+
+        private:
+                
+            void Run ();            
+            void UpdateLeaseSet ();
+            void Publish ();
+            void HandlePublishConfirmationTimer (const boost::system::error_code& ecode);
+            void HandleDatabaseStoreMessage (const uint8_t * buf, size_t len);
+            void HandleDatabaseSearchReplyMessage (const uint8_t * buf, size_t len);
+            void HandleDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);        
+
+            void RequestLeaseSet (const i2p::data::IdentHash& dest, RequestComplete requestComplete);
+            bool SendLeaseSetRequest (const i2p::data::IdentHash& dest, std::shared_ptr<const i2p::data::RouterInfo>  nextFloodfill, LeaseSetRequest * request);    
+            void HandleRequestTimoutTimer (const boost::system::error_code& ecode, const i2p::data::IdentHash& dest);
+            void HandleCleanupTimer (const boost::system::error_code& ecode);
+            void CleanupRemoteLeaseSets ();
+            
+        private:
+
+            volatile bool m_IsRunning;
+            std::thread * m_Thread; 
+            boost::asio::io_service m_Service;
+            boost::asio::io_service::work m_Work;
+            i2p::data::PrivateKeys m_Keys;
+            uint8_t m_EncryptionPublicKey[256], m_EncryptionPrivateKey[256];
+            std::map<i2p::data::IdentHash, std::shared_ptr<i2p::data::LeaseSet> > m_RemoteLeaseSets;
+            std::map<i2p::data::IdentHash, LeaseSetRequest *> m_LeaseSetRequests;
+
+            std::shared_ptr<i2p::tunnel::TunnelPool> m_Pool;
+            std::shared_ptr<i2p::data::LeaseSet> m_LeaseSet;
+            bool m_IsPublic;
+            uint32_t m_PublishReplyToken;
+            std::set<i2p::data::IdentHash> m_ExcludedFloodfills; // for publishing
+            
+            std::shared_ptr<i2p::stream::StreamingDestination> m_StreamingDestination; // default
+            std::map<uint16_t, std::shared_ptr<i2p::stream::StreamingDestination> > m_StreamingDestinationsByPorts;
+            i2p::datagram::DatagramDestination * m_DatagramDestination;
+    
+            boost::asio::deadline_timer m_PublishConfirmationTimer, m_CleanupTimer;
+
+        public:
+            
+            // for HTTP only
+            int GetNumRemoteLeaseSets () const { return m_RemoteLeaseSets.size (); };
+    };  
+}   
+}   
+
+#endif