Struct PeerConnection 

pub struct PeerConnection { /* private fields */ }

A connection in the handshake phase, before authentication completes.

For outbound connections, we know the expected peer identity from config. For inbound connections, we learn the identity during the Noise handshake.

Implementations

impl PeerConnection

pub fn outbound( link_id: LinkId, expected_identity: PeerIdentity, current_time_ms: u64, ) -> Self

Create a new outbound connection (we are initiating).

For outbound, we know who we’re trying to reach from configuration. The Noise handshake will be initialized when start_handshake is called.

pub fn inbound(link_id: LinkId, current_time_ms: u64) -> Self

Create a new inbound connection (they are initiating).

For inbound, we don’t know who they are until we decrypt their identity from Noise message 1.

pub fn inbound_with_transport( link_id: LinkId, transport_id: TransportId, source_addr: TransportAddr, current_time_ms: u64, ) -> Self

Create a new inbound connection with transport information.

Used when processing msg1 where we know the transport and source address.

pub fn link_id(&self) -> LinkId

Get the link ID.

pub fn direction(&self) -> LinkDirection

Get the connection direction.

pub fn handshake_state(&self) -> HandshakeState

Get the handshake state.

pub fn expected_identity(&self) -> Option<&PeerIdentity>

Get the expected/learned peer identity, if known.

pub fn is_outbound(&self) -> bool

Check if this is an outbound connection.

pub fn is_inbound(&self) -> bool

Check if this is an inbound connection.

pub fn is_in_progress(&self) -> bool

Check if handshake is in progress.

pub fn is_complete(&self) -> bool

Check if handshake completed.

pub fn is_failed(&self) -> bool

Check if handshake failed.

pub fn started_at(&self) -> u64

When the connection started.

pub fn last_activity(&self) -> u64

When the last activity occurred.

pub fn duration(&self, current_time_ms: u64) -> u64

Connection duration so far.

pub fn idle_time(&self, current_time_ms: u64) -> u64

Time since last activity.

pub fn link_stats(&self) -> &LinkStats

Get link statistics.

pub fn link_stats_mut(&mut self) -> &mut LinkStats

Get mutable link statistics.

pub fn our_index(&self) -> Option<SessionIndex>

Get our session index (if set).

pub fn set_our_index(&mut self, index: SessionIndex)

Set our session index.

pub fn their_index(&self) -> Option<SessionIndex>

Get their session index (if known).

pub fn set_their_index(&mut self, index: SessionIndex)

Set their session index.

pub fn transport_id(&self) -> Option<TransportId>

Get the transport ID (if set).

pub fn set_transport_id(&mut self, id: TransportId)

Set the transport ID.

pub fn source_addr(&self) -> Option<&TransportAddr>

Get the source address (if known).

pub fn set_source_addr(&mut self, addr: TransportAddr)

Set the source address.

pub fn remote_epoch(&self) -> Option<[u8; 8]>

Get the remote peer’s startup epoch (available after handshake).

pub fn set_handshake_msg1(&mut self, msg1: Vec<u8>, first_resend_at_ms: u64)

Store the wire-format msg1 bytes for resend and schedule the first resend.

pub fn set_handshake_msg2(&mut self, msg2: Vec<u8>)

Store the wire-format msg2 bytes for resend on duplicate msg1.

pub fn handshake_msg1(&self) -> Option<&[u8]>

Get the stored msg1 bytes (if any).

pub fn handshake_msg2(&self) -> Option<&[u8]>

Get the stored msg2 bytes (if any).

pub fn resend_count(&self) -> u32

Number of resends performed.

pub fn next_resend_at_ms(&self) -> u64

When the next resend is scheduled (Unix ms).

pub fn record_resend(&mut self, next_resend_at_ms: u64)

Record a resend and schedule the next one.

pub fn start_handshake( &mut self, our_keypair: Keypair, epoch: [u8; 8], current_time_ms: u64, ) -> Result<Vec<u8>, NoiseError>

Start the handshake as initiator and generate message 1.

For outbound connections only. Returns the handshake message to send. The epoch is our startup epoch, encrypted into msg1 for restart detection.

pub fn receive_handshake_init( &mut self, our_keypair: Keypair, epoch: [u8; 8], message: &[u8], current_time_ms: u64, ) -> Result<Vec<u8>, NoiseError>

Initialize responder and process incoming message 1.

For inbound connections only. Returns the handshake message 2 to send. The epoch is our startup epoch, encrypted into msg2 for restart detection.

pub fn complete_handshake( &mut self, message: &[u8], current_time_ms: u64, ) -> Result<(), NoiseError>

Complete the handshake by processing message 2.

For outbound connections only (initiator completing handshake).

pub fn take_session(&mut self) -> Option<NoiseSession>

Take the completed Noise session.

Returns the NoiseSession for use in ActivePeer. Can only be called once after handshake completes.

pub fn has_session(&self) -> bool

Check if we have a completed session ready to take.

pub fn mark_failed(&mut self)

Mark handshake as failed.

pub fn touch(&mut self, current_time_ms: u64)

Update last activity timestamp.

pub fn is_timed_out(&self, current_time_ms: u64, timeout_ms: u64) -> bool

Check if the connection has timed out.

Trait Implementations

impl Debug for PeerConnection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.