i2pd/TransportSession.h

#ifndef TRANSPORT_SESSION_H__
#define TRANSPORT_SESSION_H__

#include <inttypes.h>
#include <iostream>
#include <memory>
#include <vector>
#include "Identity.h"
#include "RouterInfo.h"
#include "I2NPProtocol.h"

namespace i2p
{
namespace transport
{
    struct DHKeysPair // transient keys for transport sessions
    {
        uint8_t publicKey[256];
        uint8_t privateKey[256];
    };  

    class SignedData
    {
        public:

            SignedData () {};
            void Insert (const uint8_t * buf, size_t len) 
            { 
                m_Stream.write ((char *)buf, len); 
            }           

            template<typename T>
            void Insert (T t)
            {
                m_Stream.write ((char *)&t, sizeof (T)); 
            }

            bool Verify (const i2p::data::IdentityEx& ident, const uint8_t * signature) const
            {
                return ident.Verify ((const uint8_t *)m_Stream.str ().c_str (), m_Stream.str ().size (), signature); 
            }

            void Sign (const i2p::data::PrivateKeys& keys, uint8_t * signature) const
            {
                keys.Sign ((const uint8_t *)m_Stream.str ().c_str (), m_Stream.str ().size (), signature); 
            }   

        private:
        
            std::stringstream m_Stream;
    };      

    class TransportSession
    {
        public:

            TransportSession (std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter): 
                m_RemoteRouter (in_RemoteRouter), m_DHKeysPair (nullptr), 
                m_NumSentBytes (0), m_NumReceivedBytes (0)
            {
                if (m_RemoteRouter)
                    m_RemoteIdentity = m_RemoteRouter->GetRouterIdentity ();
            }

            virtual ~TransportSession () { delete m_DHKeysPair; };
            virtual void Done () = 0;
            
            std::shared_ptr<const i2p::data::RouterInfo> GetRemoteRouter () { return m_RemoteRouter; };
            const i2p::data::IdentityEx& GetRemoteIdentity () { return m_RemoteIdentity; };

            size_t GetNumSentBytes () const { return m_NumSentBytes; };
            size_t GetNumReceivedBytes () const { return m_NumReceivedBytes; };
            
            virtual void SendI2NPMessages (const std::vector<std::shared_ptr<I2NPMessage> >& msgs) = 0;
            
        protected:

            std::shared_ptr<const i2p::data::RouterInfo> m_RemoteRouter;
            i2p::data::IdentityEx m_RemoteIdentity; 
            DHKeysPair * m_DHKeysPair; // X - for client and Y - for server
            size_t m_NumSentBytes, m_NumReceivedBytes;
    };  
}
}

#endif