pub struct Acceptor { /* private fields */ }
Expand description
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§
source§impl Acceptor
impl Acceptor
sourcepub fn read_tls(&mut self, rd: &mut dyn Read) -> Result<usize, Error>
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()
.
sourcepub fn accept(&mut self) -> Result<Option<Accepted>, (Error, AcceptedAlert)>
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.