i2pd/libi2pd/SSUData.h

139 lines
4.0 KiB
C
Raw Normal View History

/*
* Copyright (c) 2013-2021, 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-04-22 19:39:26 +04:00
#ifndef SSU_DATA_H__
#define SSU_DATA_H__
#include <inttypes.h>
2014-07-15 06:06:58 +04:00
#include <string.h>
2014-06-12 19:14:22 +04:00
#include <vector>
2021-09-26 01:30:17 +03:00
#include <map>
#include <unordered_map>
2015-01-31 04:30:39 +03:00
#include <memory>
2014-07-20 18:38:39 +04:00
#include <boost/asio.hpp>
2014-04-22 19:39:26 +04:00
#include "I2NPProtocol.h"
2014-09-18 22:37:29 +04:00
#include "Identity.h"
#include "RouterInfo.h"
2014-04-22 19:39:26 +04:00
namespace i2p
{
namespace transport
2014-04-22 19:39:26 +04:00
{
2014-10-29 18:17:30 +03:00
const size_t SSU_MTU_V4 = 1484;
2016-06-27 22:06:15 +03:00
#ifdef MESHNET
2016-06-27 22:28:26 +03:00
const size_t SSU_MTU_V6 = 1286;
2016-06-27 22:06:15 +03:00
#else
2017-02-12 18:12:12 +03:00
const size_t SSU_MTU_V6 = 1488;
2016-06-27 22:06:15 +03:00
#endif
2014-09-15 01:54:55 +04:00
const size_t IPV4_HEADER_SIZE = 20;
2018-01-06 06:48:51 +03:00
const size_t IPV6_HEADER_SIZE = 40;
2014-09-15 01:54:55 +04:00
const size_t UDP_HEADER_SIZE = 8;
2014-10-29 18:17:30 +03:00
const size_t SSU_V4_MAX_PACKET_SIZE = SSU_MTU_V4 - IPV4_HEADER_SIZE - UDP_HEADER_SIZE; // 1456
2017-02-12 18:12:12 +03:00
const size_t SSU_V6_MAX_PACKET_SIZE = SSU_MTU_V6 - IPV6_HEADER_SIZE - UDP_HEADER_SIZE; // 1440
2014-07-20 18:38:39 +04:00
const int RESEND_INTERVAL = 3; // in seconds
const int MAX_NUM_RESENDS = 5;
2015-02-08 16:50:05 +03:00
const int DECAY_INTERVAL = 20; // in seconds
const int INCOMPLETE_MESSAGES_CLEANUP_TIMEOUT = 30; // in seconds
const int RECEIVED_MESSAGES_CLEANUP_TIMEOUT = 40; // in seconds
2015-12-17 10:58:09 +03:00
const unsigned int MAX_NUM_RECEIVED_MESSAGES = 1000; // how many msgID we store for duplicates check
2016-06-27 00:03:04 +03:00
const int MAX_OUTGOING_WINDOW_SIZE = 200; // how many unacked message we can store
2014-04-22 19:39:26 +04:00
// data flags
const uint8_t DATA_FLAG_EXTENDED_DATA_INCLUDED = 0x02;
const uint8_t DATA_FLAG_WANT_REPLY = 0x04;
const uint8_t DATA_FLAG_REQUEST_PREVIOUS_ACKS = 0x08;
const uint8_t DATA_FLAG_EXPLICIT_CONGESTION_NOTIFICATION = 0x10;
const uint8_t DATA_FLAG_ACK_BITFIELDS_INCLUDED = 0x40;
2018-01-06 06:48:51 +03:00
const uint8_t DATA_FLAG_EXPLICIT_ACKS_INCLUDED = 0x80;
2014-04-22 19:39:26 +04:00
2014-07-15 06:06:58 +04:00
struct Fragment
{
2014-07-20 18:38:39 +04:00
int fragmentNum;
size_t len;
2014-07-15 06:06:58 +04:00
bool isLast;
2014-10-29 18:17:30 +03:00
uint8_t buf[SSU_V4_MAX_PACKET_SIZE + 18]; // use biggest
2014-07-15 06:06:58 +04:00
2014-07-20 18:38:39 +04:00
Fragment () = default;
2018-01-06 06:48:51 +03:00
Fragment (int n, const uint8_t * b, int l, bool last):
fragmentNum (n), len (l), isLast (last) { memcpy (buf, b, len); };
};
2014-07-15 06:06:58 +04:00
struct FragmentCmp
{
bool operator() (const std::shared_ptr<Fragment>& f1, const std::shared_ptr<Fragment>& f2) const
2018-01-06 07:01:44 +03:00
{
2018-01-06 06:48:51 +03:00
return f1->fragmentNum < f2->fragmentNum;
2014-07-15 06:06:58 +04:00
};
2018-01-06 06:48:51 +03:00
};
2014-07-15 06:06:58 +04:00
struct IncompleteMessage
{
std::shared_ptr<I2NPMessage> msg;
2018-01-06 06:48:51 +03:00
int nextFragmentNum;
2015-02-08 16:50:05 +03:00
uint32_t lastFragmentInsertTime; // in seconds
2020-12-13 05:40:07 +03:00
uint64_t receivedFragmentsBits;
std::set<std::shared_ptr<Fragment>, FragmentCmp> savedFragments;
2018-01-06 06:48:51 +03:00
IncompleteMessage (std::shared_ptr<I2NPMessage> m): msg (m), nextFragmentNum (0),
2020-12-13 05:40:07 +03:00
lastFragmentInsertTime (0), receivedFragmentsBits (0) {};
2018-01-06 06:48:51 +03:00
void AttachNextFragment (const uint8_t * fragment, size_t fragmentSize);
2014-07-15 06:06:58 +04:00
};
2014-07-20 02:53:02 +04:00
struct SentMessage
{
std::vector<std::shared_ptr<Fragment> > fragments;
2014-07-20 02:53:02 +04:00
uint32_t nextResendTime; // in seconds
int numResends;
2018-01-06 06:48:51 +03:00
};
2014-04-22 19:39:26 +04:00
class SSUSession;
class SSUData
{
public:
2018-01-06 06:48:51 +03:00
SSUData (SSUSession& session);
2014-04-22 19:39:26 +04:00
~SSUData ();
2015-02-08 16:50:05 +03:00
void Start ();
2018-01-06 06:48:51 +03:00
void Stop ();
2021-09-23 02:09:56 +03:00
void CleanUp (uint64_t ts);
2014-04-22 19:39:26 +04:00
void ProcessMessage (uint8_t * buf, size_t len);
2015-02-15 22:17:55 +03:00
void FlushReceivedMessage ();
void Send (std::shared_ptr<i2p::I2NPMessage> msg);
2014-04-22 19:39:26 +04:00
2018-01-06 06:48:51 +03:00
void AdjustPacketSize (std::shared_ptr<const i2p::data::RouterInfo> remoteRouter);
2014-09-18 22:37:29 +04:00
void UpdatePacketSize (const i2p::data::IdentHash& remoteIdent);
2014-06-10 19:19:31 +04:00
private:
void SendMsgAck (uint32_t msgID);
2020-12-13 05:40:07 +03:00
void SendFragmentAck (uint32_t msgID, uint64_t bits);
2014-07-17 23:22:32 +04:00
void ProcessAcks (uint8_t *& buf, uint8_t flag);
void ProcessFragments (uint8_t * buf);
2018-01-06 06:48:51 +03:00
void ProcessSentMessageAck (uint32_t msgID);
2014-06-10 19:19:31 +04:00
2014-07-20 18:38:39 +04:00
void ScheduleResend ();
2018-01-06 06:48:51 +03:00
void HandleResendTimer (const boost::system::error_code& ecode);
2015-02-08 16:50:05 +03:00
2018-01-06 06:48:51 +03:00
private:
2014-04-22 19:39:26 +04:00
SSUSession& m_Session;
2021-09-26 01:30:17 +03:00
std::map<uint32_t, std::shared_ptr<IncompleteMessage> > m_IncompleteMessages;
std::map<uint32_t, std::shared_ptr<SentMessage> > m_SentMessages;
std::unordered_map<uint32_t, uint64_t> m_ReceivedMessages; // msgID -> timestamp in seconds
boost::asio::deadline_timer m_ResendTimer;
2014-10-29 18:17:30 +03:00
int m_MaxPacketSize, m_PacketSize;
2015-01-30 06:35:57 +03:00
i2p::I2NPMessagesHandler m_Handler;
2016-08-07 23:27:36 +03:00
uint32_t m_LastMessageReceivedTime; // in second
2018-01-06 06:48:51 +03:00
};
2014-04-22 19:39:26 +04:00
}
}
#endif