kelpsget 0.1.4

A modern, lightweight wget clone written in Rust for fast and reliable file downloads from the command line.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::error::Error;
use std::path::Path;
use std::io::{Read, Write};
use url::Url;
use suppaftp::FtpStream;
use crate::progress::create_progress_bar;
use crate::config::ProxyConfig;
use crate::optimization::Optimizer;
use crate::utils::print;

pub struct FtpDownloader {
    url: String,
    output_path: String,
    quiet_mode: bool,
    proxy: ProxyConfig,
    optimizer: Optimizer,
}

impl FtpDownloader {
    pub fn new(
        url: String,
        output_path: String,
        quiet_mode: bool,
        proxy: ProxyConfig,
        optimizer: Optimizer,
    ) -> Self {
        Self {
            url,
            output_path,
            quiet_mode,
            proxy,
            optimizer,
        }
    }

    pub fn download(&self) -> Result<(), Box<dyn Error>> {
        let url = Url::parse(&self.url)?;
        let host = url.host_str().ok_or("Invalid host")?;
        let port = url.port().unwrap_or(21);
        let path = url.path();

        print(&format!("Connecting to FTP server {}:{}...", host, port), self.quiet_mode);

        let mut ftp = if self.proxy.enabled {
            self.connect_via_proxy(host, port)?
        } else {
            FtpStream::connect((host, port))?
        };

        let username = url.username();
        let password = url.password().unwrap_or("anonymous");

        print(&format!("Logging in as {}...", username), self.quiet_mode);
        ftp.login(username, password)?;

        ftp.transfer_type(suppaftp::types::FileType::Binary)?;

        let size = ftp.size(path)? as u64;
        
        let progress = create_progress_bar(
            self.quiet_mode,
            format!("Downloading {}", path),
            Some(size),
            false
        );

        let mut file = std::fs::File::create(&self.output_path)?;

        // Download file
        let mut downloaded = 0;
        ftp.retr(path, |reader| {
            let mut buffer = vec![0; 8192];
            loop {
                match reader.read(&mut buffer) {
                    Ok(0) => break,
                    Ok(n) => {
                        file.write_all(&buffer[..n]).map_err(|e| suppaftp::FtpError::ConnectionError(e))?;
                        downloaded += n;
                        progress.set_position(downloaded as u64);
                    }
                    Err(e) => return Err(suppaftp::FtpError::ConnectionError(e)),
                }
            }
            Ok(())
        })?;

        progress.finish();
        print("Download completed successfully!", self.quiet_mode);

        Ok(())
    }

    fn connect_via_proxy(&self, host: &str, port: u16) -> Result<FtpStream, Box<dyn Error>> {
        match self.proxy.proxy_type {
            crate::config::ProxyType::Http | crate::config::ProxyType::Https => {
                Err("HTTP/HTTPS proxy not supported for FTP".into())
            }
            crate::config::ProxyType::Socks5 => {
                if let Some(proxy_url) = &self.proxy.url {
                    let proxy = Url::parse(proxy_url)?;
                    let proxy_host = proxy.host_str().ok_or("Invalid proxy host")?;
                    let proxy_port = proxy.port().unwrap_or(1080);

                    let stream = socks::Socks5Stream::connect(
                        (proxy_host, proxy_port),
                        (host, port),
                    )?;

                    Ok(FtpStream::connect_with_stream(stream.into_inner())?)
                } else {
                    Err("Proxy URL not configured".into())
                }
            }
        }
    }
}