Enum MaybeTls 

pub enum MaybeTls<R, T> {
    Raw(R),
    Tls(T),
}

A type wrapper for objects that can exist in either a raw state or wrapped by TLS handling.

Variants

Raw(R)

Tls(T)

Implementations

impl MaybeTls<(), TlsSettings>

pub async fn bind( &self, addr: &SocketAddr, ) -> Result<MaybeTlsListener, TlsError>

pub async fn bind_with_allowlist( &self, addr: &SocketAddr, allow_origin: Vec<IpNet>, ) -> Result<MaybeTlsListener, TlsError>

pub async fn bind_reloadable( &self, addr: &SocketAddr, reloader: Option<TlsAcceptorReloader>, ) -> Result<MaybeTlsListener, TlsError>

Bind a listener, optionally sharing a TlsAcceptorReloader so its acceptor can be swapped at runtime. When reloader is Some and TLS is enabled, connections accepted by the returned listener use the acceptor the reloader currently holds; otherwise the acceptor is fixed for the lifetime of the listener.

impl<R, T> MaybeTls<R, T>

pub const fn is_raw(&self) -> bool

pub const fn is_tls(&self) -> bool

pub const fn raw(&self) -> Option<&R>

pub const fn tls(&self) -> Option<&T>

impl MaybeTls<(), TlsSettings>

pub async fn connect( &self, host: &str, addr: &SocketAddr, ) -> Result<MaybeTls<TcpStream, SslStream<TcpStream>>, TlsError>

impl MaybeTls<(), TlsSettings>

pub fn reloadable_acceptor( &self, ) -> Result<Option<TlsAcceptorReloader>, TlsError>

Build a reloadable acceptor handle for server use, or None when TLS is disabled.

Pass the returned handle to bind_reloadable so the bound listener serves it, and keep a clone to call reload when the certificate material rotates.

impl MaybeTls<(), TlsSettings>

pub fn enable_client() -> Result<MaybeTls<(), TlsSettings>, TlsError>

pub fn tls_client( config: Option<&TlsConfig>, ) -> Result<MaybeTls<(), TlsSettings>, TlsError>

pub fn from_config( config: Option<&TlsEnableableConfig>, for_server: bool, ) -> Result<MaybeTls<(), TlsSettings>, TlsError>

Generate an optional settings struct from the given optional configuration reference. If config is None, TLS is disabled. The for_server parameter indicates the options should be interpreted as being for a TLS server, which requires an identity certificate and changes the certificate verification default to false.

pub const fn http_protocol_name(&self) -> &'static str

impl MaybeTls<TcpStream, SslStream<TcpStream>>

pub fn peer_addr(&self) -> Result<SocketAddr, Error>

pub fn set_keepalive( &mut self, keepalive: TcpKeepaliveConfig, ) -> Result<(), Error>

pub fn set_send_buffer_bytes(&mut self, bytes: usize) -> Result<(), Error>

pub fn set_receive_buffer_bytes(&mut self, bytes: usize) -> Result<(), Error>

Trait Implementations

impl<R, T> AsyncRead for MaybeTls<R, T>

where R: AsyncRead, T: AsyncRead,

fn poll_read( self: Pin<&mut MaybeTls<R, T>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf.

impl<R, T> AsyncWrite for MaybeTls<R, T>

where R: AsyncWrite, T: AsyncWrite,

fn poll_write( self: Pin<&mut MaybeTls<R, T>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

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

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

fn poll_shutdown( self: Pin<&mut MaybeTls<R, T>>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<R, T> Clone for MaybeTls<R, T>

where R: Clone, T: Clone,

fn clone(&self) -> MaybeTls<R, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R, T> Debug for MaybeTls<R, T>

where R: Debug, T: Debug,

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

Formats the value using the given formatter.

impl<O> From<Option<O>> for MaybeTls<(), O>

fn from(tls: Option<O>) -> MaybeTls<(), O>

Converts to this type from the input type.

impl From<TlsSettings> for MaybeTls<(), TlsSettings>

fn from(tls: TlsSettings) -> MaybeTls<(), TlsSettings>

Converts to this type from the input type.

impl<'pin, R, T> Unpin for MaybeTls<R, T>

where <PinnedFieldsOfHelperStruct<__MaybeTls<'pin, R, T>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,