Struct TlsAcceptor 

pub struct TlsAcceptor(/* private fields */);

A wrapper around a native_tls::TlsAcceptor, providing an async accept method.

Example

use async_std::prelude::*;
use async_std::net::TcpListener;
use async_std::fs::File;
use async_native_tls::TlsAcceptor;

let key = File::open("tests/identity.pfx").await?;
let acceptor = TlsAcceptor::new(key, "hello").await?;
let listener = TcpListener::bind("127.0.0.1:8443").await?;
let mut incoming = listener.incoming();

while let Some(stream) = incoming.next().await {
    let acceptor = acceptor.clone();
    let stream = stream?;
    async_std::task::spawn(async move {
        let stream = acceptor.accept(stream).await.unwrap();
        // handle stream here
    });
}

Implementations

impl TlsAcceptor

pub async fn new<R, S>(file: R, password: S) -> Result<Self, Error>

where R: AsyncRead + Unpin, S: AsRef<str>,

Create a new TlsAcceptor based on an identity file and matching password.

pub async fn accept<S>(&self, stream: S) -> Result<TlsStream<S>, Error>

where S: AsyncRead + AsyncWrite + Unpin,

Accepts a new client connection with the provided stream.

This function will internally call TlsAcceptor::accept to connect the stream and returns a future representing the resolution of the connection operation. The returned future will resolve to either TlsStream<S> or Error depending if it’s successful or not.

This is typically used after a new socket has been accepted from a TcpListener. That socket is then passed to this function to perform the server half of accepting a client connection.

Trait Implementations

impl Clone for TlsAcceptor

fn clone(&self) -> TlsAcceptor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TlsAcceptor

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

Formats the value using the given formatter.

impl From<TlsAcceptor> for TlsAcceptor

fn from(inner: TlsAcceptor) -> TlsAcceptor

Converts to this type from the input type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes