i2pd/libi2pd/SSU.h

160 lines
6.4 KiB
C
Raw Normal View History

/*
* Copyright (c) 2013-2022, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/
2014-01-24 01:10:33 +04:00
#ifndef SSU_H__
#define SSU_H__
#include <inttypes.h>
2014-06-17 21:15:32 +04:00
#include <string.h>
2014-01-25 01:30:07 +04:00
#include <map>
2014-02-10 03:28:34 +04:00
#include <list>
2014-04-09 22:58:30 +04:00
#include <set>
2014-04-20 04:45:41 +04:00
#include <thread>
2015-02-07 23:25:06 +03:00
#include <mutex>
2014-01-24 01:10:33 +04:00
#include <boost/asio.hpp>
2015-11-03 17:15:49 +03:00
#include "Crypto.h"
#include "util.h"
2014-01-28 01:52:17 +04:00
#include "I2PEndian.h"
2014-04-04 22:56:46 +04:00
#include "Identity.h"
2014-01-29 01:49:54 +04:00
#include "RouterInfo.h"
2014-01-30 01:49:53 +04:00
#include "I2NPProtocol.h"
2014-10-30 22:13:12 +03:00
#include "SSUSession.h"
2014-01-24 01:10:33 +04:00
namespace i2p
{
namespace transport
2014-01-24 01:10:33 +04:00
{
2018-01-06 06:48:51 +03:00
const int SSU_KEEP_ALIVE_INTERVAL = 30; // 30 seconds
const int SSU_PEER_TEST_TIMEOUT = 60; // 60 seconds
2014-09-06 00:35:02 +04:00
const int SSU_TO_INTRODUCER_SESSION_DURATION = 3600; // 1 hour
const int SSU_TO_INTRODUCER_SESSION_EXPIRATION = 4800; // 80 minutes
const int SSU_TERMINATION_CHECK_TIMEOUT = 30; // 30 seconds
2014-09-09 16:03:05 +04:00
const size_t SSU_MAX_NUM_INTRODUCERS = 3;
2017-01-19 19:19:09 +03:00
const size_t SSU_SOCKET_RECEIVE_BUFFER_SIZE = 0x1FFFF; // 128K
2017-01-19 23:47:01 +03:00
const size_t SSU_SOCKET_SEND_BUFFER_SIZE = 0x1FFFF; // 128K
2015-02-09 04:28:18 +03:00
struct SSUPacket
{
2017-02-12 18:12:12 +03:00
i2p::crypto::AESAlignedBuffer<SSU_MTU_V6 + 18> buf; // max MTU + iv + size
2015-02-09 04:28:18 +03:00
boost::asio::ip::udp::endpoint from;
size_t len;
2018-01-06 06:48:51 +03:00
};
2014-01-24 01:10:33 +04:00
class SSUServer
{
public:
2014-04-20 04:45:41 +04:00
SSUServer (int port);
2014-01-25 01:30:07 +04:00
~SSUServer ();
2014-01-24 01:10:33 +04:00
void Start ();
void Stop ();
2021-04-04 17:36:22 +03:00
bool CreateSession (std::shared_ptr<const i2p::data::RouterInfo> router, bool peerTest = false, bool v4only = false);
bool CreateSession (std::shared_ptr<const i2p::data::RouterInfo> router,
2021-02-23 05:04:26 +03:00
std::shared_ptr<const i2p::data::RouterInfo::Address> address, bool peerTest = false);
2015-12-10 06:17:43 +03:00
void CreateDirectSession (std::shared_ptr<const i2p::data::RouterInfo> router, boost::asio::ip::udp::endpoint remoteEndpoint, bool peerTest);
2014-11-24 20:26:11 +03:00
std::shared_ptr<SSUSession> FindSession (const boost::asio::ip::udp::endpoint& e) const;
std::shared_ptr<SSUSession> GetRandomEstablishedV4Session (std::shared_ptr<const SSUSession> excluded);
std::shared_ptr<SSUSession> GetRandomEstablishedV6Session (std::shared_ptr<const SSUSession> excluded);
2014-11-24 20:26:11 +03:00
void DeleteSession (std::shared_ptr<SSUSession> session);
2018-01-06 06:48:51 +03:00
void DeleteAllSessions ();
2014-02-22 01:13:36 +04:00
2015-01-12 05:00:38 +03:00
boost::asio::io_service& GetService () { return m_Service; };
i2p::util::MemoryPool<Fragment>& GetFragmentsPool () { return m_FragmentsPool; };
i2p::util::MemoryPool<IncompleteMessage>& GetIncompleteMessagesPool () { return m_IncompleteMessagesPool; };
i2p::util::MemoryPool<SentMessage>& GetSentMessagesPool () { return m_SentMessagesPool; };
2021-03-01 20:20:53 +03:00
uint16_t GetPort () const { return m_Endpoint.port (); };
bool IsSyncClockFromPeers () const { return m_IsSyncClockFromPeers; };
2021-02-28 00:13:12 +03:00
void SetLocalAddress (const boost::asio::ip::address& localAddress);
2014-06-10 18:39:29 +04:00
void Send (const uint8_t * buf, size_t len, const boost::asio::ip::udp::endpoint& to);
2016-12-31 01:53:54 +03:00
void AddRelay (uint32_t tag, std::shared_ptr<SSUSession> relay);
2016-12-30 06:06:33 +03:00
void RemoveRelay (uint32_t tag);
2014-11-24 20:26:11 +03:00
std::shared_ptr<SSUSession> FindRelaySession (uint32_t tag);
void RescheduleIntroducersUpdateTimer ();
2021-04-21 03:02:30 +03:00
void RescheduleIntroducersUpdateTimerV6 ();
2015-03-26 23:10:52 +03:00
void NewPeerTest (uint32_t nonce, PeerTestParticipant role, std::shared_ptr<SSUSession> session = nullptr);
2015-02-26 05:56:51 +03:00
PeerTestParticipant GetPeerTestParticipant (uint32_t nonce);
2015-03-26 23:10:52 +03:00
std::shared_ptr<SSUSession> GetPeerTestSession (uint32_t nonce);
2015-02-26 05:56:51 +03:00
void UpdatePeerTest (uint32_t nonce, PeerTestParticipant role);
void RemovePeerTest (uint32_t nonce);
2018-01-06 06:48:51 +03:00
2014-01-24 01:10:33 +04:00
private:
2016-12-01 05:14:10 +03:00
void OpenSocket ();
void OpenSocketV6 ();
2014-04-20 04:45:41 +04:00
void Run ();
2015-02-09 04:28:18 +03:00
void RunReceivers ();
2017-01-19 23:47:01 +03:00
void RunReceiversV6 ();
2014-01-24 01:10:33 +04:00
void Receive ();
2014-10-29 22:02:48 +03:00
void ReceiveV6 ();
2015-02-09 04:28:18 +03:00
void HandleReceivedFrom (const boost::system::error_code& ecode, std::size_t bytes_transferred, SSUPacket * packet);
void HandleReceivedFromV6 (const boost::system::error_code& ecode, std::size_t bytes_transferred, SSUPacket * packet);
void HandleReceivedPackets (std::vector<SSUPacket *> packets,
2015-12-01 03:45:57 +03:00
std::map<boost::asio::ip::udp::endpoint, std::shared_ptr<SSUSession> >* sessions);
2014-01-24 01:10:33 +04:00
void CreateSessionThroughIntroducer (std::shared_ptr<const i2p::data::RouterInfo> router,
std::shared_ptr<const i2p::data::RouterInfo::Address> address, bool peerTest = false);
2014-09-04 00:49:48 +04:00
template<typename Filter>
std::shared_ptr<SSUSession> GetRandomV4Session (Filter filter);
template<typename Filter>
2018-01-06 06:48:51 +03:00
std::shared_ptr<SSUSession> GetRandomV6Session (Filter filter);
std::list<std::shared_ptr<SSUSession> > FindIntroducers (int maxNumIntroducers, bool v4, std::set<i2p::data::IdentHash>& excluded);
2014-09-07 04:43:20 +04:00
void ScheduleIntroducersUpdateTimer ();
2021-04-21 03:02:30 +03:00
void ScheduleIntroducersUpdateTimerV6 ();
void HandleIntroducersUpdateTimer (const boost::system::error_code& ecode, bool v4);
2015-02-25 23:26:06 +03:00
2015-02-26 22:54:28 +03:00
void SchedulePeerTestsCleanupTimer ();
void HandlePeerTestsCleanupTimer (const boost::system::error_code& ecode);
// timer
void ScheduleTermination ();
void HandleTerminationTimer (const boost::system::error_code& ecode);
void ScheduleTerminationV6 ();
void HandleTerminationTimerV6 (const boost::system::error_code& ecode);
2014-01-24 01:10:33 +04:00
private:
2014-04-20 04:45:41 +04:00
2015-02-26 05:56:51 +03:00
struct PeerTest
{
uint64_t creationTime;
PeerTestParticipant role;
2015-03-26 23:10:52 +03:00
std::shared_ptr<SSUSession> session; // for Bob to Alice
2016-06-27 17:24:37 +03:00
};
2018-01-06 06:48:51 +03:00
volatile bool m_IsRunning;
std::thread * m_Thread, * m_ReceiversThread, * m_ReceiversThreadV6;
boost::asio::io_service m_Service, m_ReceiversService, m_ReceiversServiceV6;
boost::asio::io_service::work m_Work, m_ReceiversWork, m_ReceiversWorkV6;
2014-10-29 22:02:48 +03:00
boost::asio::ip::udp::endpoint m_Endpoint, m_EndpointV6;
boost::asio::ip::udp::socket m_Socket, m_SocketV6;
boost::asio::deadline_timer m_IntroducersUpdateTimer, m_IntroducersUpdateTimerV6,
2021-04-21 03:02:30 +03:00
m_PeerTestsCleanupTimer, m_TerminationTimer, m_TerminationTimerV6;
bool m_IsSyncClockFromPeers;
2021-04-21 03:02:30 +03:00
std::list<boost::asio::ip::udp::endpoint> m_Introducers, m_IntroducersV6; // introducers we are connected to
std::map<boost::asio::ip::udp::endpoint, std::shared_ptr<SSUSession> > m_Sessions, m_SessionsV6;
2016-12-31 01:53:54 +03:00
std::map<uint32_t, std::shared_ptr<SSUSession> > m_Relays; // we are introducer
2021-09-26 01:30:17 +03:00
std::map<uint32_t, PeerTest> m_PeerTests; // nonce -> creation time in milliseconds
2018-01-06 06:48:51 +03:00
i2p::util::MemoryPool<Fragment> m_FragmentsPool;
i2p::util::MemoryPool<IncompleteMessage> m_IncompleteMessagesPool;
i2p::util::MemoryPool<SentMessage> m_SentMessagesPool;
2021-09-13 20:13:27 +03:00
i2p::util::MemoryPoolMt<SSUPacket> m_PacketsPool;
2014-02-25 07:28:28 +04:00
public:
// for HTTP only
const decltype(m_Sessions)& GetSessions () const { return m_Sessions; };
const decltype(m_SessionsV6)& GetSessionsV6 () const { return m_SessionsV6; };
2014-01-24 01:10:33 +04:00
};
}
}
#endif