Struct suppaftp::FtpStream

pub struct FtpStream { /* private fields */ }

Stream to interface with the FTP server. This interface is only for the command stream.

Implementations

impl FtpStream

pub fn connect<A: ToSocketAddrs>(addr: A) -> FtpResult<Self>

Creates an FTP Stream.

pub fn active_mode(self) -> Self

Enable active mode for data channel

pub fn set_mode(&mut self, mode: Mode)

Set the data channel transfer mode

pub fn set_passive_nat_workaround(&mut self, nat_workaround: bool)

Set NAT workaround for passive mode

pub fn get_welcome_msg(&self) -> Option<&str>

Returns welcome message retrieved from server (if available)

pub fn get_ref(&self) -> &TcpStream

Returns a reference to the underlying TcpStream.

Example:

use suppaftp::FtpStream;
use std::net::TcpStream;
use std::time::Duration;

let stream = FtpStream::connect("127.0.0.1:21")
                       .expect("Couldn't connect to the server...");
stream.get_ref().set_read_timeout(Some(Duration::from_secs(10)))
                .expect("set_read_timeout call failed");

pub fn login<S: AsRef<str>>(&mut self, user: S, password: S) -> FtpResult<()>

Log in to the FTP server.

pub fn cwd<S: AsRef<str>>(&mut self, path: S) -> FtpResult<()>

Change the current directory to the path specified.

pub fn cdup(&mut self) -> FtpResult<()>

Move the current directory to the parent directory.

pub fn pwd(&mut self) -> FtpResult<String>

Gets the current directory

pub fn noop(&mut self) -> FtpResult<()>

This does nothing. This is usually just used to keep the connection open.

pub fn mkdir<S: AsRef<str>>(&mut self, pathname: S) -> FtpResult<()>

This creates a new directory on the server.

pub fn transfer_type(&mut self, file_type: FileType) -> FtpResult<()>

Sets the type of file to be transferred. That is the implementation of TYPE command.

pub fn quit(&mut self) -> FtpResult<()>

Quits the current FTP session.

pub fn rename<S: AsRef<str>>(&mut self, from_name: S, to_name: S) -> FtpResult<()>

Renames the file from_name to to_name

pub fn retr<F, T>(&mut self, file_name: &str, reader: F) -> FtpResult<T> where
    F: FnMut(&mut dyn Read) -> FtpResult<T>, 

The implementation of RETR command where filename is the name of the file to download from FTP and reader is the function which operates with the data stream opened.

assert!(conn.retr("retr.txt", |stream| {
    let mut buf = Vec::new();
    stream.read_to_end(&mut buf).map(|_|
        assert_eq!(buf, "hello, world!".as_bytes())
    ).map_err(|e| FtpError::ConnectionError(e))
}).is_ok());

pub fn retr_as_buffer(&mut self, file_name: &str) -> FtpResult<Cursor<Vec<u8>>>

Simple way to retr a file from the server. This stores the file in a buffer in memory.

let cursor = conn.retr_as_buffer("simple_retr.txt").unwrap();
// do something with bytes
assert_eq!(cursor.into_inner(), "hello, world!".as_bytes());

pub fn retr_as_stream<S: AsRef<str>>(
    &mut self,
    file_name: S
) -> FtpResult<DataStream>

Retrieves the file name specified from the server as a readable stream. This method is a more complicated way to retrieve a file. The reader returned should be dropped. Also you will have to read the response to make sure it has the correct value. Once file has been read, call finalize_retr_stream()

pub fn finalize_retr_stream(&mut self, stream: impl Read) -> FtpResult<()>

Finalize retr stream; must be called once the requested file, got previously with retr_as_stream() has been read

pub fn rmdir<S: AsRef<str>>(&mut self, pathname: S) -> FtpResult<()>

Removes the remote pathname from the server.

pub fn rm<S: AsRef<str>>(&mut self, filename: S) -> FtpResult<()>

Remove the remote file from the server.

pub fn put_file<S: AsRef<str>, R: Read>(
    &mut self,
    filename: S,
    r: &mut R
) -> FtpResult<u64>

This stores a file on the server. r argument must be any struct which implemenents the Read trait. Returns amount of written bytes

pub fn put_with_stream<S: AsRef<str>>(
    &mut self,
    filename: S
) -> FtpResult<DataStream>

Send PUT command and returns a BufWriter, which references the file created on the server The returned stream must be then correctly manipulated to write the content of the source file to the remote destination The stream must be then correctly dropped. Once you’ve finished the write, YOU MUST CALL THIS METHOD: finalize_put_stream

pub fn finalize_put_stream(&mut self, stream: impl Write) -> FtpResult<()>

Finalize put when using stream This method must be called once the file has been written and put_with_stream has been used to write the file

pub fn append_with_stream<S: AsRef<str>>(
    &mut self,
    filename: S
) -> FtpResult<DataStream>

Open specified file for appending data. Returns the stream to append data to specified file. Once you’ve finished the write, YOU MUST CALL THIS METHOD: finalize_put_stream

pub fn append_file<R: Read>(
    &mut self,
    filename: &str,
    r: &mut R
) -> FtpResult<u64>

Append data from reader to file at filename

pub fn abort(&mut self, data_stream: impl Read) -> FtpResult<()>

abort the previous FTP service command

pub fn resume_transfer(&mut self, offset: usize) -> FtpResult<()>

Tell the server to resume the transfer from a certain offset. The offset indicates the amount of bytes to skip from the beginning of the file. the REST command does not actually initiate the transfer. After issuing a REST command, the client must send the appropriate FTP command to transfer the file

It is possible to cancel the REST command, sending a REST command with offset 0

pub fn list(&mut self, pathname: Option<&str>) -> FtpResult<Vec<String>>

Execute LIST command which returns the detailed file listing in human readable format. If pathname is omited then the list of files in the current directory will be returned otherwise it will the list of files on pathname.

Parse result

You can parse the output of this command with

use std::str::FromStr;
use suppaftp::list::File;

let file: File = File::from_str("-rw-rw-r-- 1 0  1  8192 Nov 5 2018 omar.txt")
    .ok()
    .unwrap();

pub fn nlst(&mut self, pathname: Option<&str>) -> FtpResult<Vec<String>>

Execute NLST command which returns the list of file names only. If pathname is omited then the list of files in the current directory will be returned otherwise it will the list of files on pathname.

pub fn mdtm<S: AsRef<str>>(&mut self, pathname: S) -> FtpResult<DateTime<Utc>>

Retrieves the modification time of the file at pathname if it exists.

pub fn size<S: AsRef<str>>(&mut self, pathname: S) -> FtpResult<usize>

Retrieves the size of the file in bytes at pathname if it exists.

Trait Implementations

impl Debug for FtpStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.