Thrussh

https://docs.rs/thrussh/latest/thrussh/
Admin
Thrussh is a Rust implementation of the SSH protocol providing client and server functionality with...
Tokens:385,792
Snippets:3,350
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Thrussh Client Implementation Example

Source: https://docs.rs/thrussh/latest/thrussh/index.html?search=

This example demonstrates a basic Thrussh client setup, including handling server key checks, channel confirmations, and data reception. It connects to a server, authenticates, opens a session, sends data, and waits for a response.

```rust
extern crate thrussh;
extern crate thrussh_keys;
extern crate futures;
extern crate tokio;
extern crate env_logger;
use std::sync::Arc;
use thrussh::
use thrussh::server::{Auth, Session};
use thrussh_keys::
use futures::Future;
use std::io::Read;


struct Client {
}

impl client::Handler for Client {
   type Error = anyhow::Error;

   fn check_server_key(self, server_public_key: &key::PublicKey) -> impl Future<Output = Result<(Self, bool), Self::Error>> + Send {
       println!("check_server_key: {:?}", server_public_key);
       async { Ok((self, true)) }
   }

   fn channel_open_confirmation(self, channel: ChannelId, max_packet_size: u32, window_size: u32, session: client::Session) -> impl Future<Output = Result<(Self, client::Session), Self::Error>> + Send {
       println!("channel_open_confirmation: {:?}", channel);
       async { Ok((self, session)) }
   }

   fn data(self, channel: ChannelId, data: &[u8], session: client::Session) -> impl Future<Output = Result<(Self, client::Session), Self::Error>> + Send {
       println!("data on channel {:?}: {:?}", channel, std::str::from_utf8(data));
       async { Ok((self, session)) }
   }
}

#[tokio::main]
async fn main() {
  let config = thrussh::client::Config::default();
  let config = Arc::new(config);
  let sh = Client{};

  let key = thrussh_keys::key::KeyPair::generate_ed25519().unwrap();
  let mut agent = thrussh_keys::agent::client::AgentClient::connect_env().await.unwrap();
  agent.add_identity(&key, &[]).await.unwrap();
  let mut session = thrussh::client::connect(config, "localhost:22", sh).await.unwrap();
  if session.authenticate_future(std::env::var("USER").unwrap(), key.clone_public_key(), agent).await.1.unwrap() {
    let mut channel = session.channel_open_session().await.unwrap();
    channel.data(&b"Hello, world!"[..]).await.unwrap();
    if let Some(msg) = channel.wait().await {
        println!("{:?}", msg)
    }
  }
}
```

--------------------------------

### Example Searches

Source: https://docs.rs/thrussh/latest/thrussh/client/fn.connect.html?search=

These are example search queries that can be used to find relevant information or code.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example Searches

Source: https://docs.rs/thrussh/latest/thrussh/trait.Named.html?search=

Illustrative examples of search queries, demonstrating patterns like searching for a specific type, a type conversion, or generic types with transformations.

```text
Example searches:
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Implement SSH Server with Thrussh

Source: https://docs.rs/thrussh/latest/thrussh/index.html

This example demonstrates how to set up a basic SSH server using thrussh. It includes configuration, handler implementation for sessions, authentication, and data forwarding between clients. Note that error handling for client disconnections and ID generation for new connections are simplified in this example.

```rust
extern crate thrussh;
extern crate thrussh_keys;
extern crate futures;
extern crate tokio;
use std::sync::{Mutex, Arc};
use thrussh::*;
use thrussh::server::{Auth, Session};
use thrussh_keys::*;
use std::collections::HashMap;
use futures::Future;

#[tokio::main]
async fn main() {
    let client_key = thrussh_keys::key::KeyPair::generate_ed25519().unwrap();
    let client_pubkey = Arc::new(client_key.clone_public_key());
    let mut config = thrussh::server::Config::default();
    config.connection_timeout = Some(std::time::Duration::from_secs(3));
    config.auth_rejection_time = std::time::Duration::from_secs(3);
    config.keys.push(thrussh_keys::key::KeyPair::generate_ed25519().unwrap());
    let config = Arc::new(config);
    let sh = Server{
        client_pubkey,
        clients: Arc::new(Mutex::new(HashMap::new())),
        id: 0
    };
    tokio::time::timeout(
       std::time::Duration::from_secs(1),
       thrussh::server::run(config, "0.0.0.0:2222", sh)
    ).await.unwrap_or(Ok(()));
}

#[derive(Clone)]
struct Server {
    client_pubkey: Arc<thrussh_keys::key::PublicKey>,
    clients: Arc<Mutex<HashMap<(usize, ChannelId), thrussh::server::Handle>>>,
    id: usize,
}

