Struct ClientHandler 

pub struct ClientHandler { /* private fields */ }

Available on crate feature ssh-real only.

Real SSH client backed by russh (default feature ssh-real). russh handler with TOFU known_hosts (or test-only always-trust when path is absent).

Implementations

impl ClientHandler

pub fn new( cfg: &ConnectionConfig, outcome: Arc<Mutex<Option<SshCliError>>>, forwarded: Sender<Channel<Msg>>, ) -> Self

Build a handler from connection config, outcome slot and inbound-channel sink.

Trait Implementations

impl Handler for ClientHandler

async fn server_channel_open_forwarded_tcpip( &mut self, channel: Channel<Msg>, connected_address: &str, connected_port: u32, originator_address: &str, originator_port: u32, reply: ChannelOpenHandle, _session: &mut Session, ) -> Result<(), Self::Error>

Accepts a forwarded-tcpip channel opened by the server (G-TUN-R01).

Only channels that fit in the bounded queue are accepted. A full queue means nobody is draining the reverse forward, so accepting would buffer indefinitely on the peer’s schedule; rejecting applies backpressure over the wire instead.

The default russh implementation accepts unconditionally and drops the channel, which for a client that never requested a forward means silently letting a server open channels into the process.

async fn server_channel_open_forwarded_streamlocal( &mut self, _channel: Channel<Msg>, socket_path: &str, reply: ChannelOpenHandle, _session: &mut Session, ) -> Result<(), Self::Error>

Rejects forwarded-streamlocal channels.

This CLI only ever requests outbound streamlocal channels (--remote-socket), never a remote Unix-socket listener, so an inbound one was not asked for. Accepting and dropping it — the russh default — would make the refusal invisible to both sides.

type Error = Error

async fn check_server_key( &mut self, server_key: &PublicKey, ) -> Result<bool, Self::Error>

Called to check the server’s public key. This is a very important step to help prevent man-in-the-middle attacks. The default implementation rejects all keys.

async fn auth_banner( &mut self, banner: &str, _session: &mut Session, ) -> Result<(), Self::Error>

Called when the server sends us an authentication banner. This is usually meant to be shown to the user, see RFC4252 for more details.

fn kex_done( &mut self, shared_secret: Option<&[u8]>, names: &Names, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when key exchange has completed.

fn channel_open_confirmation( &mut self, id: ChannelId, max_packet_size: u32, window_size: u32, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server confirmed our request to open a channel. A channel can only be written to after receiving this message (this library panics otherwise).

fn channel_success( &mut self, channel: ChannelId, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server signals success.

fn channel_failure( &mut self, channel: ChannelId, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server signals failure.

fn channel_close( &mut self, channel: ChannelId, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server closes a channel.

fn channel_eof( &mut self, channel: ChannelId, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server sends EOF to a channel.

fn channel_open_failure( &mut self, channel: ChannelId, reason: ChannelOpenFailure, description: &str, language: &str, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server rejected our request to open a channel.

fn server_channel_open_agent_forward( &mut self, channel: Channel<Msg>, reply: ChannelOpenHandleInner<Msg>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server opens an agent forwarding channel.

fn should_accept_unknown_server_channel( &mut self, id: ChannelId, channel_type: &str, ) -> impl Future<Output = bool> + Send

Called when the server attempts to open a channel of unknown type. It may return true, if the channel of unknown type should be accepted. In this case, Handler::server_channel_open_unknown will be called soon after. If it returns false, the channel will not be created and a rejection message will be sent to the server.

fn server_channel_open_unknown( &mut self, channel: Channel<Msg>, reply: ChannelOpenHandleInner<Msg>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server opens an unknown channel (after should_accept_unknown_server_channel returned true).

fn server_channel_open_session( &mut self, channel: Channel<Msg>, reply: ChannelOpenHandleInner<Msg>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server opens a session channel.

fn server_channel_open_direct_tcpip( &mut self, channel: Channel<Msg>, host_to_connect: &str, port_to_connect: u32, originator_address: &str, originator_port: u32, reply: ChannelOpenHandleInner<Msg>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server opens a direct tcp/ip channel (non-standard).

fn server_channel_open_direct_streamlocal( &mut self, channel: Channel<Msg>, socket_path: &str, reply: ChannelOpenHandleInner<Msg>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server opens a direct-streamlocal channel (non-standard).

fn server_channel_open_x11( &mut self, channel: Channel<Msg>, originator_address: &str, originator_port: u32, reply: ChannelOpenHandleInner<Msg>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server opens an X11 channel.

fn data( &mut self, channel: ChannelId, data: &[u8], session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server sends us data. The extended_code parameter is a stream identifier, None is usually the standard output, and Some(1) is the standard error. See RFC4254.

fn extended_data( &mut self, channel: ChannelId, ext: u32, data: &[u8], session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server sends us data. The extended_code parameter is a stream identifier, None is usually the standard output, and Some(1) is the standard error. See RFC4254.

fn xon_xoff( &mut self, channel: ChannelId, client_can_do: bool, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

The server informs this client of whether the client may perform control-S/control-Q flow control. See RFC4254.

fn exit_status( &mut self, channel: ChannelId, exit_status: u32, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

The remote process has exited, with the given exit status.

fn exit_signal( &mut self, channel: ChannelId, signal_name: Sig, core_dumped: bool, error_message: &str, lang_tag: &str, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

The remote process exited upon receiving a signal.

fn window_adjusted( &mut self, channel: ChannelId, new_size: u32, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the network window is adjusted, meaning that we can send more bytes. This is useful if this client wants to send huge amounts of data, for instance if we have called Session::data before, and it returned less than the full amount of data.

fn adjust_window(&mut self, channel: ChannelId, window: u32) -> u32

Called when this client adjusts the network window. Return the next target window and maximum packet size.

fn openssh_ext_host_keys_announced( &mut self, keys: Vec<PublicKey>, session: &mut Session, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server signals success.

fn disconnected( &mut self, reason: DisconnectReason<Self::Error>, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called when the server sent a disconnect message