Struct TcpServerHandshake

pub struct TcpServerHandshake { /* private fields */ }

Handles the server-side of the VBus-over-TCP handshake.

Examples

use async_std::net::{SocketAddr, TcpListener, TcpStream};

use async_resol_vbus::TcpServerHandshake;

let address = "0.0.0.0:7053".parse::<SocketAddr>()?;
let listener = TcpListener::bind(address).await?;
let (stream, _) = listener.accept().await?;
let mut hs = TcpServerHandshake::start(stream).await?;
let password = hs.receive_pass_command().await?;
// ...
let stream = hs.receive_data_command().await?;
// ...

Implementations

impl TcpServerHandshake

pub async fn start(stream: TcpStream) -> Result<TcpServerHandshake>

Start the VBus-over-TCP handshake as the server side.

pub fn into_inner(self) -> TcpStream

Consume self and return the underlying TcpStream.

pub async fn receive_command<V, R, T>(&mut self, validator: V) -> Result<T>

where V: Fn(String, Option<String>) -> R, R: Future<Output = Result<T, &'static str>>,

Receive a command and verify it and its provided arguments. The command reception is repeated as long as the verification fails.

The preferred way to receive commands documented in the VBus-over-TCP specification is through the receive_xxx_command and receive_xxx_command_and_verify_yyy methods which use the receive_command method internally.

This method takes a validator function that is called with the received command and its optional arguments. The validator returns a Future that can resolve into an std::result::Result<T, &'static str>. It can either be:

• Ok(value) if the validation succeeded. The value is used to resolve the receive_command Future.
• Err(reply) if the validation failed. The reply is send back to the client and the command reception is repeated.

pub async fn receive_connect_command(&mut self) -> Result<String>

Wait for a CONNECT <via_tag> command. The via tag argument is returned.

pub async fn receive_connect_command_and_verify_via_tag<V, R>( &mut self, validator: V, ) -> Result<String>

where V: Fn(String) -> R, R: Future<Output = Result<String, &'static str>>,

Wait for a CONNECT <via_tag> command.

pub async fn receive_pass_command(&mut self) -> Result<String>

Wait for a PASS <password> command.

pub async fn receive_pass_command_and_verify_password<V, R>( &mut self, validator: V, ) -> Result<String>

where V: Fn(String) -> R, R: Future<Output = Result<String, &'static str>>,

Wait for a PASS <password> command and validate the provided password.

pub async fn receive_channel_command(&mut self) -> Result<u8>

Wait for a CHANNEL <channel> command.

pub async fn receive_channel_command_and_verify_channel<V, R>( &mut self, validator: V, ) -> Result<u8>

where V: Fn(u8) -> R, R: Future<Output = Result<u8, &'static str>>,

Wait for CHANNEL <channel> command and validate the provided channel

pub async fn receive_data_command(self) -> Result<TcpStream>

Wait for a DATA command.

This function returns the underlying TcpStream since the handshake is complete after sending this command.

Trait Implementations

impl Debug for TcpServerHandshake

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

Formats the value using the given formatter.