impl server::Server for Server {
    type Handler = Self;
    fn new(&mut self, _: Option<std::net::SocketAddr>) -> Self {
        let s = self.clone();
        self.id += 1;
        s
    }
}

impl server::Handler for Server {
    type Error = anyhow::Error;

    fn channel_open_session(self, channel: ChannelId, session: Session) -> impl Future<Output = Result<(Self, Session), Self::Error>> + Send {
        {
            let mut clients = self.clients.lock().unwrap();
            clients.insert((self.id, channel), session.handle());
        }
        async { Ok((self, session)) }
    }
    fn auth_publickey(self, _: &str, _: &key::PublicKey) -> impl Future<Output = Result<(Self, Auth), Self::Error>> + Send {
        async { Ok((self, server::Auth::Accept)) }
    }
    fn data(self, channel: ChannelId, data: &[u8], mut session: Session) -> impl Future<Output = Result<(Self, Session), Self::Error>> + Send {
        {
            let mut clients = self.clients.lock().unwrap();
            for ((id, channel), ref mut s) in clients.iter_mut() {
                if *id != self.id {
                    s.data(*channel, CryptoVec::from_slice(data));
                }
            }
        }
        session.data(channel, CryptoVec::from_slice(data));
        async { Ok((self, session)) }
    }
}

```

--------------------------------

### subsystem_request

Source: https://docs.rs/thrussh/latest/thrussh/server/trait.Handler.html?search=u32+-%3E+bool

The client asks to start the subsystem with the given name (such as sftp).

```APIDOC
## subsystem_request

### Description
Initiates a subsystem request with a specified name.

### Signature
`fn subsystem_request(self, channel: ChannelId, name: &str, session: Session) -> impl Future<Output = Result<(Self, Session, bool), Self::Error>> + Send`
```

--------------------------------

### shell_request

Source: https://docs.rs/thrussh/latest/thrussh/server/trait.Handler.html

Handles a request from the client to start a shell session.

```APIDOC
## shell_request

### Description
The client requests a shell.

### Signature
`fn shell_request(self, channel: ChannelId, session: Session) -> impl Future<Output = Result<(Self, Session), Self::Error>> + Send`
```

--------------------------------

### Channel::request_subsystem

Source: https://docs.rs/thrussh/latest/thrussh/client/struct.Channel.html?search=u32+-%3E+bool

Requests the start of a subsystem with the given name.

```APIDOC
## Channel::request_subsystem

### Description
Request the start of a subsystem with the given name.

### Method
`request_subsystem<A: Into<String>>(&mut self, want_reply: bool, name: A) -> Result<(), Error>`
```

--------------------------------

### subsystem_request

Source: https://docs.rs/thrussh/latest/thrussh/server/trait.Handler.html

Initiates a subsystem on the SSH channel. This is used to start services like SFTP.

```APIDOC
## subsystem_request

### Description
The client asks to start the subsystem with the given name (such as sftp).

### Method
(Not specified, likely internal method)

### Parameters
- **channel** (ChannelId) - Description not specified
- **name** (str) - The name of the subsystem to start.
- **session** (Session) - The current SSH session.

### Response
- **Self** - The updated handler instance.
- **Session** - The updated session.
- **bool** - Indicates success or failure.
```

--------------------------------

### Rust binary_search Example

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=u32+-%3E+bool

Demonstrates searching a sorted slice for an element. Returns Ok(index) if found, or Err(insertion_point) if not found.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r {
    Ok(1..=4) => true,
    _ => false,
})
```

--------------------------------

### Session::handle

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=

Get a handle to this session.

```APIDOC
## Session::handle

### Description
Get a handle to this session.

### Method
`handle(&self) -> Handle`
```

--------------------------------

### Session::handle

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get a handle to this session.

```APIDOC
## Session::handle

### Description
Get a handle to this session.

### Method
`&self`

### Returns
`Handle`
```

--------------------------------

### subsystem_request

Source: https://docs.rs/thrussh/latest/thrussh/server/trait.Handler.html?search=

Initiates a subsystem request on an SSH channel. This is used to start services like SFTP.

```APIDOC
## subsystem_request

### Description
The client asks to start the subsystem with the given name (such as sftp).

### Method
Implied asynchronous method call

### Parameters
- **channel** (ChannelId) - The ID of the channel.
- **name** (str) - The name of the subsystem to start.
- **session** (Session) - The current session object.

### Return Value
- A future that resolves to a Result containing the updated handler, session, and a boolean indicating success.
```

--------------------------------

### subsystem_request

