Struct ssh2::Channel

pub struct Channel { /* fields omitted */ }

A channel represents a portion of an SSH connection on which data can be read and written.

Channels denote all of SCP uploads and downloads, shell sessions, remote process executions, and other general-purpose sessions. Each channel implements the Reader and Writer traits to send and receive data. Whether or not I/O operations are blocking is mandated by the blocking flag on a channel's corresponding Session.

Methods

impl Channel

pub fn setenv(&mut self, var: &str, val: &str) -> Result<(), Error>

Set an environment variable in the remote channel's process space.

Note that this does not make sense for all channel types and may be ignored by the server despite returning success.

pub fn request_pty(
    &mut self,
    term: &str,
    mode: Option<&str>,
    dim: Option<(u32, u32, u32, u32)>
) -> Result<(), Error>

Request a PTY on an established channel.

Note that this does not make sense for all channel types and may be ignored by the server despite returning success.

The dimensions argument is a tuple of (width, height, width_px, height_px)

pub fn request_pty_size(
    &mut self,
    width: u32,
    height: u32,
    width_px: Option<u32>,
    height_px: Option<u32>
) -> Result<(), Error>

Request a PTY of a specified size

pub fn exec(&mut self, command: &str) -> Result<(), Error>

Execute a command

An execution is one of the standard process services defined by the SSH2 protocol.

Example

let mut channel = session.channel_session().unwrap();
channel.exec("ls").unwrap();
let mut s = String::new();
channel.read_to_string(&mut s).unwrap();
println!("{}", s);

pub fn shell(&mut self) -> Result<(), Error>

Start a shell

A shell is one of the standard process services defined by the SSH2 protocol.

pub fn subsystem(&mut self, system: &str) -> Result<(), Error>

Request a subsystem be started.

A subsystem is one of the standard process services defined by the SSH2 protocol.

pub fn process_startup(
    &mut self,
    request: &str,
    message: Option<&str>
) -> Result<(), Error>

Initiate a request on a session type channel.

The SSH2 protocol currently defines shell, exec, and subsystem as standard process services.

Important traits for Stream<'channel>

impl<'channel> Read for Stream<'channel>impl<'channel> Write for Stream<'channel>

pub fn stderr<'a>(&'a mut self) -> Stream<'a>

Get a handle to the stderr stream of this channel.

The returned handle implements the Read and Write traits.

Important traits for Stream<'channel>

impl<'channel> Read for Stream<'channel>impl<'channel> Write for Stream<'channel>

pub fn stream<'a>(&'a mut self, stream_id: i32) -> Stream<'a>

Get a handle to a particular stream for this channel.

The returned handle implements the Read and Write traits.

Groups of substreams may be flushed by passing on of the following constants and then calling flush().

• FLUSH_EXTENDED_DATA - Flush all extended data substreams
• FLUSH_ALL - Flush all substreams

pub fn handle_extended_data(&mut self, mode: ExtendedData) -> Result<(), Error>

Change how extended data (such as stderr) is handled

pub fn exit_status(&self) -> Result<i32, Error>

Returns the exit code raised by the process running on the remote host at the other end of the named channel.

Note that the exit status may not be available if the remote end has not yet set its status to closed.

pub fn exit_signal(&self) -> Result<ExitSignal, Error>

Get the remote exit signal.

pub fn read_window(&self) -> ReadWindow

Check the status of the read window.

pub fn write_window(&self) -> WriteWindow

Check the status of the write window.

pub fn adjust_receive_window(
    &mut self,
    adjust: u64,
    force: bool
) -> Result<u64, Error>

Adjust the receive window for a channel by adjustment bytes.

If the amount to be adjusted is less than the minimum adjustment and force is false, the adjustment amount will be queued for a later packet.

This function returns the new size of the receive window (as understood by remote end) on success.

pub fn eof(&self) -> bool

Check if the remote host has sent an EOF status for the channel. Take care: the EOF status is for the entire channel which can be confusing because the reading from the channel reads only the stdout stream. unread, buffered, stderr data will cause eof() to return false.

pub fn send_eof(&mut self) -> Result<(), Error>

Tell the remote host that no further data will be sent on the specified channel.

Processes typically interpret this as a closed stdin descriptor.

pub fn wait_eof(&mut self) -> Result<(), Error>

Wait for the remote end to send EOF. Note that unread buffered stdout and stderr will cause this function to return Ok(()) without waiting. You should call the eof() function after calling this to check the status of the channel.

pub fn close(&mut self) -> Result<(), Error>

Close an active data channel.

In practice this means sending an SSH_MSG_CLOSE packet to the remote host which serves as instruction that no further data will be sent to it. The remote host may still send data back until it sends its own close message in response.

To wait for the remote end to close its connection as well, follow this command with wait_closed

pub fn wait_close(&mut self) -> Result<(), Error>

Enter a temporary blocking state until the remote host closes the named channel.

Typically sent after close in order to examine the exit status.

Trait Implementations

impl Drop for Channel

fn drop(&mut self)

Executes the destructor for this type.

impl Read for Channel

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl Write for Channel

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.