dev::p2p::Session Struct Reference

The Session class. More...

#include <Session.h>

Collaboration diagram for dev::p2p::Session:

Classes
struct	SendRequest
struct	UnknownP2PPacketType

Public Member Functions
	~Session ()
void	disconnect (DisconnectReason _reason)
void	send (std::string capability_name, unsigned packet_type, bytes payload, std::function< void()> &&on_done={})
void	ping ()
bool	isConnected () const
NodeID	id () const
PeerSessionInfo	info () const

Static Public Member Functions
static std::shared_ptr< Session >	make (SessionCapabilities caps, std::unique_ptr< RLPXFrameCoder > _io, std::shared_ptr< RLPXSocket > _s, std::shared_ptr< Peer > _n, PeerSessionInfo _info, std::optional< DisconnectReason > immediate_disconnect_reason={})

Private Member Functions
	Session (SessionCapabilities caps, std::unique_ptr< RLPXFrameCoder > _io, std::shared_ptr< RLPXSocket > _s, std::shared_ptr< Peer > _n, PeerSessionInfo _info, std::optional< DisconnectReason > immediate_disconnect_reason={})
void	disconnect_ (DisconnectReason _reason)
void	ping_ ()
void	sealAndSend_ (RLPStream &_s)
std::shared_ptr< Peer >	peer () const
void	send_ (bytes _msg, std::function< void()> on_done={})
void	drop (DisconnectReason _r)
	Drop the connection for the reason _r. More...
void	doRead ()
	Perform a read on the socket. More...
bool	checkRead (std::size_t expected, boost::system::error_code ec, std::size_t length)
	Check error code after reading and drop peer if error code. More...
void	write (uint16_t sequence_id=0, uint32_t sent_size=0)
void	splitAndPack (uint16_t &sequence_id, uint32_t &sent_size)
void	readPacket (unsigned _t, RLP const &_r)
	Deliver RLPX packet to Session or PeerCapability for interpretation. More...
void	interpretP2pPacket (P2pPacketType _t, RLP const &_r)
	Interpret an incoming Session packet. More...
std::optional< SessionCapability >	capabilityFor (unsigned _packetType) const
std::string	capabilityPacketTypeToString (unsigned _packetType) const

Static Private Member Functions
static RLPStream &	prep (RLPStream &_s, P2pPacketType _t, unsigned _args=0)
static bool	checkPacket (bytesConstRef _msg)
static std::string	capabilityPacketTypeToString (std::optional< SessionCapability > const &cap, unsigned _packetType)

Private Attributes
std::atomic< bool >	muted_ = false
SessionCapabilities	m_capabilities
	The peer's capability set. More...
std::unique_ptr< RLPXFrameCoder >	m_io
	Transport over which packets are sent. More...
std::shared_ptr< RLPXSocket >	m_socket
	Socket of peer's connection. More...
std::deque< SendRequest >	m_writeQueue
	The write queue. More...
std::vector< byte >	m_data
	Buffer for ingress packet data. More...
std::vector< byte >	m_multiData
	Buffer for multipacket data. More...
bytes	m_out
std::shared_ptr< Peer >	m_peer
	The Peer object. More...
bool	m_dropped = false
std::shared_mutex	x_info
PeerSessionInfo	m_info
	Dynamic information about this peer. More...
std::chrono::steady_clock::time_point	m_ping
	Time point of last ping. More...
std::optional< DisconnectReason >	immediate_disconnect_reason_
std::string	m_logSuffix
Logger	m_netLogger {createLogger(VerbosityDebug, "net")}
Logger	m_netLoggerDetail {createLogger(VerbosityTrace, "net")}
Logger	m_netLoggerError {createLogger(VerbosityError, "net")}
Logger	m_capLogger {createLogger(VerbosityDebug, "p2pcap")}
Logger	m_capLoggerDetail {createLogger(VerbosityTrace, "p2pcap")}

Detailed Description

The Session class.

Todo:

Document fully.

---

Class Documentation

dev::p2p::Session::SendRequest

struct dev::p2p::Session::SendRequest

Class Members
function< void()>	on_done
bytes	payload

Constructor & Destructor Documentation

Session()

Session::Session ( SessionCapabilities  caps, std::unique_ptr< RLPXFrameCoder >  _io, std::shared_ptr< RLPXSocket >  _s, std::shared_ptr< Peer >  _n, PeerSessionInfo  _info, std::optional< DisconnectReason >  immediate_disconnect_reason = {}  )

private

~Session()

Session::~Session

(

)

Member Function Documentation

capabilityFor()

std::optional< SessionCapability > Session::capabilityFor ( unsigned  _packetType ) const

private

capabilityPacketTypeToString() [1/2]

std::string Session::capabilityPacketTypeToString ( std::optional< SessionCapability > const &  cap, unsigned  _packetType  )

staticprivate

capabilityPacketTypeToString() [2/2]

std::string Session::capabilityPacketTypeToString ( unsigned  _packetType ) const

private

checkPacket()

bool Session::checkPacket ( bytesConstRef  _msg )