Source: https://docs.rs/thrussh/latest/thrussh/server/trait.Handler.html?search=std%3A%3Avec

Initiates a subsystem with a given name on the SSH channel. This is typically used for starting services like SFTP.

```APIDOC
## subsystem_request

### Description

The client asks to start the subsystem with the given name (such as sftp).

### Method Signature

`fn subsystem_request(self, channel: ChannelId, name: &str, session: Session) -> impl Future<Output = Result<(Self, Session, bool), Self::Error>> + Send`

### Parameters

- `channel` (ChannelId): The identifier for the SSH channel.
- `name` (str): The name of the subsystem to start (e.g., "sftp").
- `session` (Session): The current SSH session object.

### Returns

A future that resolves to a `Result` containing a tuple of the updated handler, the session, and a boolean indicating success, or an error.
```

--------------------------------

### Rust unsafe get_disjoint_unchecked_mut example with range indices

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates using `get_disjoint_unchecked_mut` with ranges to get mutable references to sub-slices. This is an unsafe operation and requires careful handling to avoid undefined behavior.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(x, &[8, 88, 888]);
```

--------------------------------

### run

Source: https://docs.rs/thrussh/latest/thrussh/server/fn.run.html?search=std%3A%3Avec

Runs a server by creating a new Connection from the server's configuration, a stream, and a Handler.

```APIDOC
## run

### Description
Run a server. Create a new `Connection` from the server’s configuration, a stream and a `Handler`.

### Signature
```rust
pub async fn run<H: Server + Send + 'static>(
    config: Arc<Config>,
    addr: &str,
    server: H,
) -> Result<(), Error>
```

### Parameters
* `config`: `Arc<Config>` - The server configuration.
* `addr`: `&str` - The address to bind the server to.
* `server`: `H` - The server handler implementing the `Server` trait.

### Return Value
* `Result<(), Error>` - Ok(()) if the server runs successfully, or an Error if it fails.
```

--------------------------------

### Get Last Chunk

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Get an immutable reference to the last N elements. Returns None if the slice is shorter than N.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

--------------------------------

### run

Source: https://docs.rs/thrussh/latest/thrussh/server/fn.run.html

Runs a server. It creates a new `Connection` using the provided server configuration, a stream, and a handler.

```APIDOC
## run
thrussh::server

### Description
Run a server. Create a new `Connection` from the server’s configuration, a stream and a `Handler`.

### Signature
```rust
pub async fn run<H: Server + Send + 'static>(
    config: Arc<Config>,
    addr: &str,
    server: H,
) -> Result<(), Error>
```

### Parameters
* `config`: An `Arc<Config>` containing the server configuration.
* `addr`: A string slice representing the address to bind the server to.
* `server`: An object implementing the `Server` trait, which will handle incoming connections.

### Returns
Returns `Ok(())` on successful execution, or an `Error` if the server fails to run.
```

--------------------------------

### Get Element or Subslice

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Safely get an immutable reference to an element by index or a subslice by range. Returns None if the index is out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Get Last Chunk Mutably

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Get a mutable reference to the last N elements. Returns None if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());
```

--------------------------------

### Basic SSH Client Implementation in Rust

Source: https://docs.rs/thrussh/latest/thrussh/index.html?search=std%3A%3Avec

Demonstrates a basic SSH client setup using Thrussh, including connection, authentication, and sending a simple message. Requires `tokio` for async operations and `thrussh_keys` for key management.

```rust
extern crate thrussh;
extern crate thrussh_keys;
extern crate futures;
extern crate tokio;
extern crate env_logger;
use std::sync::Arc;
use thrussh::*
use thrussh::server::{Auth, Session};
use thrussh_keys::*
use futures::Future;
use std::io::Read;


struct Client {
}

impl client::Handler for Client {
   type Error = anyhow::Error;

   fn check_server_key(self, server_public_key: &key::PublicKey) -> impl Future<Output = Result<(Self, bool), Self::Error>> + Send {
       println!("check_server_key: {:?}", server_public_key);
       async { Ok((self, true)) }
   }

   fn channel_open_confirmation(self, channel: ChannelId, max_packet_size: u32, window_size: u32, session: client::Session) -> impl Future<Output = Result<(Self, client::Session), Self::Error>> + Send {
       println!("channel_open_confirmation: {:?}", channel);
       async { Ok((self, session)) }
   }

   fn data(self, channel: ChannelId, data: &[u8], session: client::Session) -> impl Future<Output = Result<(Self, client::Session), Self::Error>> + Send {
       println!("data on channel {:?}: {:?}", channel, std::str::from_utf8(data));
       async { Ok((self, session)) }
   }
}

#[tokio::main]
async fn main() {
  let config = thrussh::client::Config::default();
  let config = Arc::new(config);
  let sh = Client{};

  let key = thrussh_keys::key::KeyPair::generate_ed25519().unwrap();
  let mut agent = thrussh_keys::agent::client::AgentClient::connect_env().await.unwrap();
  agent.add_identity(&key, &[]).await.unwrap();
  let mut session = thrussh::client::connect(config, "localhost:22", sh).await.unwrap();
  if session.authenticate_future(std::env::var("USER").unwrap(), key.clone_public_key(), agent).await.1.unwrap() {
    let mut channel = session.channel_open_session().await.unwrap();
    channel.data(&b"Hello, world!"[..]).await.unwrap();
    if let Some(msg) = channel.wait().await {
        println!("{:?}", msg)
    }
  }
}
```

