i2pd/Streaming.h

236 lines
7.7 KiB
C
Raw Normal View History

2013-12-13 02:36:24 +00:00
#ifndef STREAMING_H__
#define STREAMING_H__
#include <inttypes.h>
2014-03-19 20:38:55 +00:00
#include <string>
#include <map>
#include <set>
2014-04-12 01:13:52 +00:00
#include <queue>
2014-03-23 20:00:05 +00:00
#include <thread>
#include <boost/asio.hpp>
2014-03-25 18:26:39 +00:00
#include <boost/bind.hpp>
2014-01-01 23:19:03 +00:00
#include <cryptopp/dsa.h>
#include "I2PEndian.h"
2013-12-31 01:46:33 +00:00
#include "Identity.h"
2014-01-01 23:19:03 +00:00
#include "LeaseSet.h"
#include "I2NPProtocol.h"
2014-01-11 03:23:17 +00:00
#include "Tunnel.h"
2014-03-15 13:16:55 +00:00
#include "TunnelPool.h"
2013-12-13 02:36:24 +00:00
namespace i2p
{
namespace stream
{
const uint16_t PACKET_FLAG_SYNCHRONIZE = 0x0001;
const uint16_t PACKET_FLAG_CLOSE = 0x0002;
const uint16_t PACKET_FLAG_RESET = 0x0004;
const uint16_t PACKET_FLAG_SIGNATURE_INCLUDED = 0x0008;
const uint16_t PACKET_FLAG_SIGNATURE_REQUESTED = 0x0010;
const uint16_t PACKET_FLAG_FROM_INCLUDED = 0x0020;
const uint16_t PACKET_FLAG_DELAY_REQUESTED = 0x0040;
const uint16_t PACKET_FLAG_MAX_PACKET_SIZE_INCLUDED = 0x0080;
const uint16_t PACKET_FLAG_PROFILE_INTERACTIVE = 0x0100;
const uint16_t PACKET_FLAG_ECHO = 0x0200;
const uint16_t PACKET_FLAG_NO_ACK = 0x0400;
2014-01-12 20:57:10 +00:00
const size_t STREAMING_MTU = 1730;
const size_t MAX_PACKET_SIZE = 1754;
2014-01-11 01:21:38 +00:00
struct Packet
{
2014-03-24 23:27:20 +00:00
uint8_t buf[MAX_PACKET_SIZE];
2014-01-11 01:21:38 +00:00
size_t len, offset;
Packet (): len (0), offset (0) {};
uint8_t * GetBuffer () { return buf + offset; };
size_t GetLength () const { return len - offset; };
2014-01-30 04:13:59 +00:00
uint32_t GetSendStreamID () const { return be32toh (*(uint32_t *)buf); };
uint32_t GetReceiveStreamID () const { return be32toh (*(uint32_t *)(buf + 4)); };
uint32_t GetSeqn () const { return be32toh (*(uint32_t *)(buf + 8)); };
uint32_t GetAckThrough () const { return be32toh (*(uint32_t *)(buf + 12)); };
uint8_t GetNACKCount () const { return buf[16]; };
const uint8_t * GetOption () const { return buf + 17 + GetNACKCount ()*4 + 3; }; // 3 = resendDelay + flags
uint16_t GetFlags () const { return be16toh (*(uint16_t *)(GetOption () - 2)); };
uint16_t GetOptionSize () const { return be16toh (*(uint16_t *)GetOption ()); };
const uint8_t * GetOptionData () const { return GetOption () + 2; };
const uint8_t * GetPayload () const { return GetOptionData () + GetOptionSize (); };
};
struct PacketCmp
{
bool operator() (const Packet * p1, const Packet * p2) const
{
2014-01-30 04:13:59 +00:00
return p1->GetSeqn () < p2->GetSeqn ();
};
2014-01-11 01:21:38 +00:00
};
2013-12-31 01:46:33 +00:00
class StreamingDestination;
class Stream
{
public:
2014-03-23 20:00:05 +00:00
Stream (boost::asio::io_service& service, StreamingDestination * local, const i2p::data::LeaseSet& remote);
2014-01-11 01:21:38 +00:00
~Stream ();
uint32_t GetSendStreamID () const { return m_SendStreamID; };
uint32_t GetRecvStreamID () const { return m_RecvStreamID; };
const i2p::data::LeaseSet& GetRemoteLeaseSet () const { return m_RemoteLeaseSet; };
2014-01-12 20:57:10 +00:00
bool IsOpen () const { return m_IsOpen; };
2014-01-10 03:26:30 +00:00
bool IsEstablished () const { return m_SendStreamID; };
2014-01-01 23:19:03 +00:00
2014-01-11 01:21:38 +00:00
void HandleNextPacket (Packet * packet);
2014-04-18 23:27:39 +00:00
size_t Send (const uint8_t * buf, size_t len, int timeout); // timeout in seconds
2014-04-10 19:34:51 +00:00
2014-03-25 18:26:39 +00:00
template<typename Buffer, typename ReceiveHandler>
void AsyncReceive (const Buffer& buffer, ReceiveHandler handler, int timeout = 0);
2014-01-12 20:57:10 +00:00
void Close ();
2014-03-18 02:55:02 +00:00
void SetLeaseSetUpdated () { m_LeaseSetUpdated = true; };
2014-03-25 18:26:39 +00:00
2014-01-11 03:23:17 +00:00
private:
void SendQuickAck ();
2014-03-24 23:27:20 +00:00
bool SendPacket (Packet * packet);
bool SendPacket (const uint8_t * buf, size_t len);
void SavePacket (Packet * packet);
2014-02-02 03:20:41 +00:00
void ProcessPacket (Packet * packet);
2014-03-26 19:06:27 +00:00
size_t ConcatenatePackets (uint8_t * buf, size_t len);
2014-03-23 13:25:16 +00:00
void UpdateCurrentRemoteLease ();
2014-03-25 18:26:39 +00:00
template<typename Buffer, typename ReceiveHandler>
void HandleReceiveTimer (const boost::system::error_code& ecode, const Buffer& buffer, ReceiveHandler handler);
private:
2014-03-23 20:00:05 +00:00
boost::asio::io_service& m_Service;
2014-01-11 03:23:17 +00:00
uint32_t m_SendStreamID, m_RecvStreamID, m_SequenceNumber, m_LastReceivedSequenceNumber;
2014-03-18 02:55:02 +00:00
bool m_IsOpen, m_LeaseSetUpdated;
2013-12-31 01:46:33 +00:00
StreamingDestination * m_LocalDestination;
const i2p::data::LeaseSet& m_RemoteLeaseSet;
2014-03-23 13:25:16 +00:00
i2p::data::Lease m_CurrentRemoteLease;
2014-04-12 01:13:52 +00:00
std::queue<Packet *> m_ReceiveQueue;
std::set<Packet *, PacketCmp> m_SavedPackets;
2014-01-11 03:23:17 +00:00
i2p::tunnel::OutboundTunnel * m_OutboundTunnel;
2014-03-25 18:26:39 +00:00
boost::asio::deadline_timer m_ReceiveTimer;
};
class StreamingDestination: public i2p::data::LocalDestination
2013-12-13 02:36:24 +00:00
{
public:
2013-12-31 01:46:33 +00:00
StreamingDestination ();
2014-03-19 20:38:55 +00:00
StreamingDestination (const std::string& fullPath);
2014-03-15 00:24:12 +00:00
~StreamingDestination ();
2014-03-20 02:03:50 +00:00
const i2p::data::PrivateKeys& GetKeys () const { return m_Keys; };
const i2p::data::Identity& GetIdentity () const { return m_Keys.pub; };
2014-03-20 13:47:02 +00:00
const I2NPMessage * GetLeaseSet ();
2014-03-16 20:03:20 +00:00
i2p::tunnel::TunnelPool * GetTunnelPool () const { return m_Pool; };
void Sign (uint8_t * buf, int len, uint8_t * signature) const;
2014-03-23 20:00:05 +00:00
Stream * CreateNewStream (boost::asio::io_service& service, const i2p::data::LeaseSet& remote);
2014-01-01 23:19:03 +00:00
void DeleteStream (Stream * stream);
2014-01-11 01:21:38 +00:00
void HandleNextPacket (Packet * packet);
2014-01-09 03:47:22 +00:00
// implements LocalDestination
2014-03-15 13:16:55 +00:00
void UpdateLeaseSet ();
2014-04-01 17:42:04 +00:00
const i2p::data::IdentHash& GetIdentHash () const { return m_IdentHash; };
const uint8_t * GetEncryptionPrivateKey () const { return m_EncryptionPrivateKey; };
const uint8_t * GetEncryptionPublicKey () const { return m_EncryptionPublicKey; };
2014-01-09 03:47:22 +00:00
private:
I2NPMessage * CreateLeaseSet () const;
2013-12-31 01:46:33 +00:00
private:
std::map<uint32_t, Stream *> m_Streams;
2014-03-20 02:03:50 +00:00
i2p::data::PrivateKeys m_Keys;
2013-12-31 01:46:33 +00:00
i2p::data::IdentHash m_IdentHash;
uint8_t m_EncryptionPublicKey[256], m_EncryptionPrivateKey[256];
2014-03-15 13:16:55 +00:00
i2p::tunnel::TunnelPool * m_Pool;
2014-01-09 03:47:22 +00:00
I2NPMessage * m_LeaseSet;
2014-01-01 23:19:03 +00:00
CryptoPP::DSA::PrivateKey m_SigningPrivateKey;
};
2014-01-01 23:19:03 +00:00
2014-03-23 20:00:05 +00:00
class StreamingDestinations
{
public:
StreamingDestinations (): m_IsRunning (false), m_Thread (nullptr),
m_Work (m_Service), m_SharedLocalDestination (nullptr) {};
~StreamingDestinations () {};
void Start ();
void Stop ();
void HandleNextPacket (i2p::data::IdentHash destination, Packet * packet);
2014-03-23 20:00:05 +00:00
Stream * CreateClientStream (const i2p::data::LeaseSet& remote);
void DeleteClientStream (Stream * stream);
private:
void Run ();
void PostNextPacket (i2p::data::IdentHash destination, Packet * packet);
2014-03-23 20:00:05 +00:00
private:
bool m_IsRunning;
std::thread * m_Thread;
boost::asio::io_service m_Service;
boost::asio::io_service::work m_Work;
StreamingDestination * m_SharedLocalDestination;
};
Stream * CreateStream (const i2p::data::LeaseSet& remote);
void DeleteStream (Stream * stream);
2014-03-15 13:16:55 +00:00
void StartStreaming ();
void StopStreaming ();
2013-12-13 02:36:24 +00:00
// assuming data is I2CP message
2014-03-23 20:00:05 +00:00
void HandleDataMessage (i2p::data::IdentHash destination, const uint8_t * buf, size_t len);
2014-03-24 23:27:20 +00:00
I2NPMessage * CreateDataMessage (Stream * s, const uint8_t * payload, size_t len);
2014-03-25 18:26:39 +00:00
//-------------------------------------------------
template<typename Buffer, typename ReceiveHandler>
void Stream::AsyncReceive (const Buffer& buffer, ReceiveHandler handler, int timeout)
{
2014-04-12 01:13:52 +00:00
if (!m_ReceiveQueue.empty ())
2014-03-27 19:56:13 +00:00
{
size_t received = ConcatenatePackets (boost::asio::buffer_cast<uint8_t *>(buffer), boost::asio::buffer_size(buffer));
if (received)
{
// TODO: post to stream's thread
handler (boost::system::error_code (), received);
return;
}
}
2014-03-25 18:26:39 +00:00
m_ReceiveTimer.expires_from_now (boost::posix_time::seconds(timeout));
2014-04-23 21:51:12 +00:00
m_ReceiveTimer.async_wait ([=](const boost::system::error_code& ecode)
2014-04-23 17:44:08 +00:00
{ this->HandleReceiveTimer (ecode, buffer, handler); });
2014-03-25 18:26:39 +00:00
}
template<typename Buffer, typename ReceiveHandler>
void Stream::HandleReceiveTimer (const boost::system::error_code& ecode, const Buffer& buffer, ReceiveHandler handler)
{
2014-03-26 19:06:27 +00:00
size_t received = ConcatenatePackets (boost::asio::buffer_cast<uint8_t *>(buffer), boost::asio::buffer_size(buffer));
2014-03-25 18:26:39 +00:00
if (ecode == boost::asio::error::operation_aborted)
// timeout not expired
2014-03-26 19:06:27 +00:00
handler (boost::system::error_code (), received);
2014-03-25 18:26:39 +00:00
else
// timeout expired
2014-03-26 19:06:27 +00:00
handler (boost::asio::error::make_error_code (boost::asio::error::timed_out), received);
2014-03-25 18:26:39 +00:00
}
2013-12-13 02:36:24 +00:00
}
}
#endif