Struct libp2p_rs::plaintext::PlainTextOutput

pub struct PlainTextOutput<T> where
    T: SplitEx,  {
    pub stream: SecureStream<<T as SplitEx>::Reader, <T as SplitEx>::Writer>,
    pub local_priv_key: Keypair,
    pub local_peer_id: PeerId,
    pub remote_pub_key: PublicKey,
    pub remote_peer_id: PeerId,
    // some fields omitted
}

Output of the plaintext protocol. It implements the SecureStream trait

Fields

stream: SecureStream<<T as SplitEx>::Reader, <T as SplitEx>::Writer>

The encrypted stream, actually not any encrypt action.

local_priv_key: Keypair

The private key of the local

local_peer_id: PeerId

For convenience, the local peer ID, generated from local pub key

remote_pub_key: PublicKey

The public key of the remote.

remote_peer_id: PeerId

For convenience, put a PeerId here, which is actually calculated from remote_key

Trait Implementations

impl<T> ConnectionInfo for PlainTextOutput<T> where
    T: SplitEx, 

pub fn local_multiaddr(&self) -> Multiaddr

pub fn remote_multiaddr(&self) -> Multiaddr

impl<S> ReadEx for PlainTextOutput<S> where
    S: SplittableReadWrite, 

pub fn read2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    PlainTextOutput<S>: 'async_trait, 

Reads some bytes from the byte stream.

#[must_use]pub fn read_exact2<'a, 'async_trait>(
    &'a mut self,
    buf: &'a mut [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'a: 'async_trait,
    Self: 'async_trait, 

Reads the exact number of bytes requested.

#[must_use]pub fn read_fixed_u32<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a fixed-length integer from the underlying IO.

#[must_use]pub fn read_varint<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a variable-length integer from the underlying IO.

#[must_use]pub fn read_one_fixed<'life0, 'async_trait>(
    &'life0 mut self,
    max_size: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<u8, Global>, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a fixed length-prefixed message from the underlying IO.

#[must_use]pub fn read_one<'life0, 'async_trait>(
    &'life0 mut self,
    max_size: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<u8, Global>, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a variable length-prefixed message from the underlying IO.

impl<T> SecureInfo for PlainTextOutput<T> where
    T: SplitEx, 

pub fn local_peer(&self) -> PeerId

pub fn remote_peer(&self) -> PeerId

pub fn local_priv_key(&self) -> Keypair

pub fn remote_pub_key(&self) -> PublicKey

impl<S> SplitEx for PlainTextOutput<S> where
    S: SplittableReadWrite, 

type Reader = SecureStreamReader<<S as SplitEx>::Reader>

read half

type Writer = SecureStreamWriter<<S as SplitEx>::Writer>

write half

pub fn split(
    self
) -> (<PlainTextOutput<S> as SplitEx>::Reader, <PlainTextOutput<S> as SplitEx>::Writer)

split Self to independent reader and writer

impl<S> WriteEx for PlainTextOutput<S> where
    S: SplittableReadWrite, 

pub fn write2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    PlainTextOutput<S>: 'async_trait, 

Attempt to write bytes from buf into the object.

pub fn flush2<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    PlainTextOutput<S>: 'async_trait, 

Attempt to flush the object, ensuring that any buffered data reach their destination.

pub fn close2<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    PlainTextOutput<S>: 'async_trait, 

Attempt to close the object.

#[must_use]pub fn write_all2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Attempt to write the entire contents of data into object.

#[must_use]pub fn write_varint<'life0, 'async_trait>(
    &'life0 mut self,
    len: usize
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Writes a variable-length integer to the underlying IO.

#[must_use]pub fn write_fixed_u32<'life0, 'async_trait>(
    &'life0 mut self,
    len: usize
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Writes a fixed-length integer to the underlying IO.

#[must_use]pub fn write_one_fixed<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Send a fixed length message to the underlying IO, then flushes the writing side.

#[must_use]pub fn write_one<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Send a variable length message to the underlying IO, then flushes the writing side.