--------------------------------

### client::connect

Source: https://docs.rs/thrussh/latest/thrussh/all.html

Establishes a client connection to an SSH server.

```APIDOC
## client::connect

### Description
Establishes a client connection to an SSH server.

### Function Signature
`pub fn connect<T>(stream: T, config: Config) -> Result<Session>`

### Parameters
- `stream`: The underlying transport stream.
- `config`: The client configuration.

### Returns
A `Result` containing a `Session` on success or an error.
```

--------------------------------

### Get the length of CryptoVec

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Use the `len()` method to get the current number of bytes in the CryptoVec. An empty CryptoVec has a length of 0.

```rust
assert_eq!(cryptovec::CryptoVec::new().len(), 0)
```

--------------------------------

### Get Mutable Element or Subslice

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Safely get a mutable reference to an element by index or a subslice by range. Returns None if the index is out of bounds.

```rust
let x = &mut [0, 1, 2];

if let Some(elem) = x.get_mut(1) {
    *elem = 42;
}
assert_eq!(x, &[0, 42, 2]);
```

--------------------------------

### Binary Search Example

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Demonstrates binary search on a sorted slice. It shows finding an element, handling cases where the element is not found, and dealing with multiple matches.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r {
    Ok(1..=4) => true,
    _ => false,
});
```

--------------------------------

### Generic Implementations for Key

Source: https://docs.rs/thrussh/latest/thrussh/cipher/clear/struct.Key.html?search=

Demonstrates various blanket implementations applicable to the Key struct, including Any, Borrow, From, Into, TryFrom, TryInto, and VZip.

```rust
fn type_id(&self) -> TypeId
```

```rust
fn borrow(&self) -> &T
```

```rust
fn borrow_mut(&mut self) -> &mut T
```

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
```

```rust
type Output = T
```

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

```rust
fn vzip(self) -> V
```

--------------------------------

### Get Mutable First Chunk

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Safely get a mutable reference to the first N elements. Returns None if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

assert_eq!(None, x.first_chunk_mut::<4>());
```

--------------------------------

### Get Slice as Fixed-Size Array Reference

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=std%3A%3Avec

Attempt to get a reference to the underlying array with a specific size `N` using `as_array`. Returns `None` if `N` does not match the slice's length.

```rust
let data = [1, 2, 3];
let slice = &data[..];

let arr_ref: Option<&[i32; 3]> = slice.as_array();
assert!(arr_ref.is_some());

let arr_ref_wrong_size: Option<&[i32; 2]> = slice.as_array();
assert!(arr_ref_wrong_size.is_none());
```

--------------------------------

### Implement Thrussh SSH Client

Source: https://docs.rs/thrussh/latest/thrussh/index.html

This example shows how to implement the `client::Handler` trait for a custom client. It includes methods for checking server keys, handling channel open confirmations, and processing incoming data. The `main` function demonstrates connecting to an SSH server, authenticating using an agent, opening a session, sending a command, and receiving output.

```rust
extern crate thrussh;
extern crate thrussh_keys;
extern crate futures;
extern crate tokio;
extern external env_logger;
use std::sync::Arc;
use thrussh::*
use thrussh::server::{Auth, Session};
use thrussh_keys::*
use futures::Future;
use std::io::Read;


struct Client {
}

impl client::Handler for Client {
   type Error = anyhow::Error;

   fn check_server_key(self, server_public_key: &key::PublicKey) -> impl Future<Output = Result<(Self, bool), Self::Error>> + Send {
       println!("check_server_key: {:?}", server_public_key);
       async { Ok((self, true)) }
   }

   fn channel_open_confirmation(self, channel: ChannelId, max_packet_size: u32, window_size: u32, session: client::Session) -> impl Future<Output = Result<(Self, client::Session), Self::Error>> + Send {
       println!("channel_open_confirmation: {:?}", channel);
       async { Ok((self, session)) }
   }

