Struct 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) -> Result<FtpStream>

Creates an FTP Stream.

Examples found in repository

examples/connecting.rs (line 8)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

pub fn get_ref(&self) -> &TcpStream

Returns a reference to the underlying TcpStream.

Example:

use std::net::TcpStream;

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

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

Log in to the FTP server.

Examples found in repository

examples/connecting.rs (line 9)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

pub fn cwd(&mut self, path: &str) -> Result<()>

Change the current directory to the path specified.

Examples found in repository

examples/connecting.rs (line 12)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

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

Move the current directory to the parent directory.

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

Gets the current directory

Examples found in repository

examples/connecting.rs (line 10)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

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

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

pub fn mkdir(&mut self, pathname: &str) -> Result<()>

This creates a new directory on the server.

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

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

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

Quits the current FTP session.

Examples found in repository

examples/connecting.rs (line 25)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

pub fn get(&mut self, file_name: &str) -> Result<BufReader<DataStream>>

Retrieves the file name specified from the server. 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.

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

Renames the file from_name to to_name

pub fn retr<F, T>(&mut self, filename: &str, reader: F) -> Result<T>

where F: Fn(&mut dyn Read) -> Result<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 simple_retr(&mut self, file_name: &str) -> Result<Cursor<Vec<u8>>>

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

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

Examples found in repository

examples/connecting.rs (line 15)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

pub fn rmdir(&mut self, pathname: &str) -> Result<()>

Removes the remote pathname from the server.

pub fn rm(&mut self, filename: &str) -> Result<()>

Remove the remote file from the server.

pub fn put<R: Read>(&mut self, filename: &str, r: &mut R) -> Result<()>

This stores a file on the server.

Examples found in repository

examples/connecting.rs (line 23)

fn test_ftp(addr: &str, user: &str, pass: &str) -> Result<(), FtpError> {
    let mut ftp_stream = FtpStream::connect((addr, 21)).unwrap();
    ftp_stream.login(user, pass).unwrap();
    println!("current dir: {}", ftp_stream.pwd().unwrap());

    ftp_stream.cwd("test_data").unwrap();

    // An easy way to retrieve a file
    let cursor = ftp_stream.simple_retr("ftpext-charter.txt").unwrap();
    let vec = cursor.into_inner();
    let text = str::from_utf8(&vec).unwrap();
    println!("got data: {}", text);

    // Store a file
    let file_data = format!("Some awesome file data man!!");
    let mut reader = Cursor::new(file_data.into_bytes());
    ftp_stream.put("my_random_file.txt", &mut reader).unwrap();

    ftp_stream.quit()
}

pub fn list(&mut self, pathname: Option<&str>) -> Result<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.

pub fn nlst(&mut self, pathname: Option<&str>) -> Result<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(&mut self, pathname: &str) -> Result<Option<DateTime<UTC>>>

Retrieves the modification time of the file at pathname if it exists. In case the file does not exist None is returned.

pub fn size(&mut self, pathname: &str) -> Result<Option<usize>>

Retrieves the size of the file in bytes at pathname if it exists. In case the file does not exist None is returned.

pub fn read_response(&mut self, expected_code: u32) -> Result<Line>

pub fn read_response_in(&mut self, expected_code: &[u32]) -> Result<Line>

Retrieve single line response

Trait Implementations

impl Debug for FtpStream

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

Formats the value using the given formatter.