Struct ssh2::File

pub struct File { /* private fields */ }

A file handle to an SFTP connection.

Files behave similarly to std::old_io::File in that they are readable and writable and support operations like stat and seek.

Files are created through open, create, and open_mode on an instance of Sftp.

Implementations

impl File

pub fn setstat(&mut self, stat: FileStat) -> Result<(), Error>

Set the metadata for this handle.

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

Get the metadata for this handle.

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

pub fn readdir(&mut self) -> Result<(PathBuf, FileStat), Error>

Reads a block of data from a handle and returns file entry information for the next entry, if any.

Note that this provides raw access to the readdir function from libssh2. This will return an error when there are no more files to read, and files such as . and .. will be included in the return values.

Also note that the return paths will not be absolute paths, they are the filenames of the files in this directory.

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

This function causes the remote server to synchronize the file data and metadata to disk (like fsync(2)).

For this to work requires fsync@openssh.com support on the server.

Trait Implementations

impl Drop for File

fn drop(&mut self)

Executes the destructor for this type.

impl Read for File

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.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> 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 read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where
    Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adapter which will chain this stream with another.

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

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

impl Seek for File

fn seek(&mut self, how: SeekFrom) -> Result<u64>

Move the file handle’s internal pointer to an arbitrary location.

libssh2 implements file pointers as a localized concept to make file access appear more POSIX like. No packets are exchanged with the server during a seek operation. The localized file pointer is simply used as a convenience offset during read/write operations.

You MUST NOT seek during writing or reading a file with SFTP, as the internals use outstanding packets and changing the “file position” during transit will results in badness.

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

Rewind to the beginning of a stream.

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

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

Returns the length of this stream (in bytes).

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

Returns the current seek position from the start of the stream.

impl Write for File

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 is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers 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 Selfwhere
    Self: Sized,

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

impl Send for File

impl Sync for File