   fn data(self, channel: ChannelId, data: &[u8], session: client::Session) -> impl Future<Output = Result<(Self, client::Session), Self::Error>> + Send {
       println!("data on channel {:?}: {:?}", channel, std::str::from_utf8(data));
       async { Ok((self, session)) }
   }
}

#[tokio::main]
async fn main() {
  let config = thrussh::client::Config::default();
  let config = Arc::new(config);
  let sh = Client{};

  let key = thrussh_keys::key::KeyPair::generate_ed25519().unwrap();
  let mut agent = thrussh_keys::agent::client::AgentClient::connect_env().await.unwrap();
  agent.add_identity(&key, &[]).await.unwrap();
  let mut session = thrussh::client::connect(config, "localhost:22", sh).await.unwrap();
  if session.authenticate_future(std::env::var("USER").unwrap(), key.clone_public_key(), agent).await.1.unwrap() {
    let mut channel = session.channel_open_session().await.unwrap();
    channel.data(&b"Hello, world!"[..]).await.unwrap();
    if let Some(msg) = channel.wait().await {
        println!("{:?}", msg)
    }
  }
}
```

--------------------------------

### type_id

Source: https://docs.rs/thrussh/latest/thrussh/struct.MethodSet.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the `TypeId` of `self`.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Method Signature
`fn type_id(&self) -> TypeId`
```

--------------------------------

### Get Mutable Slice as Fixed-Size Array Reference

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=std%3A%3Avec

Attempt to get a mutable reference to the underlying array with a specific size `N` using `as_mut_array`. Returns `None` if `N` does not match the slice's length.

```rust
let mut data = [1, 2, 3];
let slice = &mut data[..];

let arr_mut_ref: Option<&mut [i32; 3]> = slice.as_mut_array();
assert!(arr_mut_ref.is_some());

let arr_mut_ref_wrong_size: Option<&mut [i32; 2]> = slice.as_mut_array();
assert!(arr_mut_ref_wrong_size.is_none());
```

--------------------------------

### Get Mutable Slice as Fixed-Size Array Mutable Reference

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempt to get a mutable reference to the underlying array with a specific size `N` using `as_mut_array`. Returns `None` if `N` does not match the slice's length.

```rust
let mut data = [1, 2, 3];
let slice = &mut data[..];
let arr_mut_ref: Option<&mut [i32; 3]> = slice.as_mut_array();
assert!(arr_mut_ref.is_some());
let arr_mut_ref_wrong_size: Option<&mut [i32; 2]> = slice.as_mut_array();
assert!(arr_mut_ref_wrong_size.is_none());
```

--------------------------------

### run

Source: https://docs.rs/thrussh/latest/thrussh/server/index.html

Runs the SSH server. It creates a new `Connection` from the server's configuration, a stream, and a `Handler`.

```APIDOC
## run

### Description
Run a server. Create a new `Connection` from the server’s configuration, a stream and a `Handler`.

### Parameters

This function does not explicitly list parameters in the source text. However, based on the description, it likely takes configuration, a stream, and a handler.

### Example

```rust
// Example usage (conceptual, actual parameters depend on library implementation)
// server::run(config, stream, handler);
```
```

--------------------------------

### connect

Source: https://docs.rs/thrussh/latest/thrussh/client/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Establishes a new SSH client connection.

```APIDOC
## connect

### Description
Establishes a new SSH client connection.

### Function Signature
connect(...)

### Parameters
(Details not provided in source)

### Returns
(Details not provided in source)
```

--------------------------------

### Split Off Slice Starting with Third Element

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Use `split_off` with a one-sided range `2..` to remove and return a reference to the slice starting from the third element. The original slice is modified to contain only the elements before the split point.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

--------------------------------

### connect

Source: https://docs.rs/thrussh/latest/thrussh/client/index.html

Establishes a new SSH client connection.

```APIDOC
## connect

### Description
Establishes a new SSH client connection.

### Function Signature
`fn connect(...)`

### Parameters
(Parameters not explicitly detailed in the source)

### Returns
(Return value not explicitly detailed in the source)
```

--------------------------------

### thrussh::server::run

Source: https://docs.rs/thrussh/latest/thrussh/server/fn.run.html?search=u32+-%3E+bool

Runs a server by creating a new `Connection` with the provided configuration, stream, and handler.

