Struct RelayResponderHandshake 

pub struct RelayResponderHandshake<T: AsyncRead + AsyncWrite + CertifiedConn + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider> {
    sleep_prov: S,
    memquota: ChannelAccount,
    framed_tls: Framed<T, ChannelCellHandler>,
    peer_addr: Sensitive<PeerAddr>,
    my_addrs: Vec<IpAddr>,
    unique_id: UniqId,
    auth_material: Arc<RelayChannelAuthMaterial>,
    create_request_handler: Arc<CreateRequestHandler>,
}

A relay channel handshake as the responder.

Fields

sleep_prov: S

Runtime handle (insofar as we need it)

memquota: ChannelAccount

Memory quota account

framed_tls: Framed<T, ChannelCellHandler>

Underlying TLS stream in a channel frame.

(We don’t enforce that this is actually TLS, but if it isn’t, the connection won’t be secure.)

peer_addr: Sensitive<PeerAddr>

The peer IP address as in the address the initiator is connecting from. This can be a client so keep it sensitive.

my_addrs: Vec<IpAddr>

Our advertised addresses. Needed for the NETINFO.

unique_id: UniqId

Logging identifier for this stream. (Used for logging only.)

auth_material: Arc<RelayChannelAuthMaterial>

Our identity keys needed for authentication.

create_request_handler: Arc<CreateRequestHandler>

Provided to each new channel so that they can handle CREATE* requests.

Implementations

impl<T: AsyncRead + AsyncWrite + CertifiedConn + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider> RelayResponderHandshake<T, S>

pub(crate) fn new( peer_addr: Sensitive<PeerAddr>, my_addrs: Vec<SocketAddr>, tls: T, sleep_prov: S, auth_material: Arc<RelayChannelAuthMaterial>, memquota: ChannelAccount, create_request_handler: Arc<CreateRequestHandler>, ) -> Self

Constructor.

pub async fn handshake<F>( self, now_fn: F, ) -> Result<MaybeVerifiableRelayResponderChannel<T, S>>

where F: FnOnce() -> SystemTime,

Begin the handshake process.

Takes a function that reports the current time. In theory, this can just be SystemTime::get().

async fn recv_cells_from_initiator( &mut self, ) -> Result<(Option<(Certs, Authenticate, ClogDigest)>, (Netinfo, Instant))>

Receive all the cells expected from the initiator of the connection. Keep in mind that it can be either a relay or client or bridge.

async fn send_cells_to_initiator(&mut self) -> Result<SlogDigest>

Send all expected cells to the initiator of the channel as the responder.

Return the SLOG (send log) digest to be later used when verifying the initiator’s AUTHENTICATE cell.

Trait Implementations

impl<T, S> ChannelBaseHandshake<T> for RelayResponderHandshake<T, S>

where T: AsyncRead + AsyncWrite + CertifiedConn + StreamOps + Send + Unpin + 'static, S: CoarseTimeProvider + SleepProvider,

Implement the base channel handshake trait.

fn framed_tls(&mut self) -> &mut Framed<T, ChannelCellHandler>

Return a mutable reference to the channel frame.

fn unique_id(&self) -> &UniqId

Return a reference to the unique ID of this handshake.

async fn send_versions_cell<F>( &mut self, now_fn: F, ) -> Result<(Instant, SystemTime)>

where F: FnOnce() -> SystemTime,

Send a msg::Versions cell.

async fn recv_versions_cell(&mut self) -> Result<u16>

Receive a msg::Versions cell.

fn set_link_protocol(&mut self, link_protocol: u16) -> Result<()>

Given a link protocol version, set it into our channel cell handler. All channel type do this after negotiating a msg::Versions cell.