Struct embedded_tls::TlsConnection

pub struct TlsConnection<'a, Socket, CipherSuite>where
    Socket: AsyncRead + AsyncWrite + 'a,
    CipherSuite: TlsCipherSuite + 'static,{ /* private fields */ }

Type representing an async TLS connection. An instance of this type can be used to establish a TLS connection, write and read encrypted data over this connection, and closing to free up the underlying resources.

Implementations

impl<'a, Socket, CipherSuite> TlsConnection<'a, Socket, CipherSuite>where
    Socket: AsyncRead + AsyncWrite + 'a,
    CipherSuite: TlsCipherSuite + 'static,

pub fn new(delegate: Socket, record_buf: &'a mut [u8]) -> Self

Create a new TLS connection with the provided context and a async I/O implementation

NOTE: The record buffer should be sized to fit an encrypted TLS record and the TLS handshake record. The maximum value of a TLS record is 16 kB, which should be a safe value to use.

pub async fn open<'m, RNG: CryptoRng + RngCore + 'm, Verifier: TlsVerifier<CipherSuite> + 'm>(
    &mut self,
    context: TlsContext<'m, CipherSuite, RNG>
) -> Result<(), TlsError>where
    'a: 'm,

Open a TLS connection, performing the handshake with the configuration provided when creating the connection instance.

The handshake may support certificates up to CERT_SIZE.

Returns an error if the handshake does not proceed. If an error occurs, the connection instance must be recreated.

pub async fn write(&mut self, buf: &[u8]) -> Result<usize, TlsError>

Encrypt and send the provided slice over the connection. The connection must be opened before writing.

Returns the number of bytes written.

pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, TlsError>

Read and decrypt data filling the provided slice. The slice must be able to keep the expected amount of data that can be received in one record to avoid loosing data.

pub async fn close(self) -> Result<Socket, (Socket, TlsError)>

Close a connection instance, returning the ownership of the async I/O provider.

Trait Implementations

impl<'a, Socket, CipherSuite> Io for TlsConnection<'a, Socket, CipherSuite>where
    Socket: AsyncRead + AsyncWrite + 'a,
    CipherSuite: TlsCipherSuite + 'static,

type Error = TlsError

Error type of all the IO operations on this type.

impl<'a, Socket, CipherSuite> Read for TlsConnection<'a, Socket, CipherSuite>where
    Socket: AsyncRead + AsyncWrite + 'a,
    CipherSuite: TlsCipherSuite + 'static,

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact(
    &mut self,
    buf: &mut [u8]
) -> impl Future<Output = Result<(), ReadExactError<Self::Error>>>

Read the exact number of bytes required to fill buf.

impl<'a, Socket, CipherSuite> Write for TlsConnection<'a, Socket, CipherSuite>where
    Socket: AsyncRead + AsyncWrite + 'a,
    CipherSuite: TlsCipherSuite + 'static,

async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(
    &mut self,
    buf: &[u8]
) -> impl Future<Output = Result<(), Self::Error>>

Write an entire buffer into this writer.