Struct rustls::server::Acceptor

pub struct Acceptor { /* private fields */ }

Available on crate feature std only.

Handle a server-side connection before configuration is available.

Acceptor allows the caller to choose a ServerConfig after reading the super::ClientHello of an incoming connection. This is useful for servers that choose different certificates or cipher suites based on the characteristics of the ClientHello. In particular it is useful for servers that need to do some I/O to load a certificate and its private key and don’t want to use the blocking interface provided by super::ResolvesServerCert.

Create an Acceptor with Acceptor::default().

Example

use rustls::server::{Acceptor, ServerConfig};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
for stream in listener.incoming() {
    let mut stream = stream.unwrap();
    let mut acceptor = Acceptor::default();
    let accepted = loop {
        acceptor.read_tls(&mut stream).unwrap();
        if let Some(accepted) = acceptor.accept().unwrap() {
            break accepted;
        }
    };

    // For some user-defined choose_server_config:
    let config = choose_server_config(accepted.client_hello());
    let conn = accepted
        .into_connection(config)
        .unwrap();
    // Proceed with handling the ServerConnection.
}

Implementations

impl Acceptor

pub fn read_tls(&mut self, rd: &mut dyn Read) -> Result<usize, Error>

Read TLS content from rd.

Returns an error if this Acceptor has already yielded an Accepted. For more details, refer to Connection::read_tls().

pub fn accept(&mut self) -> Result<Option<Accepted>, (Error, AcceptedAlert)>

Check if a ClientHello message has been received.

Returns Ok(None) if the complete ClientHello has not yet been received. Do more I/O and then call this function again.

Returns Ok(Some(accepted)) if the connection has been accepted. Call accepted.into_connection() to continue. Do not call this function again.

Returns Err((err, alert)) if an error occurred. If an alert is returned, the application should call alert.write() to send the alert to the client. It should not call accept() again.

Trait Implementations

impl Default for Acceptor

fn default() -> Self

Return an empty Acceptor, ready to receive bytes from a new client connection.

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: 1096 bytes