Struct zbus::handshake::ServerHandshake

pub struct ServerHandshake<S> { /* private fields */ }

A representation of an in-progress handshake, server-side

This would typically be used to implement a D-Bus broker, or in the context of a P2P connection.

This struct is an async-compatible representation of the initial handshake that must be performed before a D-Bus connection can be used. To use it, you should call the advance_handshake method whenever the underlying socket becomes ready (tracking the readiness itself is not managed by this abstraction) until it returns Ok(()), at which point you can invoke the try_finish method to get an Authenticated, which can be given to Connection::new_authenticated.

If handling the handshake asynchronously is not necessary, the blocking_finish method is provided which blocks until the handshake is completed or an error occurs.

Implementations

impl<S: Socket> ServerHandshake<S>

pub fn new(socket: S, guid: Guid, client_uid: u32) -> ServerHandshake<S>

pub fn advance_handshake(&mut self) -> Result<()>

Same as Handshake::advance_handshake. Only exists for backwards compatibility.

pub fn try_finish(self) -> Result<Authenticated<S>, Self>

Same as Handshake::try_finish. Only exists for backwards compatibility.

pub fn socket(&self) -> &S

Same as Handshake::socket. Only exists for backwards compatibility.

impl ServerHandshake<UnixStream>

pub fn blocking_finish(self) -> Result<Authenticated<UnixStream>>

Block and automatically drive the handshake for this server

This method will block until the handshake is finalized, even if the socket is in non-blocking mode.

Trait Implementations

impl<S: Debug> Debug for ServerHandshake<S>

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

Formats the value using the given formatter.

impl<S: Socket> Handshake<S> for ServerHandshake<S>

fn next_io_operation(&self) -> IoOperation

The next I/O operation needed for advancing the handshake.

fn advance_handshake(&mut self) -> Result<()>

Attempt to advance the handshake

fn try_finish(self) -> Result<Authenticated<S>, Self>

Attempt to finalize this handshake into an initialized client.

fn socket(&self) -> &S

Access the socket backing this handshake