Struct Handle 

pub struct Handle<I, O> { /* private fields */ }

bidirectional handle of an encrypted connection

The Handle is composed of 2 halves that can be split for more convenient management of the ins and outs of the connections.

see Handle::split for more information

Implementations

impl<I, O> Handle<I, O>

where I: AsyncRead + Unpin, O: AsyncWrite + Unpin,

pub fn split(self) -> (HandleReadHalf<I>, HandleWriteHalf<O>)

split the handle into 2 parts into 2 separate half

One will contains the writing half and the other one the reading half. This is because the connection is bidirectional/duplex so it is more convenient to handle the protocol if the 2 halves are split. However, if you are only using the synchronous you can keep the Handle as it is.

pub fn accept<K, RNG>(rng: RNG, reader: I, writer: O) -> Accepting<I, O, RNG, K>

where K: Dh, RNG: RngCore + CryptoRng,

prepare accepting the new request from the given stream

pub async fn open<K, RNG>( rng: RNG, k: &K, rs: PublicKey, reader: I, writer: O, ) -> Result<Self>

where K: Dh, RNG: RngCore + CryptoRng,

open a new stream with the remote peer connected to the stream and expecting the remote’s public identity rs.

In order to open the connection, the remote peer will need to verify our identity, so we needs the private key associated to our identity (K).

We will generate an ephemeral key, the rng will do that at the appropriate time.

pub fn remote_public_identity(&self) -> &PublicKey

retrieve the public identity of the peer

pub fn session_id(&self) -> &SessionId

retrieve the unique identifier of the established session

this is derived from the NOISE handshake and is the same on both sides of the stream (here and for the remote).

Trait Implementations

impl<I, O> FusedStream for Handle<I, O>

where I: AsyncRead + Unpin, O: Unpin,

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

impl<I, O> Sink<Bytes> for Handle<I, O>

where I: Unpin, O: AsyncWrite + Unpin,

type Error = Error

The type of value produced by the sink when an error occurs.

fn start_send(self: Pin<&mut Self>, item: Bytes) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

impl<I, O> Stream for Handle<I, O>

where I: AsyncRead + Unpin, O: Unpin,

type Item = Result<BytesMut, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.