```APIDOC
## Function run

### Description
Run a server. Create a new `Connection` from the server’s configuration, a stream and a `Handler`.

### Signature
```rust
pub async fn run<H: Server + Send + 'static>(
    config: Arc<Config>,
    addr: &str,
    server: H,
) -> Result<(), Error>
```

### Parameters
* `config`: An `Arc<Config>` containing the server configuration.
* `addr`: A string slice representing the address to bind the server to.
* `server`: An implementation of the `Server` trait that will handle incoming connections.

### Returns
Returns `Ok(())` on success, or an `Error` if the server fails to run.
```

--------------------------------

### strip_circumfix

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=

Returns a subslice with the prefix and suffix removed. If the slice starts with `prefix` and ends with `suffix`, returns the subslice after the prefix and before the suffix, wrapped in `Some`. If the slice does not start with `prefix` or does not end with `suffix`, returns `None`. This is a nightly-only experimental API.

```APIDOC
## strip_circumfix

### Description
Returns a subslice with the prefix and suffix removed. If the slice starts with `prefix` and ends with `suffix`, returns the subslice after the prefix and before the suffix, wrapped in `Some`. If the slice does not start with `prefix` or does not end with `suffix`, returns `None`.

### Signature
`pub fn strip_circumfix<S, P>(&self, prefix: &P, suffix: &S) -> Option<&[T]>`
where T: PartialEq, S: SlicePattern<Item = T> + ?Sized, P: SlicePattern<Item = T> + ?Sized

### Notes
This is a nightly-only experimental API. (`strip_circumfix`)
```

--------------------------------

### MethodSet Creation Methods

Source: https://docs.rs/thrussh/latest/thrussh/struct.MethodSet.html?search=

Methods for creating and initializing MethodSet instances.

```APIDOC
## MethodSet Creation Methods

### `empty()`

Returns an empty set of flags.

### `all()`

Returns the set containing all flags.

### `from_bits(bits: u32) -> Option<Self>`

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

### `from_bits_truncate(bits: u32) -> Self`

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

### `from_bits_unchecked(bits: u32) -> Self`

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

**Safety**
The caller of the `bitflags!` macro can chose to allow or disallow extra bits for their bitflags type.
The caller of `from_bits_unchecked()` has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.
```

--------------------------------

### take

Source: https://docs.rs/thrussh/latest/thrussh/struct.MethodSet.html?search=u32+-%3E+bool

Creates an iterator that yields the first `n` elements.

```APIDOC
## take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Arguments
- `n`: The maximum number of elements to yield.
```

--------------------------------

### Split Off Slice Starting with Third Element Mutably

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Use `split_off_mut` with `2..` to remove and return a mutable reference to the slice starting from the third element. The original mutable slice is modified to contain only the elements before the split point.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

--------------------------------

### take

Source: https://docs.rs/thrussh/latest/thrussh/struct.MethodSet.html

Creates an iterator that yields the first `n` elements.

```APIDOC
## take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Method
`take`

### Parameters
- `n`: The maximum number of elements to yield.
```

--------------------------------

### Session::window_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=

Get the window size for a given channel.

```APIDOC
## Session::window_size

### Description
Get the window size for a given channel.

### Method
`window_size(&self, channel: &ChannelId) -> u32`
```

--------------------------------

### Session::window_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the window size for a given channel.

```APIDOC
## Session::window_size

### Description
Get the window size for a given channel.

### Method
`&self`

### Parameters
#### Path Parameters
- **channel** (`&ChannelId`) - Description: The channel ID.

### Returns
`u32`
```

--------------------------------

### by_ref

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Creates a "by reference" adapter for the CryptoVec writer.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Write`.

### Method
`by_ref`

### Returns
* `&mut Self` - A mutable reference to the writer.
```

--------------------------------

### connect

Source: https://docs.rs/thrussh/latest/thrussh/client/fn.connect.html?search=

Establishes an SSH connection to a given address with a specified handler and configuration.

```APIDOC
## connect

### Description
Establishes an SSH connection to a given address with a specified handler and configuration.

### Function Signature
```rust
pub async fn connect<H: Handler + Send + 'static, T: ToSocketAddrs>(
    config: Arc<Config>,
    addr: T,
    handler: H,
) -> Result<Handle<H>, H::Error>
```

### Parameters
* `config`: An `Arc<Config>` containing the SSH client configuration.
* `addr`: A type `T` that implements `ToSocketAddrs`, representing the server address.
* `handler`: A type `H` that implements `Handler + Send + 'static`, which will handle SSH events.

### Return Value
Returns a `Result` which is either a `Handle<H>` on success, or an error of type `H::Error` on failure.
```

--------------------------------

### sender_window_size

Source: https://docs.rs/thrussh/latest/thrussh/client/struct.Session.html?search=

Gets the sender's window size for a channel.

```APIDOC
## sender_window_size

### Description
Gets the sender's window size for a channel.

