Struct ssh2::Channel

pub struct Channel<'sess> { /* 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<'sess> Channel<'sess>

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.

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)

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

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);

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

Start a shell

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

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.

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.

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

Get a handle to the stderr stream of this channel.

The returned handle implements the Read and Write traits.

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

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

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.

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

Get the remote exit signal.

fn read_window(&self) -> ReadWindow

Check the status of the read window.

fn write_window(&self) -> WriteWindow

Check the status of the write window.

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.

fn eof(&self) -> bool

Check if the remote host has sent an EOF status for the selected stream.

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.

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

Wait for the remote end to send EOF.

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

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<'sess> Write for Channel<'sess>

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

Write a buffer into this object, 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_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

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.

impl<'sess> Read for Channel<'sess>

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_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, placing them into 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 chars(self) -> Chars<Self>

Unstable (io)

: the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

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<'sess> Drop for Channel<'sess>

fn drop(&mut self)

A method called when the value goes out of scope.