staticprivate

Returns

true iff the _msg forms a valid message for sending or receiving on the network.

checkRead()

bool Session::checkRead ( std::size_t  expected, boost::system::error_code  ec, std::size_t  length  )

private

Check error code after reading and drop peer if error code.

disconnect()

void dev::p2p::Session::disconnect ( DisconnectReason  _reason )

inline

disconnect_()

void Session::disconnect_ ( DisconnectReason  _reason )

private

doRead()

void Session::doRead ( )

private

Perform a read on the socket.

read padded frame and mac

drop()

void Session::drop ( DisconnectReason  _r )

private

Drop the connection for the reason _r.

id()

NodeID dev::p2p::Session::id ( ) const

inline

info()

PeerSessionInfo dev::p2p::Session::info ( ) const

inline

interpretP2pPacket()

void Session::interpretP2pPacket ( P2pPacketType  _t, RLP const &  _r  )

private

Interpret an incoming Session packet.

isConnected()

bool dev::p2p::Session::isConnected ( ) const

inline

make()

std::shared_ptr< Session > Session::make ( SessionCapabilities  caps, std::unique_ptr< RLPXFrameCoder >  _io, std::shared_ptr< RLPXSocket >  _s, std::shared_ptr< Peer >  _n, PeerSessionInfo  _info, std::optional< DisconnectReason >  immediate_disconnect_reason = {}  )

static

peer()

std::shared_ptr<Peer> dev::p2p::Session::peer ( ) const

inlineprivate

ping()

void dev::p2p::Session::ping ( )

inline

ping_()

void Session::ping_ ( )

private

prep()

dev::RLPStream & Session::prep ( RLPStream &  _s, P2pPacketType  _t, unsigned  _args = 0  )

staticprivate

readPacket()

void Session::readPacket ( unsigned  _t, RLP const &  _r  )

private

Deliver RLPX packet to Session or PeerCapability for interpretation.

sealAndSend_()

void Session::sealAndSend_ ( RLPStream &  _s )

private

send()

void dev::p2p::Session::send ( std::string  capability_name, unsigned  packet_type, bytes  payload, std::function< void()> &&  on_done = {}  )

inline

send_()

void Session::send_ ( bytes  _msg, std::function< void()>  on_done = {}  )

private

splitAndPack()

void Session::splitAndPack ( uint16_t &  sequence_id, uint32_t &  sent_size  )

private

write()

void Session::write ( uint16_t  sequence_id = 0, uint32_t  sent_size = 0  )

private

Perform a single round of the write operation. This could end up calling itself asynchronously.

Member Data Documentation

immediate_disconnect_reason_

std::optional<DisconnectReason> dev::p2p::Session::immediate_disconnect_reason_

private

m_capabilities

SessionCapabilities dev::p2p::Session::m_capabilities

private

The peer's capability set.

m_capLogger

Logger dev::p2p::Session::m_capLogger {createLogger(VerbosityDebug, "p2pcap")}

private

m_capLoggerDetail

Logger dev::p2p::Session::m_capLoggerDetail {createLogger(VerbosityTrace, "p2pcap")}

private

m_data

std::vector<byte> dev::p2p::Session::m_data

private

Buffer for ingress packet data.

m_dropped

bool dev::p2p::Session::m_dropped = false

private

If true, we've already divested ourselves of this peer. We're just waiting for the reads & writes to fail before the shared_ptr goes OOS and the destructor kicks in.

m_info

PeerSessionInfo dev::p2p::Session::m_info

private

Dynamic information about this peer.

m_io

std::unique_ptr<RLPXFrameCoder> dev::p2p::Session::m_io

private

Transport over which packets are sent.

m_logSuffix

std::string dev::p2p::Session::m_logSuffix

private

m_multiData

std::vector<byte> dev::p2p::Session::m_multiData

private

Buffer for multipacket data.

m_netLogger

Logger dev::p2p::Session::m_netLogger {createLogger(VerbosityDebug, "net")}

private

m_netLoggerDetail

Logger dev::p2p::Session::m_netLoggerDetail {createLogger(VerbosityTrace, "net")}

private

m_netLoggerError

Logger dev::p2p::Session::m_netLoggerError {createLogger(VerbosityError, "net")}

private

m_out

bytes dev::p2p::Session::m_out

private

m_peer

std::shared_ptr<Peer> dev::p2p::Session::m_peer

private

The Peer object.

m_ping

std::chrono::steady_clock::time_point dev::p2p::Session::m_ping

private

Time point of last ping.

m_socket

std::shared_ptr<RLPXSocket> dev::p2p::Session::m_socket

private

Socket of peer's connection.

m_writeQueue

std::deque<SendRequest> dev::p2p::Session::m_writeQueue

private

The write queue.

muted_

std::atomic<bool> dev::p2p::Session::muted_ = false

private

x_info

std::shared_mutex dev::p2p::Session::x_info

mutableprivate

---

The documentation for this struct was generated from the following files:

• libraries/aleth/libp2p/Session.h
• libraries/aleth/libp2p/Session.cpp