### Method
`sender_window_size(&self, channel: ChannelId) -> usize`

### Parameters
- **channel** (ChannelId) - The ID of the channel.

### Return Value
- `usize`: The sender's window size.
```

--------------------------------

### server::run

Source: https://docs.rs/thrussh/latest/thrussh/all.html

Runs the SSH server.

```APIDOC
## server::run

### Description
Runs the SSH server, accepting incoming connections.

### Function Signature
`pub fn run<T>(stream: T, config: Config) -> Result<Handle>`

### Parameters
- `stream`: The underlying transport stream.
- `config`: The server configuration.

### Returns
A `Result` containing a `Handle` for managing the server on success or an error.
```

--------------------------------

### Get Channel ID

Source: https://docs.rs/thrussh/latest/thrussh/client/struct.Channel.html

Retrieves the unique identifier for the channel.

```rust
pub fn id(&self) -> ChannelId
```

--------------------------------

### proxy_connect

Source: https://docs.rs/thrussh/latest/thrussh/client/proxy/enum.Stream.html?search=std%3A%3Avec

Establishes a connection through a specified proxy command and its arguments.

```APIDOC
## Stream::proxy_connect

### Description
Connect through a proxy command.

### Method Signature
`pub fn proxy_connect(cmd: &str, args: &[&str]) -> Result<Stream, Error>`

### Parameters
*   `cmd` (`&str`): The proxy command to execute.
*   `args` (`&[&str]`): A slice of string slices representing the arguments for the proxy command.
```

--------------------------------

### starts_with

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Checks if the slice starts with the given needle slice.

```APIDOC
## starts_with

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.

### Method
`pub fn starts_with(&self, needle: &[T]) -> bool`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = [10, 40, 30];
v.starts_with(&[10, 40])
```

### Response
#### Success Response (true)
- Returns `true` if the slice starts with the `needle`.

#### Success Response Example
```json
{
  "example": "true"
}
```

#### Success Response (false)
- Returns `false` if the slice does not start with the `needle`.

#### Success Response Example
```json
{
  "example": "false"
}
```
```

--------------------------------

### connect

Source: https://docs.rs/thrussh/latest/thrussh/client/fn.connect.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Establishes a new SSH connection to a given address with the provided configuration and handler.

```APIDOC
## connect

### Description
Establishes a new SSH connection.

### Function Signature
```rust
pub async fn connect<H: Handler + Send + 'static, T: ToSocketAddrs>(
    config: Arc<Config>,
    addr: T,
    handler: H,
) -> Result<Handle<H>, H::Error>
```

### Parameters
* `config`: An `Arc<Config>` containing the SSH connection configuration.
* `addr`: A type `T` that implements `ToSocketAddrs`, representing the server address.
* `handler`: A type `H` that implements `Handler + Send + 'static`, which will handle SSH events.

### Returns
A `Result` which is either a `Handle<H>` on success, or an error of type `H::Error` on failure.
```

--------------------------------

### try_from

Source: https://docs.rs/thrussh/latest/thrussh/client/struct.Handle.html?search=

Performs the conversion.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Type Parameters
- `T`: The target type.
- `U`: The source type, which must implement `Into<T>`.

### Arguments
- `value`: The value to convert.

### Returns
A `Result` containing the converted value of type `T` or an error.
```

--------------------------------

### strip_prefix

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=

Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

```APIDOC
## strip_prefix

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

### Signature
`pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>`
where P: SlicePattern<Item = T> + ?Sized, T: PartialEq

### Examples
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```
```

--------------------------------

### Get Session Configuration

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=std%3A%3Avec

Retrieves a reference to the session's configuration.

```rust
pub fn config(&self) -> &Config
```

--------------------------------

### Blanket Implementations for Key

Source: https://docs.rs/thrussh/latest/thrussh/cipher/clear/struct.Key.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Showcases blanket implementations for the Key struct, demonstrating its compatibility with various generic traits.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

Source
```rust
fn type_id(&self) -> TypeId
```

Gets the `TypeId` of `self`. Read more

### impl<T> Borrow<T> for T

Source
```rust
fn borrow(&self) -> &T
```

Immutably borrows from an owned value. Read more

### impl<T> BorrowMut<T> for T

Source
```rust
fn borrow_mut(&mut self) -> &mut T
```

Mutably borrows from an owned value. Read more

### impl<T> From<T> for T

Source
```rust
fn from(t: T) -> T
```

Returns the argument unchanged.

### impl<T, U> Into<U> for T

Source
```rust
fn into(self) -> U
```

Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### impl<T> Same for T

Source
```rust
type Output = T
```

Should always be `Self`

### impl<T, U> TryFrom<U> for T

Source
```rust
type Error = Infallible
```

The type returned in the event of a conversion error.

Source
```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

Performs the conversion.

### impl<T, U> TryInto<U> for T

Source
```rust
type Error = <U as TryFrom<T>>::Error
```

The type returned in the event of a conversion error.

Source
```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

Performs the conversion.

### impl<V, T> VZip<V> for T

Source
```rust
fn vzip(self) -> V
```
```

--------------------------------

### Session::sender_window_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the sender window size for a given channel.

```APIDOC
## Session::sender_window_size

### Description
Get the sender window size for a given channel.

### Method
`&self`

### Parameters
#### Path Parameters
- **channel** (`ChannelId`) - Description: The channel ID.

### Returns
`usize`
```

--------------------------------

### Binary Search with Partition Point for Insertion

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html

Demonstrates using partition_point to find the correct index for inserting an element into a sorted vector while maintaining sorted order.

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
// If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to
// `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`
// to shift less elements.
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### Session::sender_window_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=

Get the sender window size for a given channel.

```APIDOC
## Session::sender_window_size

### Description
Get the sender window size for a given channel.

### Method
`sender_window_size(&self, channel: ChannelId) -> usize`
```

--------------------------------

### client::connect_stream

Source: https://docs.rs/thrussh/latest/thrussh/all.html

Establishes a client connection using a stream.

```APIDOC
## client::connect_stream

### Description
Establishes a client connection using a stream.

### Function Signature
`pub fn connect_stream<T>(stream: T, config: Config) -> Result<Session>`

### Parameters
- `stream`: The stream to use for the connection.
- `config`: The client configuration.

### Returns
A `Result` containing a `Session` on success or an error.
```

--------------------------------

### CryptoVec::new

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=std%3A%3Avec

Creates a new, empty CryptoVec.

```APIDOC
## CryptoVec::new

### Description
Creates a new `CryptoVec`.

### Method
`CryptoVec::new()`

### Returns
A new, empty `CryptoVec` instance.
```

--------------------------------

### Session::max_packet_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the maximum packet size for a given channel.

```APIDOC
## Session::max_packet_size

### Description
Get the maximum packet size for a given channel.

### Method
`&self`

### Parameters
#### Path Parameters
- **channel** (`&ChannelId`) - Description: The channel ID.

### Returns
`u32`
```

--------------------------------

### Session::max_packet_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=

Get the maximum packet size for a given channel.

```APIDOC
## Session::max_packet_size

### Description
Get the maximum packet size for a given channel.

### Method
`max_packet_size(&self, channel: &ChannelId) -> u32`
```

--------------------------------

### Partial Sort Unstable By Key Examples

Source: https://docs.rs/thrussh/latest/thrussh/struct.CryptoVec.html?search=u32+-%3E+bool

Demonstrates various use cases of `partial_sort_unstable_by_key`, including empty ranges, single-element ranges, subrange sorting, and full range sorting.

```rust
#![feature(slice_partial_sort_unstable)]

let mut v = [4i32, -5, 1, -3, 2];

// empty range at the beginning, nothing changed
v.partial_sort_unstable_by_key(0..0, |k| k.abs());
assert_eq!(v, [4, -5, 1, -3, 2]);
```

```rust
// empty range in the middle, partitioning the slice
v.partial_sort_unstable_by_key(2..2, |k| k.abs());
for i in 0..2 {
   assert!(v[i].abs() <= v[2].abs());
}
for i in 3..v.len() {
  assert!(v[2].abs() <= v[i].abs());
}
```

```rust
// single element range, same as select_nth_unstable
v.partial_sort_unstable_by_key(2..3, |k| k.abs());
for i in 0..2 {
   assert!(v[i].abs() <= v[2].abs());
}
for i in 3..v.len() {
  assert!(v[2].abs() <= v[i].abs());
}
```

```rust
// partial sort a subrange
v.partial_sort_unstable_by_key(1..4, |k| k.abs());
assert_eq!(&v[1..4], [2, -3, 4]);
```

```rust
// partial sort the whole range, same as sort_unstable
v.partial_sort_unstable_by_key(.., |k| k.abs());
assert_eq!(v, [1, 2, -3, 4, -5]);
```

--------------------------------

### Session::writable_packet_size

Source: https://docs.rs/thrussh/latest/thrussh/server/struct.Session.html?search=

Get the writable packet size for a given channel.

```APIDOC
## Session::writable_packet_size

### Description
Get the writable packet size for a given channel.

### Method
`writable_packet_size(&self, channel: &ChannelId) -> u32`
```
Tokens:
Raw