termscp 1.0.0

termscp is a feature rich terminal file transfer and explorer with support for SCP/SFTP/FTP/Kube/S3/WebDAV
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

//! ## AuthActivity
//!
//! `auth_activity` is the module which implements the authentication activity

use std::env;

use super::{AuthActivity, FileTransferParams, FileTransferProtocol, FormTab, HostBridgeProtocol};
use crate::filetransfer::HostBridgeParams;
use crate::filetransfer::params::ProtocolParams;
use crate::system::auto_update::{Release, Update, UpdateStatus};
use crate::system::notifications::Notification;

impl AuthActivity {
    /// Get the default port for protocol
    pub(super) fn get_default_port_for_protocol(protocol: FileTransferProtocol) -> u16 {
        match protocol {
            FileTransferProtocol::Sftp | FileTransferProtocol::Scp => 22,
            FileTransferProtocol::Ftp(_) => 21,
            FileTransferProtocol::AwsS3 => 22, // Doesn't matter, since not used
            FileTransferProtocol::Kube => 22,  // Doesn't matter, since not used
            FileTransferProtocol::Smb => 445,
            FileTransferProtocol::WebDAV => 80, // Doesn't matter, since not used
        }
    }

    /// Returns whether the port is standard or not
    pub(super) fn is_port_standard(port: u16) -> bool {
        port < 1024
    }

    /// Check minimum window size window
    pub(super) fn check_minimum_window_size(&mut self, height: u16) {
        if height < 25 {
            // Mount window error
            self.mount_size_err();
        } else {
            self.umount_size_err();
        }
    }

    /// Collect host params as `FileTransferParams`
    pub(super) fn collect_host_bridge_params(&self) -> Result<HostBridgeParams, &'static str> {
        match self.host_bridge_protocol {
            HostBridgeProtocol::Localhost => self.collect_localhost_host_params(),
            HostBridgeProtocol::Remote(remote) => {
                let transfer_params = match remote {
                    FileTransferProtocol::AwsS3 => self.collect_s3_host_params(FormTab::HostBridge),
                    FileTransferProtocol::Kube => {
                        self.collect_kube_host_params(FormTab::HostBridge)
                    }
                    FileTransferProtocol::Smb => self.collect_smb_host_params(FormTab::HostBridge),
                    FileTransferProtocol::Ftp(_)
                    | FileTransferProtocol::Scp
                    | FileTransferProtocol::Sftp => {
                        self.collect_generic_host_params(remote, FormTab::HostBridge)
                    }
                    FileTransferProtocol::WebDAV => {
                        self.collect_webdav_host_params(FormTab::HostBridge)
                    }
                }?;

                Ok(HostBridgeParams::Remote(
                    transfer_params.protocol,
                    transfer_params.params,
                ))
            }
        }
    }

    /// Collect host params as `FileTransferParams`
    pub(super) fn collect_remote_host_params(&self) -> Result<FileTransferParams, &'static str> {
        match self.remote_protocol {
            FileTransferProtocol::AwsS3 => self.collect_s3_host_params(FormTab::Remote),
            FileTransferProtocol::Kube => self.collect_kube_host_params(FormTab::Remote),
            FileTransferProtocol::Smb => self.collect_smb_host_params(FormTab::Remote),
            FileTransferProtocol::Ftp(_)
            | FileTransferProtocol::Scp
            | FileTransferProtocol::Sftp => {
                self.collect_generic_host_params(self.remote_protocol, FormTab::Remote)
            }
            FileTransferProtocol::WebDAV => self.collect_webdav_host_params(FormTab::Remote),
        }
    }

    fn collect_localhost_host_params(&self) -> Result<HostBridgeParams, &'static str> {
        // get remote local path
        let remote_local_path = self.get_input_local_directory(FormTab::Remote);

        // Local path is:
        // - the input local path if set
        // - the remote local path if set
        // - the current directory if neither is set
        let path = self
            .get_input_local_directory(FormTab::HostBridge)
            .or(remote_local_path)
            .unwrap_or_else(|| env::current_dir().unwrap_or_default());

        Ok(HostBridgeParams::Localhost(path))
    }

    /// Get input values from fields or return an error if fields are invalid to work as generic
    pub(super) fn collect_generic_host_params(
        &self,
        protocol: FileTransferProtocol,
        form_tab: FormTab,
    ) -> Result<FileTransferParams, &'static str> {
        let params = self.get_generic_params_input(form_tab);
        if params.address.is_empty() {
            return Err("Invalid host");
        }
        if params.port == 0 {
            return Err("Invalid port");
        }
        Ok(FileTransferParams {
            protocol,
            params: ProtocolParams::Generic(params),
            local_path: self.get_input_local_directory(form_tab),
            remote_path: self.get_input_remote_directory(form_tab),
        })
    }

    /// Get input values from fields or return an error if fields are invalid to work as aws s3
    pub(super) fn collect_s3_host_params(
        &self,
        form_tab: FormTab,
    ) -> Result<FileTransferParams, &'static str> {
        let params = self.get_s3_params_input(form_tab);
        if params.bucket_name.is_empty() {
            return Err("Invalid bucket");
        }
        Ok(FileTransferParams {
            protocol: FileTransferProtocol::AwsS3,
            params: ProtocolParams::AwsS3(params),
            local_path: self.get_input_local_directory(form_tab),
            remote_path: self.get_input_remote_directory(form_tab),
        })
    }

    /// Get input values from fields or return an error if fields are invalid to work as aws s3
    pub(super) fn collect_kube_host_params(
        &self,
        form_tab: FormTab,
    ) -> Result<FileTransferParams, &'static str> {
        let params = self.get_kube_params_input(form_tab);

        Ok(FileTransferParams {
            protocol: FileTransferProtocol::Kube,
            params: ProtocolParams::Kube(params),
            local_path: self.get_input_local_directory(form_tab),
            remote_path: self.get_input_remote_directory(form_tab),
        })
    }

    pub(super) fn collect_smb_host_params(
        &self,
        form_tab: FormTab,
    ) -> Result<FileTransferParams, &'static str> {
        let params = self.get_smb_params_input(form_tab);
        if params.address.is_empty() {
            return Err("Invalid address");
        }
        #[cfg(posix)]
        if params.port == 0 {
            return Err("Invalid port");
        }
        if params.share.is_empty() {
            return Err("Invalid share");
        }
        Ok(FileTransferParams {
            protocol: FileTransferProtocol::Smb,
            params: ProtocolParams::Smb(params),
            local_path: self.get_input_local_directory(form_tab),
            remote_path: self.get_input_remote_directory(form_tab),
        })
    }

    pub(super) fn collect_webdav_host_params(
        &self,
        form_tab: FormTab,
    ) -> Result<FileTransferParams, &'static str> {
        let params = self.get_webdav_params_input(form_tab);
        if params.uri.is_empty() {
            return Err("Invalid URI");
        }
        Ok(FileTransferParams {
            protocol: FileTransferProtocol::WebDAV,
            params: ProtocolParams::WebDAV(params),
            local_path: self.get_input_local_directory(form_tab),
            remote_path: self.get_input_remote_directory(form_tab),
        })
    }

    // -- update install

    /// If enabled in configuration, check for updates from Github
    pub(super) fn check_for_updates(&mut self) {
        debug!("Check for updates...");
        // Check version only if unset in the store
        let ctx = self.context_mut();
        if !ctx.store().isset(super::STORE_KEY_LATEST_VERSION) {
            debug!("Version is not set in storage");
            if ctx.config().get_check_for_updates() {
                debug!("Check for updates is enabled");
                // Send request
                match Update::is_new_version_available() {
                    Ok(Some(Release { version, body })) => {
                        // If some, store version and release notes
                        info!("Latest version is: {}", version);
                        if ctx.config().get_notifications() {
                            // Notify new version available
                            Notification::update_available(version.as_str());
                        }
                        // Store info
                        ctx.store_mut()
                            .set_string(super::STORE_KEY_LATEST_VERSION, version);
                        ctx.store_mut()
                            .set_string(super::STORE_KEY_RELEASE_NOTES, body);
                    }
                    Ok(None) => {
                        info!("Latest version is: {} (current)", env!("CARGO_PKG_VERSION"));
                        // Just set flag as check
                        ctx.store_mut().set(super::STORE_KEY_LATEST_VERSION);
                    }
                    Err(err) => {
                        // Report error
                        error!("Failed to get latest version: {err}",);
                    }
                }
            } else {
                info!("Check for updates is disabled");
            }
        }
    }

    /// Install latest termscp version via GUI
    pub(super) fn install_update(&mut self) {
        // Umount release notes
        self.umount_release_notes();
        // Mount wait box
        self.mount_wait("Installing update. Please wait…");
        // Refresh UI
        self.view();
        // Install update
        let result = Update::default().show_progress(false).upgrade();
        // Umount wait
        self.umount_wait();
        // Show outcome
        match result {
            Ok(UpdateStatus::AlreadyUptodate) => self.mount_info("termscp is already up to date!"),
            Ok(UpdateStatus::UpdateInstalled(ver)) => {
                if self.config().get_notifications() {
                    Notification::update_installed(ver.as_str());
                }
                self.mount_info(format!("termscp has been updated to version {ver}!"))
            }
            Err(err) => {
                if self.config().get_notifications() {
                    Notification::update_failed(err.to_string());
                }
                self.mount_error(format!("Could not install update: {err}"))
            }
        }
    }
}