Struct NeedsInput 

pub struct NeedsInput<Side: SideData>(/* private fields */);

More data needs to be supplied to make progress.

Provide the data to Self::process().

Implementations

impl<Side: SideData> NeedsInput<Side>

pub fn process( self, input: &mut dyn TlsInputBuffer, tls: &mut Vec<u8>, ) -> Result<Side::Handshake, Error>

Progress the handshake by receiving further data.

The data is obtained via input. Any output produced is appended to tls and should be sent to the peer (including if this function returns an error, because tls may contain an alert.)

An error from this function is otherwise fatal to the connection, as it consumes the NeedsInput object.

On success, this returns a handshake object specifying what to do to progress the connection. If this contains another NeedsInput object then obtaining more input (eg, from a socket or other source) is certainly necessary.

pub fn early_exporter(&mut self) -> Result<KeyingMaterialExporter, Error>

Returns the “early” exporter that can derive key material for use in early data

See RFC 5705 for general details on what exporters are, and RFC 9846 S7.5 for specific details on the “early” exporter.

Beware that the early exporter requires care, as it is subject to the same potential for replay as early data itself. See RFC 9846 appendix F.5.1 for more detail.

This function can be called at most once per connection. This function will error if called more than once per connection.

If you are looking for the normal exporter, this is available from Connection::exporter().

impl NeedsInput<ClientSide>

pub fn early_data(&mut self) -> Option<WriteEarlyData<'_>>

Returns an object you can use to send TLS1.3 early data (a.k.a. “0-RTT data”) to the server.

This returns None in many circumstances when the capability to send early data is not available, including but not limited to:

• The server hasn’t been talked to previously.
• The server does not support resumption.
• The server does not support early data.
• The resumption data for the server has expired.

The server specifies a maximum amount of early data. You can learn this limit through the returned object, and writes through it will process only this many bytes.

The server can choose not to accept any sent early data – in this case the data is lost but the connection continues. You can tell this happened using ClientSide::is_early_data_accepted().

Trait Implementations

impl<S: SideData> Debug for NeedsInput<S>

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

Formats the value using the given formatter.