mirror of
https://github.com/PurpleI2P/i2pd.git
synced 2025-07-01 10:14:36 +02:00
447 lines
16 KiB
C++
447 lines
16 KiB
C++
/*
|
|
* 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
|
|
*/
|
|
|
|
#ifndef I2PTUNNEL_H__
|
|
#define I2PTUNNEL_H__
|
|
|
|
#include <inttypes.h>
|
|
#include <string>
|
|
#include <set>
|
|
#include <tuple>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <boost/asio.hpp>
|
|
#include "Identity.h"
|
|
#include "Destination.h"
|
|
#include "Datagram.h"
|
|
#include "Streaming.h"
|
|
#include "I2PService.h"
|
|
#include "AddressBook.h"
|
|
|
|
namespace i2p {
|
|
namespace client {
|
|
const size_t I2P_TUNNEL_CONNECTION_BUFFER_SIZE = 65536;
|
|
const int I2P_TUNNEL_CONNECTION_MAX_IDLE = 3600; // in seconds
|
|
const int I2P_TUNNEL_DESTINATION_REQUEST_TIMEOUT = 10; // in seconds
|
|
// for HTTP tunnels
|
|
const char X_I2P_DEST_HASH[] = "X-I2P-DestHash"; // hash in base64
|
|
const char X_I2P_DEST_B64[] = "X-I2P-DestB64"; // full address in base64
|
|
const char X_I2P_DEST_B32[] = "X-I2P-DestB32"; // .b32.i2p address
|
|
const int I2P_TUNNEL_HTTP_MAX_HEADER_SIZE = 8192;
|
|
|
|
class I2PTunnelConnection : public I2PServiceHandler, public std::enable_shared_from_this<I2PTunnelConnection> {
|
|
public:
|
|
|
|
I2PTunnelConnection(I2PService *owner, std::shared_ptr <boost::asio::ip::tcp::socket> socket,
|
|
std::shared_ptr<const i2p::data::LeaseSet> leaseSet, int port = 0); // to I2P
|
|
I2PTunnelConnection(I2PService *owner, std::shared_ptr <boost::asio::ip::tcp::socket> socket,
|
|
std::shared_ptr <i2p::stream::Stream> stream); // to I2P using simplified API
|
|
I2PTunnelConnection(I2PService *owner, std::shared_ptr <i2p::stream::Stream> stream,
|
|
std::shared_ptr <boost::asio::ip::tcp::socket> socket,
|
|
const boost::asio::ip::tcp::endpoint &target, bool quiet = true); // from I2P
|
|
~I2PTunnelConnection();
|
|
|
|
void I2PConnect(const uint8_t *msg = nullptr, size_t len = 0);
|
|
|
|
void Connect(bool isUniqueLocal = true);
|
|
|
|
void Connect(const boost::asio::ip::address &localAddress);
|
|
|
|
protected:
|
|
|
|
void Terminate();
|
|
|
|
void Receive();
|
|
|
|
void HandleReceived(const boost::system::error_code &ecode, std::size_t bytes_transferred);
|
|
|
|
virtual void Write(const uint8_t *buf, size_t len); // can be overloaded
|
|
void HandleWrite(const boost::system::error_code &ecode);
|
|
|
|
virtual void WriteToStream(const uint8_t *buf, size_t len); // can be overloaded
|
|
|
|
void StreamReceive();
|
|
|
|
void HandleStreamReceive(const boost::system::error_code &ecode, std::size_t bytes_transferred);
|
|
|
|
void HandleConnect(const boost::system::error_code &ecode);
|
|
|
|
std::shared_ptr<const boost::asio::ip::tcp::socket> GetSocket() const { return m_Socket; };
|
|
|
|
private:
|
|
|
|
uint8_t m_Buffer[I2P_TUNNEL_CONNECTION_BUFFER_SIZE], m_StreamBuffer[I2P_TUNNEL_CONNECTION_BUFFER_SIZE];
|
|
std::shared_ptr <boost::asio::ip::tcp::socket> m_Socket;
|
|
std::shared_ptr <i2p::stream::Stream> m_Stream;
|
|
boost::asio::ip::tcp::endpoint m_RemoteEndpoint;
|
|
bool m_IsQuiet; // don't send destination
|
|
};
|
|
|
|
class I2PClientTunnelConnectionHTTP : public I2PTunnelConnection {
|
|
public:
|
|
|
|
I2PClientTunnelConnectionHTTP(I2PService *owner, std::shared_ptr <boost::asio::ip::tcp::socket> socket,
|
|
std::shared_ptr <i2p::stream::Stream> stream) :
|
|
I2PTunnelConnection(owner, socket, stream), m_HeaderSent(false),
|
|
m_ConnectionSent(false), m_ProxyConnectionSent(false) {};
|
|
|
|
protected:
|
|
|
|
void Write(const uint8_t *buf, size_t len);
|
|
|
|
private:
|
|
|
|
std::stringstream m_InHeader, m_OutHeader;
|
|
bool m_HeaderSent, m_ConnectionSent, m_ProxyConnectionSent;
|
|
};
|
|
|
|
class I2PServerTunnelConnectionHTTP : public I2PTunnelConnection {
|
|
public:
|
|
|
|
I2PServerTunnelConnectionHTTP(I2PService *owner, std::shared_ptr <i2p::stream::Stream> stream,
|
|
std::shared_ptr <boost::asio::ip::tcp::socket> socket,
|
|
const boost::asio::ip::tcp::endpoint &target, const std::string &host);
|
|
|
|
protected:
|
|
|
|
void Write(const uint8_t *buf, size_t len);
|
|
|
|
void WriteToStream(const uint8_t *buf, size_t len);
|
|
|
|
private:
|
|
|
|
std::string m_Host;
|
|
std::stringstream m_InHeader, m_OutHeader;
|
|
bool m_HeaderSent, m_ResponseHeaderSent;
|
|
std::shared_ptr<const i2p::data::IdentityEx> m_From;
|
|
};
|
|
|
|
class I2PTunnelConnectionIRC : public I2PTunnelConnection {
|
|
public:
|
|
|
|
I2PTunnelConnectionIRC(I2PService *owner, std::shared_ptr <i2p::stream::Stream> stream,
|
|
std::shared_ptr <boost::asio::ip::tcp::socket> socket,
|
|
const boost::asio::ip::tcp::endpoint &target, const std::string &m_WebircPass);
|
|
|
|
protected:
|
|
|
|
void Write(const uint8_t *buf, size_t len);
|
|
|
|
private:
|
|
|
|
std::shared_ptr<const i2p::data::IdentityEx> m_From;
|
|
std::stringstream m_OutPacket, m_InPacket;
|
|
bool m_NeedsWebIrc;
|
|
std::string m_WebircPass;
|
|
};
|
|
|
|
|
|
class I2PClientTunnel : public TCPIPAcceptor {
|
|
protected:
|
|
|
|
// Implements TCPIPAcceptor
|
|
std::shared_ptr <I2PServiceHandler> CreateHandler(std::shared_ptr <boost::asio::ip::tcp::socket> socket);
|
|
|
|
public:
|
|
|
|
I2PClientTunnel(const std::string &name, const std::string &destination,
|
|
const std::string &address, int port, std::shared_ptr <ClientDestination> localDestination,
|
|
int destinationPort = 0);
|
|
|
|
~I2PClientTunnel() {}
|
|
|
|
void Start();
|
|
|
|
void Stop();
|
|
|
|
const char *GetName() { return m_Name.c_str(); }
|
|
|
|
void SetKeepAliveInterval(uint32_t keepAliveInterval);
|
|
|
|
private:
|
|
|
|
std::shared_ptr<const Address> GetAddress();
|
|
|
|
void ScheduleKeepAliveTimer();
|
|
|
|
void HandleKeepAliveTimer(const boost::system::error_code &ecode);
|
|
|
|
private:
|
|
|
|
std::string m_Name, m_Destination;
|
|
std::shared_ptr<const Address> m_Address;
|
|
int m_DestinationPort;
|
|
uint32_t m_KeepAliveInterval;
|
|
std::unique_ptr <boost::asio::deadline_timer> m_KeepAliveTimer;
|
|
};
|
|
|
|
|
|
/** 2 minute timeout for udp sessions */
|
|
const uint64_t I2P_UDP_SESSION_TIMEOUT = 1000 * 60 * 2;
|
|
const uint64_t I2P_UDP_REPLIABLE_DATAGRAM_INTERVAL = 100; // in milliseconds
|
|
|
|
/** max size for i2p udp */
|
|
const size_t I2P_UDP_MAX_MTU = 64 * 1024;
|
|
|
|
struct UDPSession {
|
|
i2p::datagram::DatagramDestination *m_Destination;
|
|
boost::asio::ip::udp::socket IPSocket;
|
|
i2p::data::IdentHash Identity;
|
|
boost::asio::ip::udp::endpoint FromEndpoint;
|
|
boost::asio::ip::udp::endpoint SendEndpoint;
|
|
uint64_t LastActivity;
|
|
|
|
uint16_t LocalPort;
|
|
uint16_t RemotePort;
|
|
|
|
uint8_t m_Buffer[I2P_UDP_MAX_MTU];
|
|
|
|
UDPSession(boost::asio::ip::udp::endpoint localEndpoint,
|
|
const std::shared_ptr <i2p::client::ClientDestination> &localDestination,
|
|
boost::asio::ip::udp::endpoint remote, const i2p::data::IdentHash *ident,
|
|
uint16_t ourPort, uint16_t theirPort);
|
|
|
|
void HandleReceived(const boost::system::error_code &ecode, std::size_t len);
|
|
|
|
void Receive();
|
|
};
|
|
|
|
|
|
/** read only info about a datagram session */
|
|
struct DatagramSessionInfo {
|
|
/** the name of this forward */
|
|
std::string Name;
|
|
/** ident hash of local destination */
|
|
std::shared_ptr<const i2p::data::IdentHash> LocalIdent;
|
|
/** ident hash of remote destination */
|
|
std::shared_ptr<const i2p::data::IdentHash> RemoteIdent;
|
|
/** ident hash of IBGW in use currently in this session or nullptr if none is set */
|
|
std::shared_ptr<const i2p::data::IdentHash> CurrentIBGW;
|
|
/** ident hash of OBEP in use for this session or nullptr if none is set */
|
|
std::shared_ptr<const i2p::data::IdentHash> CurrentOBEP;
|
|
/** i2p router's udp endpoint */
|
|
boost::asio::ip::udp::endpoint LocalEndpoint;
|
|
/** client's udp endpoint */
|
|
boost::asio::ip::udp::endpoint RemoteEndpoint;
|
|
/** how long has this converstation been idle in ms */
|
|
uint64_t idle;
|
|
};
|
|
|
|
typedef std::shared_ptr <UDPSession> UDPSessionPtr;
|
|
|
|
/** server side udp tunnel, many i2p inbound to 1 ip outbound */
|
|
class I2PUDPServerTunnel {
|
|
public:
|
|
|
|
I2PUDPServerTunnel(const std::string &name,
|
|
std::shared_ptr <i2p::client::ClientDestination> localDestination,
|
|
boost::asio::ip::address localAddress,
|
|
boost::asio::ip::udp::endpoint forwardTo, uint16_t port, bool gzip);
|
|
|
|
~I2PUDPServerTunnel();
|
|
|
|
/** expire stale udp conversations */
|
|
void ExpireStale(const uint64_t delta = I2P_UDP_SESSION_TIMEOUT);
|
|
|
|
void Start();
|
|
|
|
void Stop();
|
|
|
|
const char *GetName() const { return m_Name.c_str(); }
|
|
|
|
std::vector <std::shared_ptr<DatagramSessionInfo>> GetSessions();
|
|
|
|
std::shared_ptr <ClientDestination> GetLocalDestination() const { return m_LocalDest; }
|
|
|
|
void SetUniqueLocal(bool isUniqueLocal = true) { m_IsUniqueLocal = isUniqueLocal; }
|
|
|
|
private:
|
|
|
|
void
|
|
HandleRecvFromI2P(const i2p::data::IdentityEx &from, uint16_t fromPort, uint16_t toPort, const uint8_t *buf,
|
|
size_t len);
|
|
|
|
void HandleRecvFromI2PRaw(uint16_t fromPort, uint16_t toPort, const uint8_t *buf, size_t len);
|
|
|
|
UDPSessionPtr ObtainUDPSession(const i2p::data::IdentityEx &from, uint16_t localPort, uint16_t remotePort);
|
|
|
|
private:
|
|
|
|
bool m_IsUniqueLocal;
|
|
const std::string m_Name;
|
|
boost::asio::ip::address m_LocalAddress;
|
|
boost::asio::ip::udp::endpoint m_RemoteEndpoint;
|
|
std::mutex m_SessionsMutex;
|
|
std::vector <UDPSessionPtr> m_Sessions;
|
|
std::shared_ptr <i2p::client::ClientDestination> m_LocalDest;
|
|
UDPSessionPtr m_LastSession;
|
|
bool m_Gzip;
|
|
|
|
public:
|
|
|
|
bool isUpdated; // transient, used during reload only
|
|
};
|
|
|
|
class I2PUDPClientTunnel {
|
|
public:
|
|
|
|
I2PUDPClientTunnel(const std::string &name, const std::string &remoteDest,
|
|
boost::asio::ip::udp::endpoint localEndpoint,
|
|
std::shared_ptr <i2p::client::ClientDestination> localDestination,
|
|
uint16_t remotePort, bool gzip);
|
|
|
|
~I2PUDPClientTunnel();
|
|
|
|
void Start();
|
|
|
|
void Stop();
|
|
|
|
const char *GetName() const { return m_Name.c_str(); }
|
|
|
|
std::vector <std::shared_ptr<DatagramSessionInfo>> GetSessions();
|
|
|
|
bool IsLocalDestination(const i2p::data::IdentHash &destination) const {
|
|
return destination == m_LocalDest->GetIdentHash();
|
|
}
|
|
|
|
std::shared_ptr <ClientDestination> GetLocalDestination() const { return m_LocalDest; }
|
|
|
|
inline void SetLocalDestination(std::shared_ptr <ClientDestination> dest) {
|
|
if (m_LocalDest) m_LocalDest->Release();
|
|
if (dest) dest->Acquire();
|
|
m_LocalDest = dest;
|
|
}
|
|
|
|
void ExpireStale(const uint64_t delta = I2P_UDP_SESSION_TIMEOUT);
|
|
|
|
private:
|
|
|
|
typedef std::pair <boost::asio::ip::udp::endpoint, uint64_t> UDPConvo;
|
|
|
|
void RecvFromLocal();
|
|
|
|
void HandleRecvFromLocal(const boost::system::error_code &e, std::size_t transferred);
|
|
|
|
void
|
|
HandleRecvFromI2P(const i2p::data::IdentityEx &from, uint16_t fromPort, uint16_t toPort, const uint8_t *buf,
|
|
size_t len);
|
|
|
|
void HandleRecvFromI2PRaw(uint16_t fromPort, uint16_t toPort, const uint8_t *buf, size_t len);
|
|
|
|
void TryResolving();
|
|
|
|
private:
|
|
|
|
const std::string m_Name;
|
|
std::mutex m_SessionsMutex;
|
|
std::unordered_map <uint16_t, std::shared_ptr<UDPConvo>> m_Sessions; // maps i2p port -> local udp convo
|
|
const std::string m_RemoteDest;
|
|
std::shared_ptr <i2p::client::ClientDestination> m_LocalDest;
|
|
const boost::asio::ip::udp::endpoint m_LocalEndpoint;
|
|
i2p::data::IdentHash *m_RemoteIdent;
|
|
std::thread *m_ResolveThread;
|
|
std::unique_ptr <boost::asio::ip::udp::socket> m_LocalSocket;
|
|
boost::asio::ip::udp::endpoint m_RecvEndpoint;
|
|
uint8_t m_RecvBuff[I2P_UDP_MAX_MTU];
|
|
uint16_t RemotePort, m_LastPort;
|
|
bool m_cancel_resolve;
|
|
bool m_Gzip;
|
|
std::shared_ptr <UDPConvo> m_LastSession;
|
|
|
|
public:
|
|
|
|
bool isUpdated; // transient, used during reload only
|
|
};
|
|
|
|
class I2PServerTunnel : public I2PService {
|
|
public:
|
|
|
|
I2PServerTunnel(const std::string &name, const std::string &address, int port,
|
|
std::shared_ptr <ClientDestination> localDestination, int inport = 0, bool gzip = true);
|
|
|
|
void Start();
|
|
|
|
void Stop();
|
|
|
|
void SetAccessList(const std::set <i2p::data::IdentHash> &accessList);
|
|
|
|
void SetUniqueLocal(bool isUniqueLocal) { m_IsUniqueLocal = isUniqueLocal; }
|
|
|
|
bool IsUniqueLocal() const { return m_IsUniqueLocal; }
|
|
|
|
void SetLocalAddress(const std::string &localAddress);
|
|
|
|
const std::string &GetAddress() const { return m_Address; }
|
|
|
|
int GetPort() const { return m_Port; };
|
|
|
|
uint16_t GetLocalPort() const { return m_PortDestination->GetLocalPort(); };
|
|
|
|
const boost::asio::ip::tcp::endpoint &GetEndpoint() const { return m_Endpoint; }
|
|
|
|
const char *GetName() { return m_Name.c_str(); }
|
|
|
|
private:
|
|
|
|
void HandleResolve(const boost::system::error_code &ecode, boost::asio::ip::tcp::resolver::iterator it,
|
|
std::shared_ptr <boost::asio::ip::tcp::resolver> resolver);
|
|
|
|
void Accept();
|
|
|
|
void HandleAccept(std::shared_ptr <i2p::stream::Stream> stream);
|
|
|
|
virtual std::shared_ptr <I2PTunnelConnection>
|
|
CreateI2PConnection(std::shared_ptr <i2p::stream::Stream> stream);
|
|
|
|
private:
|
|
|
|
bool m_IsUniqueLocal;
|
|
std::string m_Name, m_Address;
|
|
int m_Port;
|
|
boost::asio::ip::tcp::endpoint m_Endpoint;
|
|
std::shared_ptr <i2p::stream::StreamingDestination> m_PortDestination;
|
|
std::set <i2p::data::IdentHash> m_AccessList;
|
|
bool m_IsAccessList;
|
|
std::unique_ptr <boost::asio::ip::address> m_LocalAddress;
|
|
};
|
|
|
|
class I2PServerTunnelHTTP : public I2PServerTunnel {
|
|
public:
|
|
|
|
I2PServerTunnelHTTP(const std::string &name, const std::string &address, int port,
|
|
std::shared_ptr <ClientDestination> localDestination, const std::string &host,
|
|
int inport = 0, bool gzip = true);
|
|
|
|
private:
|
|
|
|
std::shared_ptr <I2PTunnelConnection> CreateI2PConnection(std::shared_ptr <i2p::stream::Stream> stream);
|
|
|
|
private:
|
|
|
|
std::string m_Host;
|
|
};
|
|
|
|
class I2PServerTunnelIRC : public I2PServerTunnel {
|
|
public:
|
|
|
|
I2PServerTunnelIRC(const std::string &name, const std::string &address, int port,
|
|
std::shared_ptr <ClientDestination> localDestination, const std::string &webircpass,
|
|
int inport = 0, bool gzip = true);
|
|
|
|
private:
|
|
|
|
std::shared_ptr <I2PTunnelConnection> CreateI2PConnection(std::shared_ptr <i2p::stream::Stream> stream);
|
|
|
|
private:
|
|
|
|
std::string m_WebircPass;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endif
|