Struct WishHandler 

pub struct WishHandler { /* private fields */ }

Handler for a single SSH connection.

Implements russh::server::Handler to handle SSH protocol events and bridge them to Wish’s session/middleware system.

Implementations

impl WishHandler

pub fn new( remote_addr: SocketAddr, local_addr: SocketAddr, server_state: Arc<ServerState>, shutdown_rx: Receiver<()>, ) -> Self

Creates a new handler for a connection.

Trait Implementations

impl Handler for WishHandler

fn auth_publickey<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, user: &'life1 str, public_key: &'life2 PublicKey, ) -> Pin<Box<dyn Future<Output = Result<Auth, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle public key authentication.

fn auth_password<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, user: &'life1 str, password: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Auth, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle password authentication.

fn auth_none<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Auth, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle “none” authentication (for servers that accept all).

fn auth_keyboard_interactive<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, user: &'life1 str, submethods: &'life2 str, response: Option<Response<'async_trait>>, ) -> Pin<Box<dyn Future<Output = Result<Auth, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle keyboard-interactive authentication.

fn channel_open_session<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: Channel<Msg>, session: &'life1 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle new session channel.

fn pty_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, channel: ChannelId, term: &'life1 str, col_width: u32, row_height: u32, _pix_width: u32, _pix_height: u32, _modes: &'life2 [(Pty, u32)], session: &'life3 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle PTY request.

fn shell_request<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, session: &'life1 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle shell request.

fn exec_request<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, channel: ChannelId, data: &'life1 [u8], session: &'life2 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle exec request (command execution).

fn env_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, channel: ChannelId, variable_name: &'life1 str, variable_value: &'life2 str, session: &'life3 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle environment variable request.

fn subsystem_request<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, channel: ChannelId, name: &'life1 str, session: &'life2 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle subsystem request.

fn window_change_request<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, col_width: u32, row_height: u32, _pix_width: u32, _pix_height: u32, _session: &'life1 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle window change request.

fn data<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, channel: ChannelId, data: &'life1 [u8], _session: &'life2 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle data from client.

fn channel_eof<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, _session: &'life1 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle channel EOF.

fn channel_close<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, _session: &'life1 mut RusshSession, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle channel close.

type Error = Error

fn auth_publickey_offered<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, user: &'life1 str, public_key: &'life2 PublicKey, ) -> Pin<Box<dyn Future<Output = Result<Auth, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Check authentication using the “publickey” method. This method should just check whether the public key matches the authorized ones. Russh then checks the signature. If the key is unknown, or the signature is invalid, Russh guarantees that rejection happens in constant time config.auth_rejection_time, except if this method takes more time than that.

fn auth_succeeded<'life0, 'life1, 'async_trait>( &'life0 mut self, session: &'life1 mut Session, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Called when authentication succeeds for a session.

fn channel_open_x11<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, channel: Channel<Msg>, originator_address: &'life1 str, originator_port: u32, session: &'life2 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Called when a new X11 channel is created. Return value indicates whether the channel request should be granted.

fn channel_open_direct_tcpip<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, channel: Channel<Msg>, host_to_connect: &'life1 str, port_to_connect: u32, originator_address: &'life2 str, originator_port: u32, session: &'life3 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Send + 'async_trait,

Called when a new TCP/IP is created. Return value indicates whether the channel request should be granted.

fn channel_open_forwarded_tcpip<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, channel: Channel<Msg>, host_to_connect: &'life1 str, port_to_connect: u32, originator_address: &'life2 str, originator_port: u32, session: &'life3 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Send + 'async_trait,

Called when a new forwarded connection comes in. https://www.rfc-editor.org/rfc/rfc4254#section-7

fn channel_open_confirmation<'life0, 'life1, 'async_trait>( &'life0 mut self, id: ChannelId, max_packet_size: u32, window_size: u32, session: &'life1 mut Session, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

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

fn extended_data<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, channel: ChannelId, code: u32, data: &'life1 [u8], session: &'life2 mut Session, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Called when an extended data packet is received. Code 1 means that this packet comes from stderr, other codes are not defined (see RFC4254).

fn window_adjusted<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, new_size: u32, session: &'life1 mut Session, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Called when the network window is adjusted, meaning that we can send more bytes.

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

Called when this server adjusts the network window. Return the next target window.

fn x11_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, channel: ChannelId, single_connection: bool, x11_auth_protocol: &'life1 str, x11_auth_cookie: &'life2 str, x11_screen_number: u32, session: &'life3 mut Session, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Send + 'async_trait,

The client requests an X11 connection.

fn agent_request<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, session: &'life1 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

The client requests OpenSSH agent forwarding

fn signal<'life0, 'life1, 'async_trait>( &'life0 mut self, channel: ChannelId, signal: Sig, session: &'life1 mut Session, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

The client is sending a signal (usually to pass to the currently running process).

fn tcpip_forward<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, address: &'life1 str, port: &'life2 mut u32, session: &'life3 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Send + 'async_trait,

Used for reverse-forwarding ports, see RFC4254. If port is 0, you should set it to the allocated port number.

fn cancel_tcpip_forward<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, address: &'life1 str, port: u32, session: &'life2 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Used to stop the reverse-forwarding of a port, see RFC4254.

fn streamlocal_forward<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, socket_path: &'life1 str, session: &'life2 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

fn cancel_streamlocal_forward<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, socket_path: &'life1 str, session: &'life2 mut Session, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,