,
{
// Append the path as file or directory
if src_path.as_ref().is_file() {
self.append_file(path, &mut File::open(src_path)?)
} else if src_path.as_ref().is_dir() {
self.append_dir(path, src_path)
} else {
// TODO: return a IO NotFound error here!
panic!("Unable to append path to archive, not a file or directory");
}
}
/// Append a file to the archive builder.
pub fn append_file(&mut self, path: P, file: &mut File) -> Result<()>
where
P: AsRef,
{
self.inner.append_file(path, file)
}
/// Append a directory to the archive builder.
// TODO: Define a flag to add recursively or not
pub fn append_dir(&mut self, path: P, src_path: Q) -> Result<()>
where
P: AsRef,
Q: AsRef,
{
self.inner.append_dir_all(path, src_path)
}
// TODO: some description
pub fn finish(mut self) -> Result<()> {
self.inner.finish()
}
}
================================================
FILE: src/archive/mod.rs
================================================
pub mod archive;
pub mod archiver;
================================================
FILE: src/client.rs
================================================
use std::time::Duration;
use ffsend_api::client::{ClientConfig, ClientConfigBuilder};
use crate::cmd::matcher::MainMatcher;
/// Create a client configuration for ffsend actions.
///
/// A client configuration allows you to build a client, which must be passed to ffsend API
/// actions.
// TODO: properly handle errors, do not unwrap
pub fn create_config(matcher_main: &MainMatcher) -> ClientConfig {
// TODO: configure HTTP authentication properties
ClientConfigBuilder::default()
.timeout(to_duration(matcher_main.timeout()))
.transfer_timeout(to_duration(matcher_main.transfer_timeout()))
.basic_auth(matcher_main.basic_auth())
.build()
.expect("failed to create network client configuration")
}
/// Convert the given number of seconds into an optional duration, used for clients.
pub fn to_duration(secs: u64) -> Option {
if secs > 0 {
Some(Duration::from_secs(secs))
} else {
None
}
}
================================================
FILE: src/cmd/arg/api.rs
================================================
use clap::{Arg, ArgMatches};
use ffsend_api::api::{DesiredVersion, Version};
use super::{CmdArg, CmdArgOption};
use crate::config::API_VERSION_DESIRED_DEFAULT;
use crate::util::{quit_error_msg, ErrorHints};
/// The api argument.
pub struct ArgApi {}
impl CmdArg for ArgApi {
fn name() -> &'static str {
"api"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("api")
.long("api")
.short("A")
.value_name("VERSION")
.env("FFSEND_API")
.hide_env_values(true)
.global(true)
.help("Server API version to use, '-' to lookup")
.long_help(
"Server API version to use, one of:\n\
2, 3: Send API versions\n\
auto, -: probe server to determine\
",
)
}
}
impl<'a> CmdArgOption<'a> for ArgApi {
type Value = DesiredVersion;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// Get the version string
let version = match Self::value_raw(matches) {
Some(version) => version,
None => return API_VERSION_DESIRED_DEFAULT,
};
// Parse the lookup version string
if is_auto(version) {
return DesiredVersion::Lookup;
}
// Parse the given API version
match Version::parse(version) {
Ok(version) => DesiredVersion::Use(version),
Err(_) => quit_error_msg(
"failed to determine given server API version, version unknown",
ErrorHints::default(),
),
}
}
}
/// Check whether the given API version argument means we've to probe the server for the proper
/// version.
fn is_auto(arg: &str) -> bool {
let arg = arg.trim().to_lowercase();
arg == "a" || arg == "auto" || arg == "-"
}
================================================
FILE: src/cmd/arg/basic_auth.rs
================================================
use clap::{Arg, ArgMatches};
use super::{CmdArg, CmdArgOption};
/// The basicauth argument.
pub struct ArgBasicAuth {}
impl CmdArg for ArgBasicAuth {
fn name() -> &'static str {
"basic-auth"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("basic-auth")
.long("basic-auth")
.alias("basic-authentication")
.alias("http-basic-authentication")
.alias("http-basic-auth")
.value_name("USER:PASSWORD")
.env("FFSEND_BASIC_AUTH")
.hide_env_values(true)
.global(true)
.help("Protected proxy HTTP basic authentication credentials (not FxA)")
}
}
impl<'a> CmdArgOption<'a> for ArgBasicAuth {
type Value = Option<(String, Option)>;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// Get the authentication credentials
let raw = match Self::value_raw(matches) {
Some(raw) => raw,
None => return None,
};
// Split the properties
let mut iter = raw.splitn(2, ':');
Some((
iter.next().unwrap_or("").to_owned(),
iter.next().map(|pass| pass.to_owned()),
))
}
}
================================================
FILE: src/cmd/arg/download_limit.rs
================================================
use clap::{Arg, ArgMatches};
use ffsend_api::api::Version as ApiVersion;
use ffsend_api::config::downloads_max;
use super::{CmdArg, CmdArgFlag, CmdArgOption};
use crate::cmd::matcher::MainMatcher;
use crate::util::{highlight, prompt_yes, quit};
/// The download limit argument.
pub struct ArgDownloadLimit {}
impl ArgDownloadLimit {
pub fn value_checked<'a>(
matches: &ArgMatches<'a>,
main_matcher: &MainMatcher,
api_version: ApiVersion,
auth: bool,
) -> Option {
// Get the download value
let mut downloads = Self::value(matches)?;
// Get number of allowed downloads, return if allowed or when forcing
let allowed = downloads_max(api_version, auth);
if allowed.contains(&downloads) || main_matcher.force() {
return Some(downloads);
}
// Prompt the user the specified downloads limit is invalid
let allowed_str = allowed
.iter()
.map(|value| format!("{}", value))
.collect::>()
.join(", ");
eprintln!("The downloads limit must be one of: {}", allowed_str);
if auth {
eprintln!("Use '{}' to force", highlight("--force"));
} else {
eprintln!(
"Use '{}' to force, authenticate for higher limits",
highlight("--force")
);
}
// Ask to use closest limit, quit if user cancelled
let closest = closest(allowed, downloads);
if !prompt_yes(
&format!("Would you like to limit downloads to {} instead?", closest),
None,
main_matcher,
) {
quit();
}
downloads = closest;
Some(downloads)
}
}
impl CmdArg for ArgDownloadLimit {
fn name() -> &'static str {
"download-limit"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("download-limit")
.long("download-limit")
.short("d")
.alias("downloads")
.alias("download")
.value_name("COUNT")
.env("FFSEND_DOWNLOAD_LIMIT")
.help("The file download limit")
}
}
impl CmdArgFlag for ArgDownloadLimit {}
impl<'a> CmdArgOption<'a> for ArgDownloadLimit {
type Value = Option;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// TODO: do not unwrap, report an error
Self::value_raw(matches).map(|d| d.parse::().expect("invalid download limit"))
}
}
/// Find the closest value to `current` in the given `values` range.
fn closest(values: &[usize], current: usize) -> usize {
// Own the values, sort and reverse, start with biggest first
let mut values = values.to_vec();
values.sort_unstable();
// Find the closest value, return it
*values
.iter()
.rev()
.map(|value| (value, (current as i64 - *value as i64).abs()))
.min_by_key(|value| value.1)
.expect("failed to find closest value, none given")
.0
}
================================================
FILE: src/cmd/arg/expiry_time.rs
================================================
use chrono::Duration;
use clap::{Arg, ArgMatches};
use failure::Fail;
use ffsend_api::api::Version as ApiVersion;
use ffsend_api::config::expiry_max;
use super::{CmdArg, CmdArgFlag, CmdArgOption};
use crate::cmd::matcher::MainMatcher;
use crate::util::{
format_duration, highlight, parse_duration, prompt_yes, quit, quit_error, ErrorHints,
};
/// The download limit argument.
pub struct ArgExpiryTime {}
impl ArgExpiryTime {
pub fn value_checked<'a>(
matches: &ArgMatches<'a>,
main_matcher: &MainMatcher,
api_version: ApiVersion,
auth: bool,
) -> Option {
// Get the expiry time value
let mut expiry = Self::value(matches)?;
// Get expiry time, return if allowed or when forcing
let max = *expiry_max(api_version, auth).into_iter().max().unwrap();
if expiry <= max || main_matcher.force() {
return Some(expiry);
}
// Define function to format seconds
let format_secs = |secs: usize| format_duration(Duration::seconds(secs as i64));
// Prompt the user the specified expiry time is invalid
eprintln!(
"The expiry time must equal to or less than: {}",
format_secs(max),
);
if auth {
eprintln!("Use '{}' to force", highlight("--force"));
} else {
eprintln!(
"Use '{}' to force, authenticate for higher limits",
highlight("--force")
);
}
// Ask to use maximum expiry time instead, quit if user cancelled
if !prompt_yes(
&format!(
"Would you like to set expiry time to {} instead?",
format_secs(max),
),
None,
main_matcher,
) {
quit();
}
expiry = max;
Some(expiry)
}
}
impl CmdArg for ArgExpiryTime {
fn name() -> &'static str {
"expiry-time"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("expiry-time")
.long("expiry-time")
.short("e")
.alias("expire")
.alias("expiry")
.value_name("TIME")
.env("FFSEND_EXPIRY_TIME")
.help("The file expiry time")
}
}
impl CmdArgFlag for ArgExpiryTime {}
impl<'a> CmdArgOption<'a> for ArgExpiryTime {
type Value = Option;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
Self::value_raw(matches).map(|t| match parse_duration(t) {
Ok(seconds) => seconds,
Err(err) => quit_error(
err.context("specified invalid file expiry time"),
ErrorHints::default(),
),
})
}
}
================================================
FILE: src/cmd/arg/gen_passphrase.rs
================================================
use chbs;
use clap::Arg;
use super::{CmdArg, CmdArgFlag};
/// The passphrase generation argument.
pub struct ArgGenPassphrase {}
impl ArgGenPassphrase {
/// Generate a cryptographically secure passphrase that is easily
/// remembered using diceware.
pub fn gen_passphrase() -> String {
chbs::passphrase()
}
}
impl CmdArg for ArgGenPassphrase {
fn name() -> &'static str {
"gen-passphrase"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("gen-passphrase")
.long("gen-passphrase")
.alias("gen-password")
.alias("generate-passphrase")
.alias("generate-password")
.short("P")
.conflicts_with("password")
.help("Protect the file with a generated passphrase")
}
}
impl CmdArgFlag for ArgGenPassphrase {}
================================================
FILE: src/cmd/arg/host.rs
================================================
use clap::{Arg, ArgMatches};
use failure::Fail;
use ffsend_api::url::Url;
use super::{CmdArg, CmdArgOption};
use crate::host::parse_host;
use crate::util::{quit_error, ErrorHints};
/// The host argument.
pub struct ArgHost {}
impl CmdArg for ArgHost {
fn name() -> &'static str {
"host"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("host")
.long("host")
.short("h")
.value_name("URL")
.default_value("https://send.vis.ee/")
.env("FFSEND_HOST")
.hide_env_values(true)
.help("The remote host to upload to")
}
}
impl<'a> CmdArgOption<'a> for ArgHost {
type Value = Url;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// Get the URL
let url = Self::value_raw(matches).expect("missing host");
// Parse the URL
match parse_host(&url) {
Ok(url) => url,
Err(err) => quit_error(
err.context("failed to parse the given host"),
ErrorHints::default(),
),
}
}
}
================================================
FILE: src/cmd/arg/mod.rs
================================================
pub mod api;
pub mod basic_auth;
pub mod download_limit;
pub mod expiry_time;
pub mod gen_passphrase;
pub mod host;
pub mod owner;
pub mod password;
pub mod url;
// Re-export to arg module
pub use self::api::ArgApi;
pub use self::basic_auth::ArgBasicAuth;
pub use self::download_limit::ArgDownloadLimit;
pub use self::expiry_time::ArgExpiryTime;
pub use self::gen_passphrase::ArgGenPassphrase;
pub use self::host::ArgHost;
pub use self::owner::ArgOwner;
pub use self::password::ArgPassword;
pub use self::url::ArgUrl;
use clap::{Arg, ArgMatches};
/// A generic trait, for a reusable command argument struct.
/// The `CmdArgFlag` and `CmdArgOption` traits further specify what kind of
/// argument this is.
pub trait CmdArg {
/// Get the argument name that is used as main identifier.
fn name() -> &'static str;
/// Build the argument.
fn build<'a, 'b>() -> Arg<'a, 'b>;
}
/// This `CmdArg` specification defines that this argument may be tested as
/// flag. This will allow to test whether the flag is present in the given
/// matches.
pub trait CmdArgFlag: CmdArg {
/// Check whether the argument is present in the given matches.
fn is_present<'a>(matches: &ArgMatches<'a>) -> bool {
matches.is_present(Self::name())
}
}
/// This `CmdArg` specification defines that this argument may be tested as
/// option. This will allow to fetch the value of the argument.
pub trait CmdArgOption<'a>: CmdArg {
/// The type of the argument value.
type Value;
/// Get the argument value.
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value;
/// Get the raw argument value, as a string reference.
fn value_raw<'b: 'a>(matches: &'a ArgMatches<'b>) -> Option<&'a str> {
matches.value_of(Self::name())
}
}
================================================
FILE: src/cmd/arg/owner.rs
================================================
use clap::{Arg, ArgMatches};
use super::{CmdArg, CmdArgFlag, CmdArgOption};
use crate::cmd::matcher::{MainMatcher, Matcher};
use crate::util::prompt_owner_token;
/// The owner argument.
pub struct ArgOwner {}
impl CmdArg for ArgOwner {
fn name() -> &'static str {
"owner"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("owner")
.long("owner")
.short("o")
.alias("owner-token")
.value_name("TOKEN")
.min_values(0)
.max_values(1)
.help("Specify the file owner token")
}
}
impl CmdArgFlag for ArgOwner {}
impl<'a> CmdArgOption<'a> for ArgOwner {
type Value = Option;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// The owner token flag must be present
if !Self::is_present(matches) {
return None;
}
// Get the owner token from the argument if set
match Self::value_raw(matches) {
None => {}
p => return p.map(|p| p.into()),
}
// Create a main matcher
let matcher_main = MainMatcher::with(matches).unwrap();
// Prompt for the owner token
// TODO: should this be optional?
Some(prompt_owner_token(&matcher_main, false))
}
}
================================================
FILE: src/cmd/arg/password.rs
================================================
use clap::{Arg, ArgMatches};
use super::{CmdArg, CmdArgFlag, CmdArgOption};
use crate::cmd::matcher::{MainMatcher, Matcher};
use crate::util::{check_empty_password, prompt_password};
/// The password argument.
pub struct ArgPassword {}
impl CmdArg for ArgPassword {
fn name() -> &'static str {
"password"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("password")
.long("password")
.short("p")
.value_name("PASSWORD")
.min_values(0)
.max_values(1)
.help("Unlock a password protected file")
}
}
impl CmdArgFlag for ArgPassword {}
impl<'a> CmdArgOption<'a> for ArgPassword {
type Value = Option;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// The password flag must be present
if !Self::is_present(matches) {
return None;
}
// Create a main matcher
let matcher_main = MainMatcher::with(matches).unwrap();
// Get the password argument value, or prompt
let password = match Self::value_raw(matches) {
Some(password) => password.into(),
None => prompt_password(&matcher_main, false).unwrap(),
};
// Check for empty passwords
check_empty_password(&password, &matcher_main);
Some(password)
}
}
================================================
FILE: src/cmd/arg/url.rs
================================================
use clap::{Arg, ArgMatches};
use failure::Fail;
use ffsend_api::url::Url;
use super::{CmdArg, CmdArgOption};
use crate::host::parse_host;
use crate::util::{quit_error, ErrorHints};
/// The URL argument.
pub struct ArgUrl {}
impl CmdArg for ArgUrl {
fn name() -> &'static str {
"URL"
}
fn build<'b, 'c>() -> Arg<'b, 'c> {
Arg::with_name("URL")
.required(true)
.multiple(false)
.help("The share URL")
}
}
impl<'a> CmdArgOption<'a> for ArgUrl {
type Value = Url;
fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
// Get the URL
let url = Self::value_raw(matches).expect("missing URL");
// Parse the URL
match parse_host(&url) {
Ok(url) => url,
Err(err) => quit_error(
err.context("failed to parse the given share URL"),
ErrorHints::default(),
),
}
}
}
================================================
FILE: src/cmd/handler.rs
================================================
#[cfg(feature = "infer-command")]
use std::ffi::OsString;
use clap::{App, AppSettings, Arg, ArgMatches};
use super::arg::{ArgApi, ArgBasicAuth, CmdArg};
#[cfg(feature = "history")]
use super::matcher::HistoryMatcher;
use super::matcher::{
DebugMatcher, DeleteMatcher, DownloadMatcher, ExistsMatcher, GenerateMatcher, InfoMatcher,
Matcher, ParamsMatcher, PasswordMatcher, UploadMatcher, VersionMatcher,
};
#[cfg(feature = "history")]
use super::subcmd::CmdHistory;
use super::subcmd::{
CmdDebug, CmdDelete, CmdDownload, CmdExists, CmdGenerate, CmdInfo, CmdParams, CmdPassword,
CmdUpload, CmdVersion,
};
#[cfg(feature = "infer-command")]
use crate::config::INFER_COMMANDS;
use crate::config::{CLIENT_TIMEOUT, CLIENT_TRANSFER_TIMEOUT};
#[cfg(feature = "history")]
use crate::util::app_history_file_path_string;
#[cfg(feature = "infer-command")]
use crate::util::bin_name;
use crate::util::parse_duration;
#[cfg(feature = "history")]
lazy_static! {
/// The default history file
static ref DEFAULT_HISTORY_FILE: String = app_history_file_path_string();
}
lazy_static! {
/// The default client timeout in seconds as a string
static ref DEFAULT_TIMEOUT: String = format!("{}", CLIENT_TIMEOUT);
/// The default client transfer timeout in seconds as a string
static ref DEFAULT_TRANSFER_TIMEOUT: String = format!("{}", CLIENT_TRANSFER_TIMEOUT);
/// The about notice in command output.
static ref APP_ABOUT: String = format!(
"{}\n\n\
The default public Send host is provided by Tim Visee, @timvisee.\n\
Please consider to donate and help keep it running: https://vis.ee/donate\
",
crate_description!(),
);
}
/// CLI argument handler.
pub struct Handler<'a> {
/// The CLI matches.
matches: ArgMatches<'a>,
}
impl<'a: 'b, 'b> Handler<'a> {
/// Build the application CLI definition.
pub fn build() -> App<'a, 'b> {
// Build the CLI application definition
let app = App::new(crate_name!())
.version(crate_version!())
.author(crate_authors!())
.about(APP_ABOUT.as_str())
.after_help("This application is not affiliated with Firefox or Mozilla.")
.global_setting(AppSettings::GlobalVersion)
.global_setting(AppSettings::VersionlessSubcommands)
// TODO: enable below command when it doesn't break `p` anymore.
// .global_setting(AppSettings::InferSubcommands)
.arg(
Arg::with_name("force")
.long("force")
.short("f")
.global(true)
.help("Force the action, ignore warnings"),
)
.arg(
Arg::with_name("no-interact")
.long("no-interact")
.short("I")
.alias("no-interactive")
.alias("non-interactive")
.global(true)
.help("Not interactive, do not prompt"),
)
.arg(
Arg::with_name("yes")
.long("yes")
.short("y")
.alias("assume-yes")
.global(true)
.help("Assume yes for prompts"),
)
.arg(
Arg::with_name("timeout")
.long("timeout")
.short("t")
.alias("time")
.global(true)
.value_name("SECONDS")
.help("Request timeout (0 to disable)")
.default_value(&DEFAULT_TIMEOUT)
.hide_default_value(true)
.env("FFSEND_TIMEOUT")
.hide_env_values(true)
.validator(|arg| {
parse_duration(&arg).map(drop).map_err(|_| {
String::from(
"Timeout time must be a positive number of seconds, or 0 to disable."
)
})
}),
)
.arg(
Arg::with_name("transfer-timeout")
.long("transfer-timeout")
.short("T")
.alias("trans-time")
.alias("trans-timeout")
.alias("transfer-time")
.alias("time-trans")
.alias("timeout-trans")
.alias("time-transfer")
.global(true)
.value_name("SECONDS")
.help("Transfer timeout (0 to disable)")
.default_value(&DEFAULT_TRANSFER_TIMEOUT)
.hide_default_value(true)
.env("FFSEND_TRANSFER_TIMEOUT")
.hide_env_values(true)
.validator(|arg| {
parse_duration(&arg).map(drop).map_err(|_| {
String::from(
"Timeout time must be a positive number of seconds, or 0 to disable."
)
})
}),
)
.arg(
Arg::with_name("quiet")
.long("quiet")
.short("q")
.global(true)
.help("Produce output suitable for logging and automation"),
)
.arg(
Arg::with_name("verbose")
.long("verbose")
.short("v")
.multiple(true)
.global(true)
.help("Enable verbose information and logging"),
)
.arg(ArgApi::build())
.arg(ArgBasicAuth::build())
.subcommand(CmdDebug::build())
.subcommand(CmdDelete::build())
.subcommand(CmdDownload::build().display_order(2))
.subcommand(CmdExists::build())
.subcommand(CmdGenerate::build())
.subcommand(CmdInfo::build())
.subcommand(CmdParams::build())
.subcommand(CmdPassword::build())
.subcommand(CmdUpload::build().display_order(1))
.subcommand(CmdVersion::build());
// With history support, a flag for the history file and incognito mode
#[cfg(feature = "history")]
let app = app
.arg(
Arg::with_name("history")
.long("history")
.short("H")
.value_name("FILE")
.global(true)
.help("Use the specified history file")
.default_value(&DEFAULT_HISTORY_FILE)
.hide_default_value(true)
.env("FFSEND_HISTORY")
.hide_env_values(true),
)
.arg(
Arg::with_name("incognito")
.long("incognito")
.short("i")
.alias("incog")
.alias("private")
.alias("priv")
.global(true)
.help("Don't update local history for actions"),
)
.subcommand(CmdHistory::build());
// Disable color usage if compiled without color support
#[cfg(feature = "no-color")]
let app = app.global_setting(AppSettings::ColorNever);
app
}
/// Parse CLI arguments.
pub fn parse() -> Handler<'a> {
// Obtain the program arguments
#[allow(unused_mut)]
let mut args: Vec<_> = ::std::env::args_os().collect();
// Infer subcommand based on binary name
#[cfg(feature = "infer-command")]
Self::infer_subcommand(&mut args);
// Build the application CLI definition, get the matches
Handler {
matches: Handler::build().get_matches_from(args),
}
}
/// Infer subcommand when the binary has a predefined name,
/// modifying the given program arguments.
///
/// If no subcommand could be inferred, the `args` list leaves unchanged.
/// See `crate::config::INFER_COMMANDS` for a list of commands.
///
/// When the `ffsend` binary is called with such a name, the corresponding subcommand is
/// automatically inserted as argument. This also works when calling binaries through symbolic
/// or hard links.
#[cfg(feature = "infer-command")]
fn infer_subcommand(args: &mut Vec) {
// Get the name of the called binary
let name = bin_name();
// Infer subcommands
for (bin, subcmd) in INFER_COMMANDS.iter() {
if &name == bin {
args.insert(1, subcmd.into());
break;
}
}
}
/// Get the raw matches.
pub fn matches(&'a self) -> &'a ArgMatches {
&self.matches
}
/// Get the debug sub command, if matched.
pub fn debug(&'a self) -> Option {
DebugMatcher::with(&self.matches)
}
/// Get the delete sub command, if matched.
pub fn delete(&'a self) -> Option {
DeleteMatcher::with(&self.matches)
}
/// Get the download sub command, if matched.
pub fn download(&'a self) -> Option {
DownloadMatcher::with(&self.matches)
}
/// Get the exists sub command, if matched.
pub fn exists(&'a self) -> Option {
ExistsMatcher::with(&self.matches)
}
/// Get the generate sub command, if matched.
pub fn generate(&'a self) -> Option {
GenerateMatcher::with(&self.matches)
}
/// Get the history sub command, if matched.
#[cfg(feature = "history")]
pub fn history(&'a self) -> Option {
HistoryMatcher::with(&self.matches)
}
/// Get the info matcher, if that subcommand is entered.
pub fn info(&'a self) -> Option {
InfoMatcher::with(&self.matches)
}
/// Get the parameters sub command, if matched.
pub fn params(&'a self) -> Option {
ParamsMatcher::with(&self.matches)
}
/// Get the password sub command, if matched.
pub fn password(&'a self) -> Option {
PasswordMatcher::with(&self.matches)
}
/// Get the upload sub command, if matched.
pub fn upload(&'a self) -> Option {
UploadMatcher::with(&self.matches)
}
/// Get the version sub command, if matched.
pub fn version(&'a self) -> Option {
VersionMatcher::with(&self.matches)
}
}
================================================
FILE: src/cmd/matcher/debug.rs
================================================
use clap::ArgMatches;
use ffsend_api::url::Url;
use super::Matcher;
use crate::cmd::arg::{ArgHost, CmdArgOption};
/// The debug command matcher.
pub struct DebugMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> DebugMatcher<'a> {
/// Get the host to upload to.
///
/// This method parses the host into an `Url`.
/// If the given host is invalid,
/// the program will quit with an error message.
pub fn host(&'a self) -> Url {
ArgHost::value(self.matches)
}
}
impl<'a> Matcher<'a> for DebugMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("debug")
.map(|matches| DebugMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/delete.rs
================================================
use clap::ArgMatches;
use ffsend_api::url::Url;
use super::Matcher;
use crate::cmd::arg::{ArgOwner, ArgUrl, CmdArgOption};
/// The delete command matcher.
pub struct DeleteMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> DeleteMatcher<'a> {
/// Get the file share URL.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn url(&'a self) -> Url {
ArgUrl::value(self.matches)
}
/// Get the owner token.
pub fn owner(&'a self) -> Option {
// TODO: just return a string reference here?
ArgOwner::value(self.matches).map(|token| token.to_owned())
}
}
impl<'a> Matcher<'a> for DeleteMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("delete")
.map(|matches| DeleteMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/download.rs
================================================
use std::path::PathBuf;
use clap::ArgMatches;
use ffsend_api::url::Url;
use super::Matcher;
use crate::cmd::arg::{ArgPassword, ArgUrl, CmdArgOption};
#[cfg(feature = "archive")]
use crate::util::env_var_present;
/// The download command matcher.
pub struct DownloadMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> DownloadMatcher<'a> {
/// Get the file share URL.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn url(&'a self) -> Url {
ArgUrl::value(self.matches)
}
/// Guess the file share host, based on the file share URL.
///
/// See `Self::url`.
pub fn guess_host(&'a self, url: Option) -> Url {
let mut url = url.unwrap_or(self.url());
url.set_path("");
url.set_query(None);
url.set_fragment(None);
url
}
/// Get the password.
/// `None` is returned if no password was specified.
pub fn password(&'a self) -> Option {
ArgPassword::value(self.matches)
}
/// The target file or directory to download the file to.
/// If a directory is given, the file name of the original uploaded file
/// will be used.
pub fn output(&'a self) -> PathBuf {
self.matches
.value_of("output")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("./"))
}
/// Check whether to extract an archived file.
#[cfg(feature = "archive")]
pub fn extract(&self) -> bool {
self.matches.is_present("extract") || env_var_present("FFSEND_EXTRACT")
}
}
impl<'a> Matcher<'a> for DownloadMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("download")
.map(|matches| DownloadMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/exists.rs
================================================
use ffsend_api::url::Url;
use clap::ArgMatches;
use super::Matcher;
use crate::cmd::arg::{ArgUrl, CmdArgOption};
/// The exists command matcher.
pub struct ExistsMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> ExistsMatcher<'a> {
/// Get the file share URL.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn url(&'a self) -> Url {
ArgUrl::value(self.matches)
}
}
impl<'a> Matcher<'a> for ExistsMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("exists")
.map(|matches| ExistsMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/generate/completions.rs
================================================
use std::path::PathBuf;
use std::str::FromStr;
use clap::{ArgMatches, Shell};
use super::Matcher;
/// The completions completions command matcher.
pub struct CompletionsMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> CompletionsMatcher<'a> {
/// Get the shells to generate completions for.
pub fn shells(&'a self) -> Vec {
// Get the raw list of shells
let raw = self
.matches
.values_of("SHELL")
.expect("no shells were given");
// Parse the list of shell names, deduplicate
let mut shells: Vec<_> = raw
.into_iter()
.map(|name| name.trim().to_lowercase())
.map(|name| {
if name == "all" {
Shell::variants()
.iter()
.map(|name| name.to_string())
.collect()
} else {
vec![name]
}
})
.flatten()
.collect();
shells.sort_unstable();
shells.dedup();
// Parse the shell names
shells
.into_iter()
.map(|name| Shell::from_str(&name).expect("failed to parse shell name"))
.collect()
}
/// The target directory to output the shell completion files to.
pub fn output(&'a self) -> PathBuf {
self.matches
.value_of("output")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("./"))
}
}
impl<'a> Matcher<'a> for CompletionsMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("generate")?
.subcommand_matches("completions")
.map(|matches| CompletionsMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/generate/mod.rs
================================================
pub mod completions;
use clap::ArgMatches;
use super::Matcher;
use completions::CompletionsMatcher;
/// The generate command matcher.
pub struct GenerateMatcher<'a> {
root: &'a ArgMatches<'a>,
_matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> GenerateMatcher<'a> {
/// Get the generate completions sub command, if matched.
pub fn matcher_completions(&'a self) -> Option {
CompletionsMatcher::with(&self.root)
}
}
impl<'a> Matcher<'a> for GenerateMatcher<'a> {
fn with(root: &'a ArgMatches) -> Option {
root.subcommand_matches("generate")
.map(|matches| GenerateMatcher {
root,
_matches: matches,
})
}
}
================================================
FILE: src/cmd/matcher/history.rs
================================================
use clap::ArgMatches;
use failure::Fail;
use ffsend_api::url::Url;
use super::Matcher;
use crate::host::parse_host;
use crate::util::{quit_error, ErrorHints};
/// The history command matcher.
pub struct HistoryMatcher<'a> {
#[allow(unused)]
matches: &'a ArgMatches<'a>,
}
impl<'a> HistoryMatcher<'a> {
/// Check whether to clear all history.
pub fn clear(&self) -> bool {
self.matches.is_present("clear")
}
/// Check whether to remove a given entry from the history.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn rm(&'a self) -> Option {
// Get the URL
let url = self.matches.value_of("rm")?;
// Parse the URL
match parse_host(&url) {
Ok(url) => Some(url),
Err(err) => quit_error(
err.context("failed to parse the given share URL"),
ErrorHints::default(),
),
}
}
}
impl<'a> Matcher<'a> for HistoryMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("history")
.map(|matches| HistoryMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/info.rs
================================================
use ffsend_api::url::Url;
use clap::ArgMatches;
use super::Matcher;
use crate::cmd::arg::{ArgOwner, ArgPassword, ArgUrl, CmdArgOption};
/// The info command matcher.
pub struct InfoMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> InfoMatcher<'a> {
/// Get the file share URL.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn url(&'a self) -> Url {
ArgUrl::value(self.matches)
}
/// Get the owner token.
pub fn owner(&'a self) -> Option {
// TODO: just return a string reference here?
ArgOwner::value(self.matches).map(|token| token.to_owned())
}
/// Get the password.
/// `None` is returned if no password was specified.
pub fn password(&'a self) -> Option {
ArgPassword::value(self.matches)
}
}
impl<'a> Matcher<'a> for InfoMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("info")
.map(|matches| InfoMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/main.rs
================================================
#[cfg(feature = "history")]
use std::path::PathBuf;
use clap::ArgMatches;
use ffsend_api::api::DesiredVersion;
use super::Matcher;
use crate::cmd::arg::{ArgApi, ArgBasicAuth, CmdArgOption};
use crate::util::{env_var_present, parse_duration};
#[cfg(feature = "history")]
use crate::util::{quit_error_msg, ErrorHintsBuilder};
/// The main command matcher.
pub struct MainMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> MainMatcher<'a> {
/// Check whether to force.
pub fn force(&self) -> bool {
self.matches.is_present("force") || env_var_present("FFSEND_FORCE")
}
/// Check whether to use no-interact mode.
pub fn no_interact(&self) -> bool {
self.matches.is_present("no-interact") || env_var_present("FFSEND_NO_INTERACT")
}
/// Check whether to assume yes.
pub fn assume_yes(&self) -> bool {
self.matches.is_present("yes") || env_var_present("FFSEND_YES")
}
/// Get the desired API version to use.
pub fn api(&'a self) -> DesiredVersion {
ArgApi::value(self.matches)
}
/// Get basic HTTP authentication credentials to use.
pub fn basic_auth(&'a self) -> Option<(String, Option)> {
ArgBasicAuth::value(self.matches)
}
/// Get the history file to use.
#[cfg(feature = "history")]
pub fn history(&self) -> PathBuf {
// Get the path
let path = self.matches.value_of("history").map(PathBuf::from);
// Ensure the path is correct
match path {
Some(path) => path,
None => quit_error_msg(
"history file path not set",
ErrorHintsBuilder::default()
.history(true)
.verbose(false)
.build()
.unwrap(),
),
}
}
/// Get the timeout in seconds
pub fn timeout(&self) -> u64 {
self.matches
.value_of("timeout")
.and_then(|arg| parse_duration(arg).ok())
.expect("invalid timeout value") as u64
}
/// Get the transfer timeout in seconds
pub fn transfer_timeout(&self) -> u64 {
self.matches
.value_of("transfer-timeout")
.and_then(|arg| parse_duration(arg).ok())
.expect("invalid transfer-timeout value") as u64
}
/// Check whether we are incognito from the file history.
#[cfg(feature = "history")]
pub fn incognito(&self) -> bool {
self.matches.is_present("incognito") || env_var_present("FFSEND_INCOGNITO")
}
/// Check whether quiet mode is used.
pub fn quiet(&self) -> bool {
!self.verbose() && (self.matches.is_present("quiet") || env_var_present("FFSEND_QUIET"))
}
/// Check whether verbose mode is used.
pub fn verbose(&self) -> bool {
self.matches.is_present("verbose") || env_var_present("FFSEND_VERBOSE")
}
}
impl<'a> Matcher<'a> for MainMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
Some(MainMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/mod.rs
================================================
pub mod debug;
pub mod delete;
pub mod download;
pub mod exists;
pub mod generate;
#[cfg(feature = "history")]
pub mod history;
pub mod info;
pub mod main;
pub mod params;
pub mod password;
pub mod upload;
pub mod version;
// Re-export to matcher module
pub use self::debug::DebugMatcher;
pub use self::delete::DeleteMatcher;
pub use self::download::DownloadMatcher;
pub use self::exists::ExistsMatcher;
pub use self::generate::GenerateMatcher;
#[cfg(feature = "history")]
pub use self::history::HistoryMatcher;
pub use self::info::InfoMatcher;
pub use self::main::MainMatcher;
pub use self::params::ParamsMatcher;
pub use self::password::PasswordMatcher;
pub use self::upload::{CopyMode, UploadMatcher};
pub use self::version::VersionMatcher;
use clap::ArgMatches;
pub trait Matcher<'a>: Sized {
// Construct a new matcher instance from these argument matches.
fn with(matches: &'a ArgMatches) -> Option;
}
================================================
FILE: src/cmd/matcher/params.rs
================================================
use clap::ArgMatches;
use ffsend_api::api::Version as ApiVersion;
use ffsend_api::url::Url;
use super::Matcher;
use crate::cmd::{
arg::{ArgDownloadLimit, ArgOwner, ArgUrl, CmdArgOption},
matcher::MainMatcher,
};
/// The params command matcher.
pub struct ParamsMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> ParamsMatcher<'a> {
/// Get the file share URL.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn url(&'a self) -> Url {
ArgUrl::value(self.matches)
}
/// Get the owner token.
pub fn owner(&'a self) -> Option {
// TODO: just return a string reference here?
ArgOwner::value(self.matches).map(|token| token.to_owned())
}
/// Get the download limit.
///
/// If the download limit was the default, `None` is returned to not
/// explicitly set it.
pub fn download_limit(
&'a self,
main_matcher: &MainMatcher,
api_version: ApiVersion,
auth: bool,
) -> Option {
ArgDownloadLimit::value_checked(self.matches, main_matcher, api_version, auth)
}
}
impl<'a> Matcher<'a> for ParamsMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("parameters")
.map(|matches| ParamsMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/password.rs
================================================
use clap::ArgMatches;
use ffsend_api::url::Url;
use rpassword::prompt_password_stderr;
use crate::cmd::arg::{ArgGenPassphrase, ArgOwner, ArgPassword, ArgUrl, CmdArgFlag, CmdArgOption};
use crate::cmd::matcher::{MainMatcher, Matcher};
use crate::util::check_empty_password;
/// The password command matcher.
pub struct PasswordMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> PasswordMatcher<'a> {
/// Get the file share URL.
///
/// This method parses the URL into an `Url`.
/// If the given URL is invalid,
/// the program will quit with an error message.
pub fn url(&'a self) -> Url {
ArgUrl::value(self.matches)
}
/// Get the owner token.
pub fn owner(&'a self) -> Option {
// TODO: just return a string reference here?
ArgOwner::value(self.matches).map(|token| token.to_owned())
}
/// Get the password.
///
/// The password is returned in the following format:
/// `(password, generated)`
pub fn password(&'a self) -> (String, bool) {
// Generate a passphrase if requested
if ArgGenPassphrase::is_present(self.matches) {
return (ArgGenPassphrase::gen_passphrase(), true);
}
// Get the password, or prompt for it
let password = match ArgPassword::value(self.matches) {
Some(password) => password,
None => {
// Prompt for the password
// TODO: don't unwrap/expect
// TODO: create utility function for this
prompt_password_stderr("New password: ")
.expect("failed to read password from stdin")
}
};
// Create a main matcher
let matcher_main = MainMatcher::with(self.matches).unwrap();
// Check for empty passwords
check_empty_password(&password, &matcher_main);
(password, false)
}
}
impl<'a> Matcher<'a> for PasswordMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("password")
.map(|matches| PasswordMatcher { matches })
}
}
================================================
FILE: src/cmd/matcher/upload.rs
================================================
use clap::ArgMatches;
use ffsend_api::{api::Version as ApiVersion, config, url::Url};
use super::Matcher;
use crate::cmd::{
arg::{
ArgDownloadLimit, ArgExpiryTime, ArgGenPassphrase, ArgHost, ArgPassword, CmdArgFlag,
CmdArgOption,
},
matcher::MainMatcher,
};
use crate::util::{bin_name, env_var_present, quit_error_msg, ErrorHintsBuilder};
/// The upload command matcher.
pub struct UploadMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> UploadMatcher<'a> {
/// Get the selected file to upload.
// TODO: maybe return a file or path instance here
pub fn files(&'a self) -> Vec<&'a str> {
self.matches
.values_of("FILE")
.expect("no file specified to upload")
.collect()
}
/// The the name to use for the uploaded file.
/// If no custom name is given, none is returned.
// TODO: validate custom names, no path separators
// TODO: only allow extension renaming with force flag
pub fn name(&'a self) -> Option<&'a str> {
// Get the chosen file name
let name = self.matches.value_of("name")?;
// The file name must not be empty
// TODO: allow to force an empty name here, and process empty names on downloading
if name.trim().is_empty() {
quit_error_msg(
"the file name must not be empty",
ErrorHintsBuilder::default()
.force(false)
.verbose(false)
.build()
.unwrap(),
);
}
Some(name)
}
/// Get the host to upload to.
///
/// This method parses the host into an `Url`.
/// If the given host is invalid,
/// the program will quit with an error message.
pub fn host(&'a self) -> Url {
ArgHost::value(self.matches)
}
/// Get the password.
/// A generated passphrase will be returned if the user requested so,
/// otherwise the specified password is returned.
/// If no password was set, `None` is returned instead.
///
/// The password is returned in the following format:
/// `(password, generated)`
pub fn password(&'a self) -> Option<(String, bool)> {
// Generate a passphrase if requested
if ArgGenPassphrase::is_present(self.matches) {
return Some((ArgGenPassphrase::gen_passphrase(), true));
}
// Use a specified password or use nothing
ArgPassword::value(self.matches).map(|password| (password, false))
}
/// Get the download limit.
///
/// If the download limit was the default, `None` is returned to not
/// explicitly set it.
pub fn download_limit(
&'a self,
main_matcher: &MainMatcher,
api_version: ApiVersion,
auth: bool,
) -> Option {
ArgDownloadLimit::value_checked(self.matches, main_matcher, api_version, auth).and_then(
|d| match d {
d if d == config::downloads_default(api_version, auth) => None,
d => Some(d),
},
)
}
/// Get the expiry time in seconds.
///
/// If the expiry time was not set, `None` is returned.
pub fn expiry_time(
&'a self,
main_matcher: &MainMatcher,
api_version: ApiVersion,
auth: bool,
) -> Option {
ArgExpiryTime::value_checked(self.matches, main_matcher, api_version, auth)
}
/// Check whether to archive the file to upload.
#[cfg(feature = "archive")]
pub fn archive(&self) -> bool {
self.matches.is_present("archive") || env_var_present("FFSEND_ARCHIVE")
}
/// Check whether to open the file URL in the user's browser.
pub fn open(&self) -> bool {
self.matches.is_present("open") || env_var_present("FFSEND_OPEN")
}
/// Check whether to to delete local files after uploading.
pub fn delete(&self) -> bool {
self.matches.is_present("delete")
}
/// Check whether to copy the file URL in the user's clipboard, get the copy mode.
#[cfg(feature = "clipboard")]
pub fn copy(&self) -> Option {
// Get the options
let copy = self.matches.is_present("copy") || env_var_present("FFSEND_COPY");
let copy_cmd = self.matches.is_present("copy-cmd") || env_var_present("FFSEND_COPY_CMD");
// Return the corresponding copy mode
if copy_cmd {
Some(CopyMode::DownloadCmd)
} else if copy {
Some(CopyMode::Url)
} else {
None
}
}
/// Check whether to shorten a share URL
#[cfg(feature = "urlshorten")]
pub fn shorten(&self) -> bool {
self.matches.is_present("shorten")
}
/// Check whether to print a QR code for the share URL.
#[cfg(feature = "qrcode")]
pub fn qrcode(&self) -> bool {
self.matches.is_present("qrcode")
}
}
impl<'a> Matcher<'a> for UploadMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("upload")
.map(|matches| UploadMatcher { matches })
}
}
/// The copy mode.
#[derive(Debug, Copy, Clone)]
pub enum CopyMode {
/// Copy the public share link.
Url,
/// Copy an ffsend download command.
DownloadCmd,
}
impl CopyMode {
/// Build the string to copy, based on the given `url` and current mode.
pub fn build(&self, url: &str) -> String {
match self {
CopyMode::Url => url.into(),
CopyMode::DownloadCmd => format!("{} download {}", bin_name(), url),
}
}
}
================================================
FILE: src/cmd/matcher/version.rs
================================================
use ffsend_api::url::Url;
use clap::ArgMatches;
use super::Matcher;
use crate::cmd::arg::{ArgHost, CmdArgOption};
/// The version command matcher.
pub struct VersionMatcher<'a> {
matches: &'a ArgMatches<'a>,
}
impl<'a: 'b, 'b> VersionMatcher<'a> {
/// Get the host to probe.
///
/// This method parses the host into an `Url`.
/// If the given host is invalid,
/// the program will quit with an error message.
pub fn host(&'a self) -> Url {
ArgHost::value(self.matches)
}
}
impl<'a> Matcher<'a> for VersionMatcher<'a> {
fn with(matches: &'a ArgMatches) -> Option {
matches
.subcommand_matches("version")
.map(|matches| VersionMatcher { matches })
}
}
================================================
FILE: src/cmd/mod.rs
================================================
pub mod arg;
pub mod handler;
pub mod matcher;
pub mod subcmd;
// Reexport modules
pub use self::handler::Handler;
================================================
FILE: src/cmd/subcmd/debug.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgHost, CmdArg};
/// The debug command definition.
pub struct CmdDebug;
impl CmdDebug {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("debug")
.about("View debug information")
.visible_alias("dbg")
.arg(ArgHost::build().hidden(true))
}
}
================================================
FILE: src/cmd/subcmd/delete.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgOwner, ArgUrl, CmdArg};
/// The delete command definition.
pub struct CmdDelete;
impl CmdDelete {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("delete")
.about("Delete a shared file")
.visible_alias("del")
.visible_alias("rm")
.arg(ArgUrl::build())
.arg(ArgOwner::build())
}
}
================================================
FILE: src/cmd/subcmd/download.rs
================================================
use clap::{App, Arg, SubCommand};
use crate::cmd::arg::{ArgPassword, ArgUrl, CmdArg};
/// The download command definition.
pub struct CmdDownload;
impl CmdDownload {
pub fn build<'a, 'b>() -> App<'a, 'b> {
// Build the subcommand
#[allow(unused_mut)]
let mut cmd = SubCommand::with_name("download")
.about("Download files")
.visible_alias("d")
.visible_alias("down")
.arg(ArgUrl::build())
.arg(ArgPassword::build())
.arg(
Arg::with_name("output")
.long("output")
.short("o")
.alias("output-file")
.alias("out")
.alias("file")
.value_name("PATH")
.help("Output file or directory"),
);
// Optional archive support
#[cfg(feature = "archive")]
{
cmd = cmd.arg(
Arg::with_name("extract")
.long("extract")
.short("e")
.alias("archive")
.alias("arch")
.alias("a")
.help("Extract an archived file"),
)
}
cmd
}
}
================================================
FILE: src/cmd/subcmd/exists.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgUrl, CmdArg};
/// The exists command definition.
pub struct CmdExists;
impl CmdExists {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("exists")
.about("Check whether a remote file exists")
.visible_alias("e")
.alias("exist")
.arg(ArgUrl::build())
}
}
================================================
FILE: src/cmd/subcmd/generate/completions.rs
================================================
use clap::{App, Arg, Shell, SubCommand};
/// The generate completions command definition.
pub struct CmdCompletions;
impl CmdCompletions {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("completions")
.about("Shell completions")
.alias("completion")
.alias("complete")
.arg(
Arg::with_name("SHELL")
.help("Shell type to generate completions for")
.required(true)
.multiple(true)
.takes_value(true)
.possible_value("all")
.possible_values(&Shell::variants())
.case_insensitive(true),
)
.arg(
Arg::with_name("output")
.long("output")
.short("o")
.alias("output-dir")
.alias("out")
.alias("dir")
.value_name("DIR")
.help("Shell completion files output directory"),
)
}
}
================================================
FILE: src/cmd/subcmd/generate/mod.rs
================================================
pub mod completions;
use clap::{App, AppSettings, SubCommand};
use completions::CmdCompletions;
/// The generate command definition.
pub struct CmdGenerate;
impl CmdGenerate {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("generate")
.about("Generate assets")
.visible_alias("gen")
.setting(AppSettings::SubcommandRequiredElseHelp)
.subcommand(CmdCompletions::build())
}
}
================================================
FILE: src/cmd/subcmd/history.rs
================================================
use clap::{App, Arg, SubCommand};
/// The history command definition.
pub struct CmdHistory;
impl CmdHistory {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("history")
.about("View file history")
.visible_alias("h")
.alias("ls")
.arg(
Arg::with_name("rm")
.long("rm")
.short("R")
.alias("remove")
.value_name("URL")
.help("Remove history entry"),
)
.arg(
Arg::with_name("clear")
.long("clear")
.short("C")
.alias("flush")
.help("Clear all history"),
)
}
}
================================================
FILE: src/cmd/subcmd/info.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgOwner, ArgPassword, ArgUrl, CmdArg};
/// The info command definition.
pub struct CmdInfo;
impl CmdInfo {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("info")
.about("Fetch info about a shared file")
.visible_alias("i")
.alias("information")
.arg(ArgUrl::build())
.arg(ArgOwner::build())
.arg(ArgPassword::build())
}
}
================================================
FILE: src/cmd/subcmd/mod.rs
================================================
pub mod debug;
pub mod delete;
pub mod download;
pub mod exists;
pub mod generate;
#[cfg(feature = "history")]
pub mod history;
pub mod info;
pub mod params;
pub mod password;
pub mod upload;
pub mod version;
// Re-export to cmd module
pub use self::debug::CmdDebug;
pub use self::delete::CmdDelete;
pub use self::download::CmdDownload;
pub use self::exists::CmdExists;
pub use self::generate::CmdGenerate;
#[cfg(feature = "history")]
pub use self::history::CmdHistory;
pub use self::info::CmdInfo;
pub use self::params::CmdParams;
pub use self::password::CmdPassword;
pub use self::upload::CmdUpload;
pub use self::version::CmdVersion;
================================================
FILE: src/cmd/subcmd/params.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgDownloadLimit, ArgOwner, ArgUrl, CmdArg};
/// The params command definition.
pub struct CmdParams;
impl CmdParams {
pub fn build<'a, 'b>() -> App<'a, 'b> {
// Create a list of parameter arguments, of which one is required
let param_args = [ArgDownloadLimit::name()];
SubCommand::with_name("parameters")
.about("Change parameters of a shared file")
.visible_alias("params")
.alias("param")
.alias("parameter")
.arg(ArgUrl::build())
.arg(ArgOwner::build())
.arg(ArgDownloadLimit::build().required_unless_one(¶m_args))
}
}
================================================
FILE: src/cmd/subcmd/password.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgGenPassphrase, ArgOwner, ArgPassword, ArgUrl, CmdArg};
/// The password command definition.
pub struct CmdPassword;
impl CmdPassword {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("password")
.about("Change the password of a shared file")
.visible_alias("pass")
.visible_alias("p")
.arg(ArgUrl::build())
.arg(ArgPassword::build().help("Specify a password, do not prompt"))
.arg(ArgGenPassphrase::build())
.arg(ArgOwner::build())
}
}
================================================
FILE: src/cmd/subcmd/upload.rs
================================================
use clap::{App, Arg, SubCommand};
use crate::cmd::arg::{
ArgDownloadLimit, ArgExpiryTime, ArgGenPassphrase, ArgHost, ArgPassword, CmdArg,
};
/// The upload command definition.
pub struct CmdUpload;
impl CmdUpload {
pub fn build<'a, 'b>() -> App<'a, 'b> {
// Build the subcommand
#[allow(unused_mut)]
let mut cmd = SubCommand::with_name("upload")
.about("Upload files")
.visible_alias("u")
.visible_alias("up")
.arg(
Arg::with_name("FILE")
.help("The file(s) to upload")
.required(true)
.multiple(true),
)
.arg(ArgPassword::build().help("Protect the file with a password"))
.arg(ArgGenPassphrase::build())
.arg(ArgDownloadLimit::build())
.arg(ArgExpiryTime::build())
.arg(ArgHost::build())
.arg(
Arg::with_name("name")
.long("name")
.short("n")
.alias("file")
.alias("f")
.value_name("NAME")
.help("Rename the file being uploaded"),
)
.arg(
Arg::with_name("open")
.long("open")
.short("o")
.help("Open the share link in your browser"),
)
.arg(
Arg::with_name("delete")
.long("delete")
.alias("rm")
.short("D")
.help("Delete local file after upload"),
);
// Optional archive support
#[cfg(feature = "archive")]
{
cmd = cmd.arg(
Arg::with_name("archive")
.long("archive")
.short("a")
.alias("arch")
.help("Archive the upload in a single file"),
)
}
// Optional clipboard support
#[cfg(feature = "clipboard")]
{
cmd = cmd
.arg(
Arg::with_name("copy")
.long("copy")
.short("c")
.help("Copy the share link to your clipboard")
.conflicts_with("copy-cmd"),
)
.arg(
Arg::with_name("copy-cmd")
.long("copy-cmd")
.alias("copy-command")
.short("C")
.help("Copy the ffsend download command to your clipboard")
.conflicts_with("copy"),
);
}
// Optional url shortening support
#[cfg(feature = "urlshorten")]
{
cmd = cmd.arg(
Arg::with_name("shorten")
.long("shorten")
.alias("short")
.alias("url-shorten")
.short("S")
.help("Shorten share URLs with a public service"),
)
}
// Optional qrcode support
#[cfg(feature = "qrcode")]
{
cmd = cmd.arg(
Arg::with_name("qrcode")
.long("qrcode")
.alias("qr")
.short("Q")
.help("Print a QR code for the share URL"),
)
}
cmd
}
}
================================================
FILE: src/cmd/subcmd/version.rs
================================================
use clap::{App, SubCommand};
use crate::cmd::arg::{ArgHost, CmdArg};
/// The version command definition.
pub struct CmdVersion;
impl CmdVersion {
pub fn build<'a, 'b>() -> App<'a, 'b> {
SubCommand::with_name("version")
.about("Determine the Send server version")
.alias("ver")
.visible_alias("v")
.arg(ArgHost::build())
}
}
================================================
FILE: src/config.rs
================================================
#[cfg(feature = "infer-command")]
use std::collections::HashMap;
use ffsend_api::api::{DesiredVersion, Version};
/// The timeout for the Send client for generic requests, `0` to disable.
pub const CLIENT_TIMEOUT: u64 = 30;
/// The timeout for the Send client used to transfer (upload/download) files.
/// Make sure this is big enough, or file uploads will be dropped. `0` to disable.
pub const CLIENT_TRANSFER_TIMEOUT: u64 = 24 * 60 * 60;
/// The default desired version to select for the server API.
pub const API_VERSION_DESIRED_DEFAULT: DesiredVersion = DesiredVersion::Assume(API_VERSION_ASSUME);
/// The default server API version to assume when it could not be determined.
#[cfg(feature = "send3")]
pub const API_VERSION_ASSUME: Version = Version::V3;
#[cfg(not(feature = "send3"))]
pub const API_VERSION_ASSUME: Version = Version::V2;
#[cfg(feature = "infer-command")]
lazy_static! {
/// Hashmap holding binary names to infer subcommands for.
///
/// When the `ffsend` binary is called with such a name, the corresponding subcommand is
/// automatically inserted as argument. This also works when calling binaries through symbolic
/// or hard links.
pub static ref INFER_COMMANDS: HashMap<&'static str, &'static str> = {
let mut m = HashMap::new();
m.insert("ffput", "upload");
m.insert("ffget", "download");
m.insert("ffdel", "delete");
m
};
}
================================================
FILE: src/error.rs
================================================
use ffsend_api::action::delete::Error as DeleteError;
use ffsend_api::action::exists::Error as ExistsError;
use ffsend_api::action::params::Error as ParamsError;
use ffsend_api::action::password::Error as PasswordError;
use ffsend_api::action::version::Error as VersionError;
use ffsend_api::file::remote_file::FileParseError;
use crate::action::download::Error as CliDownloadError;
use crate::action::generate::completions::Error as CliGenerateCompletionsError;
#[cfg(feature = "history")]
use crate::action::history::Error as CliHistoryError;
use crate::action::info::Error as CliInfoError;
use crate::action::upload::Error as CliUploadError;
#[derive(Fail, Debug)]
pub enum Error {
/// An error occurred while invoking an action.
#[fail(display = "")]
Action(#[cause] ActionError),
}
impl From for Error {
fn from(err: CliDownloadError) -> Error {
Error::Action(ActionError::Download(err))
}
}
impl From for Error {
fn from(err: CliInfoError) -> Error {
Error::Action(ActionError::Info(err))
}
}
impl From for Error {
fn from(err: CliUploadError) -> Error {
Error::Action(ActionError::Upload(err))
}
}
impl From for Error {
fn from(err: ActionError) -> Error {
Error::Action(err)
}
}
#[derive(Debug, Fail)]
pub enum ActionError {
/// An error occurred while invoking the delete action.
#[fail(display = "failed to delete the file")]
Delete(#[cause] DeleteError),
/// An error occurred while invoking the download action.
#[fail(display = "failed to download the requested file")]
Download(#[cause] CliDownloadError),
/// An error occurred while invoking the exists action.
#[fail(display = "failed to check whether the file exists")]
Exists(#[cause] ExistsError),
/// An error occurred while generating completions.
#[fail(display = "failed to generate shell completions")]
GenerateCompletions(#[cause] CliGenerateCompletionsError),
/// An error occurred while processing the file history.
#[cfg(feature = "history")]
#[fail(display = "failed to process the history")]
History(#[cause] CliHistoryError),
/// An error occurred while invoking the info action.
#[fail(display = "failed to fetch file info")]
Info(#[cause] CliInfoError),
/// An error occurred while invoking the params action.
#[fail(display = "failed to change the parameters")]
Params(#[cause] ParamsError),
/// An error occurred while invoking the password action.
#[fail(display = "failed to change the password")]
Password(#[cause] PasswordError),
/// An error occurred while invoking the version action.
#[fail(display = "failed to determine server version")]
Version(#[cause] VersionError),
/// An error occurred while invoking the upload action.
#[fail(display = "failed to upload the specified file")]
Upload(#[cause] CliUploadError),
/// Failed to parse a share URL, it was invalid.
/// This error is not related to a specific action.
#[fail(display = "invalid share URL")]
InvalidUrl(#[cause] FileParseError),
}
impl From for ActionError {
fn from(err: DeleteError) -> ActionError {
ActionError::Delete(err)
}
}
impl From for ActionError {
fn from(err: ExistsError) -> ActionError {
ActionError::Exists(err)
}
}
impl From for ActionError {
fn from(err: CliGenerateCompletionsError) -> ActionError {
ActionError::GenerateCompletions(err)
}
}
#[cfg(feature = "history")]
impl From for ActionError {
fn from(err: CliHistoryError) -> ActionError {
ActionError::History(err)
}
}
impl From for ActionError {
fn from(err: ParamsError) -> ActionError {
ActionError::Params(err)
}
}
impl From for ActionError {
fn from(err: PasswordError) -> ActionError {
ActionError::Password(err)
}
}
impl From for ActionError {
fn from(err: VersionError) -> ActionError {
ActionError::Version(err)
}
}
impl From for ActionError {
fn from(err: FileParseError) -> ActionError {
ActionError::InvalidUrl(err)
}
}
================================================
FILE: src/history.rs
================================================
use std::fs;
use std::io::Error as IoError;
use std::path::PathBuf;
use failure::Fail;
use ffsend_api::{
file::remote_file::{FileParseError, RemoteFile},
url::Url,
};
use toml::{de::Error as DeError, ser::Error as SerError};
use version_compare::Cmp;
use crate::util::{print_error, print_warning};
/// The minimum supported history file version.
const VERSION_MIN: &str = "0.0.1";
/// The maximum supported history file version.
const VERSION_MAX: &str = crate_version!();
#[derive(Serialize, Deserialize)]
pub struct History {
/// The application version the history file was built with.
/// Used for compatibility checking.
version: Option,
/// The file history.
files: Vec,
/// Whether the list of files has changed.
#[serde(skip)]
changed: bool,
/// An optional path to automatically save the history to.
#[serde(skip)]
autosave: Option,
}
impl History {
/// Construct a new history.
/// A path may be given to automatically save the history to once changed.
pub fn new(autosave: Option) -> Self {
let mut history = History::default();
history.autosave = autosave;
history
}
/// Load the history from the given file.
pub fn load(path: PathBuf) -> Result {
// Read the file to a string
let data = fs::read_to_string(&path)?;
// Parse the data, set the autosave path
let mut history: Self = toml::from_str(&data)?;
history.autosave = Some(path);
// Make sure the file version is supported
if history.version.is_none() {
print_warning("History file has no version, ignoring");
history.version = Some(crate_version!().into());
} else {
// Get the version number from the file
let version = history.version.as_ref().unwrap();
if let Ok(true) = version_compare::compare_to(version, VERSION_MIN, Cmp::Lt) {
print_warning("history file version is too old, ignoring");
} else if let Ok(true) = version_compare::compare_to(version, VERSION_MAX, Cmp::Gt) {
print_warning("history file has an unknown version, ignoring");
}
}
// Garbage collect
history.gc();
Ok(history)
}
/// Load the history from the given file.
/// If the file doesn't exist, create a new empty history instance.
///
/// Autosaving will be enabled, and will save to the given file path.
pub fn load_or_new(file: PathBuf) -> Result {
if file.is_file() {
Self::load(file)
} else {
Ok(Self::new(Some(file)))
}
}
/// Save the history to the internal autosave file.
pub fn save(&mut self) -> Result<(), SaveError> {
// Garbage collect
self.gc();
// Get the path
let path = self.autosave.as_ref().ok_or(SaveError::NoPath)?;
// If we have no files, remove the history file if it exists
if self.files.is_empty() {
if path.is_file() {
fs::remove_file(&path).map_err(SaveError::Delete)?;
}
return Ok(());
}
// Ensure the file parent directories are available
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)?;
}
// Set file permissions on unix based systems
#[cfg(unix)]
{
use std::fs::Permissions;
use std::os::unix::fs::PermissionsExt;
if !path.exists() {
let file = fs::File::create(path).map_err(SaveError::Write)?;
// Set Read/Write permissions for the user
file.set_permissions(Permissions::from_mode(0o600))
.map_err(SaveError::SetPermissions)?;
}
}
// Build the data and write to a file
let data = toml::to_string(self)?;
fs::write(&path, data)?;
// There are no new changes, set the flag
self.changed = false;
Ok(())
}
/// Add the given remote file to the history.
/// If a file with the same ID as the given file exists,
/// the files are merged, see `RemoteFile::merge()`.
///
/// If `overwrite` is set to true, the given file will overwrite
/// properties on the existing file.
pub fn add(&mut self, file: RemoteFile, overwrite: bool) {
// Merge any existing file with the same ID
{
// Find anything to merge
let merge_info: Vec = self
.files
.iter_mut()
.filter(|f| f.id() == file.id())
.map(|ref mut f| f.merge(&file, overwrite))
.collect();
let merged = !merge_info.is_empty();
let changed = merge_info.iter().any(|i| *i);
// Return if merged, update the changed state
if merged {
if changed {
self.changed = true;
}
return;
}
}
// Add the file to the list
self.files.push(file);
self.changed = true;
}
/// Remove a file, matched by it's file ID.
///
/// If any file was removed, true is returned.
pub fn remove(&mut self, id: &str) -> bool {
// Get the indices of files that have expired
let expired_indices: Vec = self
.files
.iter()
.enumerate()
.filter(|&(_, f)| f.id() == id)
.map(|(i, _)| i)
.collect();
// Remove these specific files
for i in expired_indices.iter().rev() {
self.files.remove(*i);
}
// Set the changed flag, and return
if expired_indices.is_empty() {
self.changed = true;
}
!expired_indices.is_empty()
}
/// Remove a file by the given URL.
///
/// If any file was removed, true is returned.
pub fn remove_url(&mut self, url: Url) -> Result {
Ok(self.remove(RemoteFile::parse_url(url, None)?.id()))
}
/// Get all files.
pub fn files(&self) -> &Vec {
&self.files
}
/// Get a file from the history, based on the given remote file.
/// The file ID and host will be compared against all files in this history.
/// If multiple files exist within the history that are equal, only one is returned.
/// If no matching file was found, `None` is returned.
pub fn get_file(&self, file: &RemoteFile) -> Option<&RemoteFile> {
self.files
.iter()
.find(|f| f.id() == file.id() && f.host() == file.host())
}
/// Clear all history.
pub fn clear(&mut self) {
self.changed = !self.files.is_empty();
self.files.clear();
}
/// Garbage collect (remove) all files that have been expired,
/// as defined by their `expire_at` property.
///
/// If the expiry property is None (thus unknown), the file will be kept.
///
/// The number of expired files is returned.
pub fn gc(&mut self) -> usize {
// Get a list of expired files
let expired: Vec = self
.files
.iter()
.filter(|f| f.has_expired())
.cloned()
.collect();
// Remove the files
for f in &expired {
self.remove(f.id());
}
// Set the changed flag
if !expired.is_empty() {
self.changed = true;
}
// Return the number of expired files
expired.len()
}
}
impl Drop for History {
fn drop(&mut self) {
// Automatically save if enabled and something was changed
if self.autosave.is_some() && self.changed {
// Save and report errors
if let Err(err) = self.save() {
print_error(err.context("failed to auto save history, ignoring"));
}
}
}
}
impl Default for History {
fn default() -> Self {
Self {
version: Some(crate_version!().into()),
files: Vec::new(),
changed: false,
autosave: None,
}
}
}
#[derive(Debug, Fail)]
pub enum Error {
/// An error occurred while loading the history from a file.
#[fail(display = "failed to load history from file")]
Load(#[cause] LoadError),
/// An error occurred while saving the history to a file.
#[fail(display = "failed to save history to file")]
Save(#[cause] SaveError),
}
impl From for Error {
fn from(err: LoadError) -> Self {
Error::Load(err)
}
}
impl From for Error {
fn from(err: SaveError) -> Self {
Error::Save(err)
}
}
#[derive(Debug, Fail)]
pub enum LoadError {
/// Failed to read the file contents from the given file.
#[fail(display = "failed to read from the history file")]
Read(#[cause] IoError),
/// Failed to parse the loaded file.
#[fail(display = "failed to parse the file contents")]
Parse(#[cause] DeError),
}
impl From for LoadError {
fn from(err: IoError) -> Self {
LoadError::Read(err)
}
}
impl From for LoadError {
fn from(err: DeError) -> Self {
LoadError::Parse(err)
}
}
#[derive(Debug, Fail)]
pub enum SaveError {
/// No autosave file path was present, failed to save.
#[fail(display = "no autosave file path specified")]
NoPath,
/// Failed to serialize the history for saving.
#[fail(display = "failed to serialize the history for saving")]
Serialize(#[cause] SerError),
/// Failed to write to the history file.
#[fail(display = "failed to write to the history file")]
Write(#[cause] IoError),
/// Failed to set file permissions to the history file.
#[fail(display = "failed to set permissions to the history file")]
SetPermissions(#[cause] IoError),
/// Failed to delete the history file, which was tried because there
/// are no history items to save.
#[fail(display = "failed to delete history file, because history is empty")]
Delete(#[cause] IoError),
}
impl From for SaveError {
fn from(err: SerError) -> Self {
SaveError::Serialize(err)
}
}
impl From for SaveError {
fn from(err: IoError) -> Self {
SaveError::Write(err)
}
}
================================================
FILE: src/history_tool.rs
================================================
use failure::Fail;
use ffsend_api::file::remote_file::RemoteFile;
use crate::cmd::matcher::MainMatcher;
use crate::history::{Error as HistoryError, History};
use crate::util::print_error;
/// Load the history from the given path, add the given file, and save it
/// again.
///
/// When a file with the same ID already exists, the existing file is
/// merged with this one. If `overwrite` is set to true, this file will
/// overwrite properties in the already existing file when merging.
///
/// If there is no file at the given path, new history will be created.
fn add_error(
matcher_main: &MainMatcher,
file: RemoteFile,
overwrite: bool,
) -> Result<(), HistoryError> {
// Ignore if incognito
if matcher_main.incognito() {
return Ok(());
}
// Load the history, add the file, and save
let mut history = History::load_or_new(matcher_main.history())?;
history.add(file, overwrite);
history.save().map_err(|err| err.into())
}
/// Load the history from the given path, add the given file, and save it
/// again.
/// If there is no file at the given path, new history will be created.
///
/// When a file with the same ID already exists, the existing file is
/// merged with this one. If `overwrite` is set to true, this file will
/// overwrite properties in the already existing file when merging.
///
/// If an error occurred, the error is printed and ignored.
pub fn add(matcher_main: &MainMatcher, file: RemoteFile, overwrite: bool) {
if let Err(err) = add_error(matcher_main, file, overwrite) {
print_error(err.context("failed to add file to local history, ignoring"));
}
}
/// Load the history from the given path, remove the given file by it's
/// ID, and save it again.
/// True is returned if any file was removed.
fn remove_error(matcher_main: &MainMatcher, file: &RemoteFile) -> Result {
// Ignore if incognito
if matcher_main.incognito() {
return Ok(false);
}
// Load the history, remove the file, and save
let mut history = History::load_or_new(matcher_main.history())?;
let removed = history.remove(file.id());
history.save()?;
Ok(removed)
}
/// Load the history from the given path, remove the given file by it's
/// ID, and save it again.
/// True is returned if any file was removed.
pub fn remove(matcher_main: &MainMatcher, file: &RemoteFile) -> bool {
let result = remove_error(matcher_main, file);
let ok = result.is_ok();
if let Err(err) = result {
print_error(err.context("failed to remove file from local history, ignoring"));
}
ok
}
/// Derive the file secret and owner token from the history for the given file.
/// The newly derived properties will be set into the given borrowed remote file.
/// This method may be used to automatically derive the properties for some file actions
/// requiring an owner token or secret, to prevent the user from having to enter it manually.
///
/// If the file already has all properties set,
/// nothing will be derived and `false` is returned.
/// If an error occurred while deriving,
/// the error is printed and `false` is returned.
/// If there was no matching file in the history,
/// and no properties could be derived, `false` is returned.
/// Incognito mode does not have any effect on this method,
/// as it won't ever change the history.
///
/// If any property was successfully derived, `true` is returned.
pub fn derive_file_properties(matcher_main: &MainMatcher, file: &mut RemoteFile) -> bool {
// Return if all properties are already set
if file.has_secret() && file.has_owner_token() {
return false;
}
// Load the history
let history = match History::load_or_new(matcher_main.history()) {
Ok(history) => history,
Err(err) => {
print_error(err.context("failed to derive file properties from history, ignoring"));
return false;
}
};
// Find a matching file, grab and set the owner token if available
match history.get_file(file) {
Some(f) => {
// Set the secret
if f.has_secret() {
file.set_secret(f.secret_raw().clone());
}
// Set the owner token
if f.has_owner_token() {
file.set_owner_token(f.owner_token().cloned());
}
// Return whether any property was derived
f.has_secret() || f.has_owner_token()
}
None => false,
}
}
================================================
FILE: src/host.rs
================================================
use ffsend_api::url::{ParseError, Url};
/// Parse the given host string, into an URL.
pub fn parse_host(host: &str) -> Result {
// Trim
let host = host.trim();
// Make sure a valid scheme is prefixed
if !host.starts_with("https://") && !host.starts_with("http://") {
return Err(HostError::Scheme);
}
// Parse the URL, and map the errors
Url::parse(host).map_err(|err| match err {
ParseError::EmptyHost => HostError::Empty,
ParseError::InvalidPort => HostError::Port,
ParseError::InvalidIpv4Address => HostError::Ipv4,
ParseError::InvalidIpv6Address => HostError::Ipv6,
ParseError::InvalidDomainCharacter => HostError::DomainCharacter,
ParseError::RelativeUrlWithoutBase => HostError::NoBase,
err => HostError::Other(err),
})
}
/// An error that has occurred while parsing a host.
#[derive(Debug, Fail)]
pub enum HostError {
/// The URL scheme is missing or invalid.
#[fail(display = "the URL must have the 'https://' or 'http://' scheme")]
Scheme,
/// The host address is empty.
#[fail(display = "empty host address")]
Empty,
/// The port number is invalid.
#[fail(display = "invalid port")]
Port,
/// The given IPv4 styled address is invalid.
#[fail(display = "invalid IPv4 address in the host")]
Ipv4,
/// The given IPv6 styled address is invalid.
#[fail(display = "invalid IPv6 address in the host")]
Ipv6,
/// The domain contains an invalid character.
#[fail(display = "invalid character in the domain")]
DomainCharacter,
/// The base host is missing from the host URL.
#[fail(display = "missing host in the host URL")]
NoBase,
/// Failed to parse the host URL due to another reason.
#[fail(display = "could not parse host URL")]
Other(#[cause] ParseError),
}
================================================
FILE: src/main.rs
================================================
#[macro_use]
extern crate clap;
#[macro_use]
extern crate derive_builder;
#[macro_use]
extern crate failure;
#[macro_use]
extern crate lazy_static;
#[cfg(feature = "history")]
#[macro_use]
extern crate serde_derive;
mod action;
#[cfg(feature = "archive")]
mod archive;
mod client;
mod cmd;
mod config;
mod error;
#[cfg(feature = "history")]
mod history;
#[cfg(feature = "history")]
mod history_tool;
mod host;
mod progress;
#[cfg(feature = "urlshorten")]
mod urlshorten;
mod util;
use std::process;
use crate::action::debug::Debug;
use crate::action::delete::Delete;
use crate::action::download::Download;
use crate::action::exists::Exists;
use crate::action::generate::Generate;
#[cfg(feature = "history")]
use crate::action::history::History;
use crate::action::info::Info;
use crate::action::params::Params;
use crate::action::password::Password;
use crate::action::upload::Upload;
use crate::action::version::Version;
use crate::cmd::{
matcher::{MainMatcher, Matcher},
Handler,
};
use crate::error::Error;
use crate::util::{bin_name, highlight, quit_error, ErrorHints};
/// Application entrypoint.
fn main() {
// Probe for OpenSSL certificates
openssl_probe::init_ssl_cert_env_vars();
// Parse CLI arguments
let cmd_handler = Handler::parse();
// Invoke the proper action
if let Err(err) = invoke_action(&cmd_handler) {
quit_error(err, ErrorHints::default());
};
}
/// Invoke the proper action based on the CLI input.
///
/// If no proper action is selected, the program will quit with an error
/// message.
fn invoke_action(handler: &Handler) -> Result<(), Error> {
// Match the debug command
if handler.debug().is_some() {
return Debug::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the delete command
if handler.delete().is_some() {
return Delete::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the download command
if handler.download().is_some() {
return Download::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the exists command
if handler.exists().is_some() {
return Exists::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the generate command
if handler.generate().is_some() {
return Generate::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the history command
#[cfg(feature = "history")]
{
if handler.history().is_some() {
return History::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
}
// Match the info command
if handler.info().is_some() {
return Info::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the parameters command
if handler.params().is_some() {
return Params::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the password command
if handler.password().is_some() {
return Password::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the upload command
if handler.upload().is_some() {
return Upload::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Match the version command
if handler.version().is_some() {
return Version::new(handler.matches())
.invoke()
.map_err(|err| err.into());
}
// Get the main matcher
let matcher_main = MainMatcher::with(handler.matches()).unwrap();
// Print the main info and return
if !matcher_main.quiet() {
print_main_info();
}
Ok(())
}
/// Print the main info, shown when no subcommands were supplied.
pub fn print_main_info() -> ! {
// Get the name of the used executable
let bin = bin_name();
// Print the main info
println!("{} {}", crate_name!(), crate_version!());
println!("Usage: {} [FLAGS] ...", bin);
println!();
println!(crate_description!());
println!();
println!("Missing subcommand. Here are the most used:");
println!(" {}", highlight(&format!("{} upload ...", bin)));
println!(" {}", highlight(&format!("{} download ...", bin)));
println!();
println!("To show all subcommands, features and other help:");
println!(" {}", highlight(&format!("{} help [SUBCOMMAND]", bin)));
println!();
println!("The default public Send host is provided by Tim Visee.");
println!("Please consider to donate and help keep it running: https://vis.ee/donate");
process::exit(1)
}
================================================
FILE: src/progress.rs
================================================
use std::io::{stderr, Stderr};
use std::time::Duration;
use ffsend_api::pipe::ProgressReporter;
use pbr::{ProgressBar as Pbr, Units};
/// The refresh rate of the progress bar, in milliseconds.
const PROGRESS_BAR_FPS_MILLIS: u64 = 200;
/// A progress bar reporter.
pub struct ProgressBar<'a> {
progress_bar: Option>,
msg_progress: &'a str,
msg_finish: &'a str,
}
impl<'a> ProgressBar<'a> {
/// Construct a new progress bar, with the given messages.
pub fn new(msg_progress: &'a str, msg_finish: &'a str) -> ProgressBar<'a> {
Self {
progress_bar: None,
msg_progress,
msg_finish,
}
}
/// Construct a new progress bar for uploading.
pub fn new_upload() -> ProgressBar<'a> {
Self::new("Encrypt & Upload ", "Upload complete")
}
/// Construct a new progress bar for downloading.
pub fn new_download() -> ProgressBar<'a> {
Self::new("Download & Decrypt ", "Download complete")
}
}
impl<'a> ProgressReporter for ProgressBar<'a> {
/// Start the progress with the given total.
fn start(&mut self, total: u64) {
// Initialize the progress bar
let mut progress_bar = Pbr::on(stderr(), total);
progress_bar.set_max_refresh_rate(Some(Duration::from_millis(PROGRESS_BAR_FPS_MILLIS)));
progress_bar.set_units(Units::Bytes);
progress_bar.message(self.msg_progress);
self.progress_bar = Some(progress_bar);
}
/// A progress update.
fn progress(&mut self, progress: u64) {
self.progress_bar
.as_mut()
.expect("progress bar not yet instantiated, cannot set progress")
.set(progress);
}
/// Finish the progress.
fn finish(&mut self) {
let progress_bar = self
.progress_bar
.as_mut()
.expect("progress bar not yet instantiated");
#[cfg(not(target_os = "windows"))]
progress_bar.finish_print(self.msg_finish);
#[cfg(target_os = "windows")]
{
progress_bar.finish_println(self.msg_finish);
eprintln!();
}
}
}
================================================
FILE: src/urlshorten.rs
================================================
//! URL shortening mechanics.
use ffsend_api::{
api::request::{ensure_success, ResponseError},
client::Client,
reqwest,
url::{self, Url},
};
use urlshortener::{
providers::{self, Provider},
request::{Method, Request},
};
/// An URL shortening result.
type Result = ::std::result::Result;
/// Shorten the given URL.
pub fn shorten(client: &Client, url: &str) -> Result {
// TODO: allow selecting other shorteners
request(client, providers::request(url, &Provider::IsGd))
}
/// Shorten the given URL.
pub fn shorten_url(client: &Client, url: &Url) -> Result {
Url::parse(&shorten(client, url.as_str())?).map_err(|err| err.into())
}
/// Do the request as given, return the response.
fn request(client: &Client, req: Request) -> Result {
// Start the request builder
let mut builder = match req.method {
Method::Get => client.get(&req.url),
Method::Post => client.post(&req.url),
};
// Define the custom user agent
if let Some(_agent) = req.user_agent.clone() {
// TODO: implement this
// builder.header(header::UserAgent::new(agent.0));
panic!("Custom UserAgent for URL shortener not yet implemented");
}
// Define the custom content type
if let Some(_content_type) = req.content_type {
// TODO: implement this
// match content_type {
// ContentType::Json => builder.header(header::ContentType::json()),
// ContentType::FormUrlEncoded => {
// builder.header(header::ContentType::form_url_encoded())
// }
// };
panic!("Custom UserAgent for URL shortener not yet implemented");
}
// Define the custom body
if let Some(body) = req.body.clone() {
builder = builder.body(body);
}
// Send the request, ensure success
let response = builder.send().map_err(Error::Request)?;
ensure_success(&response)?;
// Respond with the body text
response.text().map_err(Error::Malformed)
}
/// An URL shortening error.
#[derive(Debug, Fail)]
pub enum Error {
/// Failed to send the shortening request.
#[fail(display = "failed to send URL shorten request")]
Request(#[cause] reqwest::Error),
/// The server responded with a bad response.
#[fail(display = "failed to shorten URL, got bad response")]
Response(#[cause] ResponseError),
/// The server responded with a malformed response.
#[fail(display = "failed to shorten URL, got malformed response")]
Malformed(#[cause] reqwest::Error),
/// An error occurred while parsing the shortened URL.
#[fail(display = "failed to shorten URL, could not parse URL")]
Url(#[cause] url::ParseError),
}
impl From for Error {
fn from(err: url::ParseError) -> Self {
Error::Url(err)
}
}
impl From for Error {
fn from(err: ResponseError) -> Self {
Error::Response(err)
}
}
================================================
FILE: src/util.rs
================================================
#[cfg(feature = "clipboard-crate")]
extern crate clip;
#[cfg(feature = "clipboard-bin")]
extern crate which;
use std::borrow::Borrow;
use std::env::{self, current_exe, var_os};
use std::ffi::OsStr;
#[cfg(feature = "clipboard")]
use std::fmt;
use std::fmt::{Debug, Display};
#[cfg(feature = "clipboard-bin")]
use std::io::ErrorKind as IoErrorKind;
use std::io::{self, Read};
use std::io::{stderr, stdin, Error as IoError, Write};
use std::iter;
use std::path::Path;
use std::path::PathBuf;
use std::process::exit;
#[cfg(feature = "clipboard-bin")]
use std::process::{Command, Stdio};
#[cfg(feature = "clipboard-crate")]
use self::clip::{ClipboardContext, ClipboardProvider};
use chrono::Duration;
use colored::*;
#[cfg(feature = "history")]
use directories::ProjectDirs;
use failure::{err_msg, Fail};
#[cfg(feature = "clipboard-crate")]
use failure::{Compat, Error};
use ffsend_api::{
api::request::{ensure_success, ResponseError},
client::Client,
reqwest,
url::Url,
};
use fs2::available_space;
use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
use regex::Regex;
use rpassword::prompt_password_stderr;
#[cfg(feature = "clipboard-bin")]
use which::which;
use crate::cmd::matcher::MainMatcher;
/// Print a success message.
pub fn print_success(msg: &str) {
eprintln!("{}", msg.green());
}
/// Print the given error in a proper format for the user,
/// with it's causes.
pub fn print_error(err: impl Borrow) {
// Report each printable error, count them
let count = err
.borrow()
.causes()
.map(|err| format!("{}", err))
.filter(|err| !err.is_empty())
.enumerate()
.map(|(i, err)| {
if i == 0 {
eprintln!("{} {}", highlight_error("error:"), err);
} else {
eprintln!("{} {}", highlight_error("caused by:"), err);
}
})
.count();
// Fall back to a basic message
if count == 0 {
eprintln!(
"{} {}",
highlight_error("error:"),
"an undefined error occurred"
);
}
}
/// Print the given error message in a proper format for the user,
/// with it's causes.
pub fn print_error_msg(err: S)
where
S: AsRef + Display + Debug + Sync + Send + 'static,
{
print_error(err_msg(err).compat());
}
/// Print a warning.
pub fn print_warning(err: S)
where
S: AsRef + Display + Debug + Sync + Send + 'static,
{
eprintln!("{} {}", highlight_warning("warning:"), err);
}
/// Quit the application regularly.
pub fn quit() -> ! {
exit(0);
}
/// Quit the application with an error code,
/// and print the given error.
pub fn quit_error(err: E, hints: impl Borrow) -> ! {
// Print the error
print_error(err);
// Print error hints
hints.borrow().print();
// Quit
exit(1);
}
/// Quit the application with an error code,
/// and print the given error message.
pub fn quit_error_msg(err: S, hints: impl Borrow) -> !
where
S: AsRef + Display + Debug + Sync + Send + 'static,
{
quit_error(err_msg(err).compat(), hints);
}
/// The error hint configuration.
#[derive(Clone, Builder)]
#[builder(default)]
pub struct ErrorHints {
/// Show about specifying an API version.
api: bool,
/// A list of info messages to print along with the error.
info: Vec,
/// Show about the name option.
name: bool,
/// Show about the password option.
password: bool,
/// Show about the owner option.
owner: bool,
/// Show about the history flag.
#[cfg(feature = "history")]
history: bool,
/// Show about the force flag.
force: bool,
/// Show about the verbose flag.
verbose: bool,
/// Show about the help flag.
help: bool,
}
impl ErrorHints {
/// Check whether any hint should be printed.
pub fn any(&self) -> bool {
// Determine the result
#[allow(unused_mut)]
let mut result =
self.name || self.password || self.owner || self.force || self.verbose || self.help;
// Factor in the history hint when enabled
#[cfg(feature = "history")]
{
result = result || self.history;
}
result
}
/// Print the error hints.
pub fn print(&self) {
// Print info messages
for msg in &self.info {
eprintln!("{} {}", highlight_info("info:"), msg);
}
// Stop if nothing should be printed
if !self.any() {
return;
}
eprint!("\n");
// Print hints
if self.api {
eprintln!(
"Use '{}' to select a server API version",
highlight("--api ")
);
}
if self.name {
eprintln!(
"Use '{}' to specify a file name",
highlight("--name ")
);
}
if self.password {
eprintln!(
"Use '{}' to specify a password",
highlight("--password ")
);
}
if self.owner {
eprintln!(
"Use '{}' to specify an owner token",
highlight("--owner ")
);
}
#[cfg(feature = "history")]
{
if self.history {
eprintln!(
"Use '{}' to specify a history file",
highlight("--history ")
);
}
}
if self.force {
eprintln!("Use '{}' to force", highlight("--force"));
}
if self.verbose {
eprintln!("For detailed errors try '{}'", highlight("--verbose"));
}
if self.help {
eprintln!("For more information try '{}'", highlight("--help"));
}
// Flush
let _ = stderr().flush();
}
}
impl Default for ErrorHints {
fn default() -> Self {
ErrorHints {
api: false,
info: Vec::new(),
name: false,
password: false,
owner: false,
#[cfg(feature = "history")]
history: false,
force: false,
verbose: true,
help: true,
}
}
}
impl ErrorHintsBuilder {
/// Add a single info entry.
pub fn add_info(mut self, info: String) -> Self {
// Initialize the info list
if self.info.is_none() {
self.info = Some(Vec::new());
}
// Add the item to the info list
if let Some(ref mut list) = self.info {
list.push(info);
}
self
}
}
/// Highlight the given text with a color.
pub fn highlight(msg: &str) -> ColoredString {
msg.yellow()
}
/// Highlight the given text with an error color.
pub fn highlight_error(msg: &str) -> ColoredString {
msg.red().bold()
}
/// Highlight the given text with an warning color.
pub fn highlight_warning(msg: &str) -> ColoredString {
highlight(msg).bold()
}
/// Highlight the given text with an info color
pub fn highlight_info(msg: &str) -> ColoredString {
msg.cyan()
}
/// Open the given URL in the users default browser.
/// The browsers exit status is returned.
pub fn open_url(url: impl Borrow) -> Result<(), IoError> {
open_path(url.borrow().as_str())
}
/// Open the given path or URL using the program configured on the system.
/// The program exit status is returned.
pub fn open_path(path: &str) -> Result<(), IoError> {
open::that(path)
}
/// Set the clipboard of the user to the given `content` string.
#[cfg(feature = "clipboard")]
pub fn set_clipboard(content: String) -> Result<(), ClipboardError> {
ClipboardType::select().set(content)
}
/// Clipboard management enum.
///
/// Defines which method of setting the clipboard is used.
/// Invoke `ClipboardType::select()` to select the best variant to use determined at runtime.
///
/// Usually, the `Native` variant is used. However, on Linux system a different variant will be
/// selected which will call a system binary to set the clipboard. This must be done because the
/// native clipboard interface only has a lifetime of the application. This means that the
/// clipboard is instantly cleared as soon as this application quits, which is always immediately.
/// This limitation is due to security reasons as defined by X11. The alternative binaries we set
/// the clipboard with spawn a daemon in the background to keep the clipboard alive until it's
/// flushed.
#[cfg(feature = "clipboard")]
#[derive(Clone, Eq, PartialEq)]
pub enum ClipboardType {
/// Native operating system clipboard.
#[cfg(feature = "clipboard-crate")]
Native,
/// Manage clipboard through `xclip` on Linux.
///
/// May contain a binary path if specified at compile time through the `XCLIP_PATH` variable.
#[cfg(feature = "clipboard-bin")]
Xclip(Option),
/// Manage clipboard through `xsel` on Linux.
///
/// May contain a binary path if specified at compile time through the `XSEL_PATH` variable.
#[cfg(feature = "clipboard-bin")]
Xsel(Option),
}
#[cfg(feature = "clipboard")]
impl ClipboardType {
/// Select the clipboard type to use, depending on the runtime system.
pub fn select() -> Self {
#[cfg(feature = "clipboard-crate")]
{
ClipboardType::Native
}
#[cfg(feature = "clipboard-bin")]
{
if let Some(path) = option_env!("XCLIP_PATH") {
ClipboardType::Xclip(Some(path.to_owned()))
} else if let Some(path) = option_env!("XSEL_PATH") {
ClipboardType::Xsel(Some(path.to_owned()))
} else if which("xclip").is_ok() {
ClipboardType::Xclip(None)
} else if which("xsel").is_ok() {
ClipboardType::Xsel(None)
} else {
// TODO: should we error here instead, as no clipboard binary was found?
ClipboardType::Xclip(None)
}
}
}
/// Set clipboard contents through the selected clipboard type.
pub fn set(&self, content: String) -> Result<(), ClipboardError> {
match self {
#[cfg(feature = "clipboard-crate")]
ClipboardType::Native => Self::native_set(content),
#[cfg(feature = "clipboard-bin")]
ClipboardType::Xclip(path) => Self::xclip_set(path.clone(), &content),
#[cfg(feature = "clipboard-bin")]
ClipboardType::Xsel(path) => Self::xsel_set(path.clone(), &content),
}
}
/// Set the clipboard through a native interface.
///
/// This is used on non-Linux systems.
#[cfg(feature = "clipboard-crate")]
fn native_set(content: String) -> Result<(), ClipboardError> {
ClipboardProvider::new()
.and_then(|mut context: ClipboardContext| context.set_contents(content))
.map_err(|err| format_err!("{}", err).compat())
.map_err(ClipboardError::Native)
}
#[cfg(feature = "clipboard-bin")]
fn xclip_set(path: Option, content: &str) -> Result<(), ClipboardError> {
Self::sys_cmd_set(
"xclip",
Command::new(path.unwrap_or_else(|| "xclip".into()))
.arg("-sel")
.arg("clip"),
content,
)
}
#[cfg(feature = "clipboard-bin")]
fn xsel_set(path: Option, content: &str) -> Result<(), ClipboardError> {
Self::sys_cmd_set(
"xsel",
Command::new(path.unwrap_or_else(|| "xsel".into())).arg("--clipboard"),
content,
)
}
#[cfg(feature = "clipboard-bin")]
fn sys_cmd_set(
bin: &'static str,
command: &mut Command,
content: &str,
) -> Result<(), ClipboardError> {
// Spawn the command process for setting the clipboard
let mut process = match command.stdin(Stdio::piped()).stdout(Stdio::null()).spawn() {
Ok(process) => process,
Err(err) => {
return Err(match err.kind() {
IoErrorKind::NotFound => ClipboardError::NoBinary,
_ => ClipboardError::BinaryIo(bin, err),
});
}
};
// Write the contents to the xclip process
process
.stdin
.as_mut()
.unwrap()
.write_all(content.as_bytes())
.map_err(|err| ClipboardError::BinaryIo(bin, err))?;
// Wait for xclip to exit
let status = process
.wait()
.map_err(|err| ClipboardError::BinaryIo(bin, err))?;
if !status.success() {
return Err(ClipboardError::BinaryStatus(
bin,
status.code().unwrap_or(0),
));
}
Ok(())
}
}
#[cfg(feature = "clipboard")]
impl fmt::Display for ClipboardType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
#[cfg(feature = "clipboard-crate")]
ClipboardType::Native => write!(f, "native"),
#[cfg(feature = "clipboard-bin")]
ClipboardType::Xclip(path) => match path {
None => write!(f, "xclip"),
Some(path) => write!(f, "xclip ({})", path),
},
#[cfg(feature = "clipboard-bin")]
ClipboardType::Xsel(path) => match path {
None => write!(f, "xsel"),
Some(path) => write!(f, "xsel ({})", path),
},
}
}
}
#[cfg(feature = "clipboard")]
#[derive(Debug, Fail)]
pub enum ClipboardError {
/// A generic error occurred while setting the clipboard contents.
///
/// This is for non-Linux systems, using a native clipboard interface.
#[cfg(feature = "clipboard-crate")]
#[fail(display = "failed to access clipboard")]
Native(#[cause] Compat),
/// The `xclip` or `xsel` binary could not be found on the system, required for clipboard support.
#[cfg(feature = "clipboard-bin")]
#[fail(display = "failed to access clipboard, xclip or xsel is not installed")]
NoBinary,
/// An error occurred while using `xclip` or `xsel` to set the clipboard contents.
/// This problem probably occurred when starting, or while piping the clipboard contents to
/// the process.
#[cfg(feature = "clipboard-bin")]
#[fail(display = "failed to access clipboard using {}", _0)]
BinaryIo(&'static str, #[cause] IoError),
/// `xclip` or `xsel` unexpectedly exited with a non-successful status code.
#[cfg(feature = "clipboard-bin")]
#[fail(
display = "failed to use clipboard, {} exited with status code {}",
_0, _1
)]
BinaryStatus(&'static str, i32),
}
/// Check for an empty password in the given `password`.
/// If the password is empty the program will quit with an error unless
/// forced.
// TODO: move this to a better module
pub fn check_empty_password(password: &str, matcher_main: &MainMatcher) {
if !matcher_main.force() && password.is_empty() {
quit_error_msg(
"an empty password is not supported by the web interface",
ErrorHintsBuilder::default()
.force(true)
.verbose(false)
.build()
.unwrap(),
)
}
}
/// Prompt the user to enter a password.
///
/// If `empty` is `false`, empty passwords aren't allowed unless forced.
pub fn prompt_password(main_matcher: &MainMatcher, optional: bool) -> Option {
// Quit with an error if we may not interact
if !optional && main_matcher.no_interact() {
quit_error_msg(
"missing password, must be specified in no-interact mode",
ErrorHintsBuilder::default()
.password(true)
.verbose(false)
.build()
.unwrap(),
);
}
// Prompt for the password
let prompt = if optional {
"Password (optional): "
} else {
"Password: "
};
match prompt_password_stderr(prompt) {
// If optional and nothing is entered, regard it as not defined
Ok(password) => {
if password.is_empty() && optional {
None
} else {
Some(password)
}
}
// On input error, propagate the error or don't use a password if optional
Err(err) => {
if !optional {
quit_error(
err.context("failed to read password from password prompt"),
ErrorHints::default(),
)
} else {
None
}
}
}
}
/// Get a password if required.
/// This method will ensure a password is set (or not) in the given `password`
/// parameter, as defined by `needs`.
/// If a password is needed, it may optionally be entered if `option` is set to true.
///
/// This method will prompt the user for a password, if one is required but
/// wasn't set. An ignore message will be shown if it was not required while it
/// was set.
///
/// Returns true if a password is now set, false if not.
pub fn ensure_password(
password: &mut Option,
needs: bool,
main_matcher: &MainMatcher,
optional: bool,
) -> bool {
// Return if we're fine, ignore if set but we don't need it
if password.is_some() == needs {
return needs;
}
if !needs {
// Notify the user a set password is ignored
if password.is_some() {
println!("Ignoring password, it is not required");
*password = None;
}
return false;
}
// Check whether we allow interaction
let interact = !main_matcher.no_interact();
loop {
// Prompt for an owner token if not set yet
if password.is_none() {
// Do not ask for a token if optional when non-interactive or forced
if optional && (!interact || main_matcher.force()) {
return false;
}
// Ask for the password
*password = prompt_password(main_matcher, optional);
}
// The token must not be empty, unless it's optional
let empty = password.is_none();
if empty && !optional {
eprintln!(
"No password given, which is required. Use {} to cancel.",
highlight("[CTRL+C]"),
);
} else {
return !empty;
}
}
}
/// Prompt the user to enter some value.
/// The prompt that is shown should be passed to `msg`,
/// excluding the `:` suffix.
pub fn prompt(msg: &str, main_matcher: &MainMatcher) -> String {
// Quit with an error if we may not interact
if main_matcher.no_interact() {
quit_error_msg(
format!(
"could not prompt for '{}' in no-interact mode, maybe specify it",
msg,
),
ErrorHints::default(),
);
}
// Show the prompt
eprint!("{}: ", msg);
let _ = stderr().flush();
// Get the input
let mut input = String::new();
if let Err(err) = stdin().read_line(&mut input) {
quit_error(
err.context("failed to read input from prompt"),
ErrorHints::default(),
);
}
// Trim and return
input.trim().to_owned()
}
/// Prompt the user for a question, allowing a yes or now answer.
/// True is returned if yes was answered, false if no.
///
/// A default may be given, which is chosen if no-interact mode is
/// enabled, or if enter was pressed by the user without entering anything.
pub fn prompt_yes(msg: &str, def: Option, main_matcher: &MainMatcher) -> bool {
// Define the available options string
let options = format!(
"[{}/{}]",
match def {
Some(def) if def => "Y",
_ => "y",
},
match def {
Some(def) if !def => "N",
_ => "n",
}
);
// Assume yes
if main_matcher.assume_yes() {
eprintln!("{} {}: yes", msg, options);
return true;
}
// Autoselect if in no-interact mode
if main_matcher.no_interact() {
if let Some(def) = def {
eprintln!("{} {}: {}", msg, options, if def { "yes" } else { "no" });
return def;
} else {
quit_error_msg(
format!(
"could not prompt question '{}' in no-interact mode, maybe specify it",
msg,
),
ErrorHints::default(),
);
}
}
// Get the user input
let answer = prompt(&format!("{} {}", msg, options), main_matcher);
// Assume the default if the answer is empty
if answer.is_empty() && def.is_some() {
return def.unwrap();
}
// Derive a boolean and return
match derive_bool(&answer) {
Some(answer) => answer,
None => prompt_yes(msg, def, main_matcher),
}
}
/// Try to derive true or false (yes or no) from the given input.
/// None is returned if no boolean could be derived accurately.
fn derive_bool(input: &str) -> Option {
// Process the input
let input = input.trim().to_lowercase();
// Handle short or incomplete answers
match input.as_str() {
"y" | "ye" | "t" | "1" => return Some(true),
"n" | "f" | "0" => return Some(false),
_ => {}
}
// Handle complete answers with any suffix
if input.starts_with("yes") || input.starts_with("true") {
return Some(true);
}
if input.starts_with("no") || input.starts_with("false") {
return Some(false);
}
// The answer could not be determined, return none
None
}
/// Prompt the user to enter an owner token.
pub fn prompt_owner_token(main_matcher: &MainMatcher, optional: bool) -> String {
prompt(
if optional {
"Owner token (optional)"
} else {
"Owner token"
},
main_matcher,
)
}
/// Get the owner token.
/// This method will ensure an owner token is set in the given `token`
/// parameter.
///
/// This method will prompt the user for the token, if it wasn't set.
///
/// Returns if an owner token was set.
/// If `optional` is false, this always returns true.
///
/// If in non-interactive or force mode, the user will not be prompted for a token if `optional` is
/// set to true.
pub fn ensure_owner_token(
token: &mut Option,
main_matcher: &MainMatcher,
optional: bool,
) -> bool {
// Check whether we allow interaction
let interact = !main_matcher.no_interact();
// Notify that an owner token is required
if interact && token.is_none() {
if optional {
println!("The file owner token is recommended for authentication.");
} else {
println!("The file owner token is required for authentication.");
}
}
loop {
// Prompt for an owner token if not set yet
if token.is_none() {
// Do not ask for a token if optional when non-interactive or forced
if optional && (!interact || main_matcher.force()) {
return false;
}
// Ask for the token, or quit with an error if non-interactive
if interact {
*token = Some(prompt_owner_token(main_matcher, optional));
} else {
quit_error_msg(
"missing owner token, must be specified in no-interact mode",
ErrorHintsBuilder::default()
.owner(true)
.verbose(false)
.build()
.unwrap(),
);
}
}
// The token must not be empty, unless it's optional
let empty = token.as_ref().unwrap().is_empty();
if empty {
*token = None;
}
if empty && !optional {
eprintln!(
"Empty owner token given, which is invalid. Use {} to cancel.",
highlight("[CTRL+C]"),
);
} else {
return !empty;
}
}
}
/// Format the given number of bytes readable for humans.
pub fn format_bytes(bytes: u64) -> String {
let bytes = bytes as f64;
let kb = 1024f64;
match bytes {
bytes if bytes >= kb.powf(4_f64) => format!("{:.*} TiB", 2, bytes / kb.powf(4_f64)),
bytes if bytes >= kb.powf(3_f64) => format!("{:.*} GiB", 2, bytes / kb.powf(3_f64)),
bytes if bytes >= kb.powf(2_f64) => format!("{:.*} MiB", 2, bytes / kb.powf(2_f64)),
bytes if bytes >= kb => format!("{:.*} KiB", 2, bytes / kb),
_ => format!("{:.*} B", 0, bytes),
}
}
/// Parse the given duration string from human readable format into seconds.
/// This method parses a string of time components to represent the given duration.
///
/// The following time units are used:
/// - `w`: weeks
/// - `d`: days
/// - `h`: hours
/// - `m`: minutes
/// - `s`: seconds
/// The following time strings can be parsed:
/// - `8w6d`
/// - `23h14m`
/// - `9m55s`
/// - `1s1s1s1s1s`
pub fn parse_duration(duration: &str) -> Result {
// Build a regex to grab time parts
let re = Regex::new(r"(?i)([0-9]+)(([a-z]|\s*$))")
.expect("failed to compile duration parsing regex");
// We must find any match
if re.find(duration).is_none() {
return Err(ParseDurationError::Empty);
}
// Parse each time part, sum it's seconds
let mut seconds = 0;
for capture in re.captures_iter(duration) {
// Parse time value and modifier
let number = capture[1]
.parse::()
.map_err(ParseDurationError::InvalidValue)?;
let modifier = capture[2].trim().to_lowercase();
// Multiply and sum seconds by modifier
seconds += match modifier.as_str() {
"" | "s" => number,
"m" => number * 60,
"h" => number * 60 * 60,
"d" => number * 60 * 60 * 24,
"w" => number * 60 * 60 * 24 * 7,
m => return Err(ParseDurationError::UnknownIdentifier(m.into())),
};
}
Ok(seconds)
}
/// Represents a duration parsing error.
#[derive(Debug, Fail)]
pub enum ParseDurationError {
/// The given duration string did not contain any duration part.
#[fail(display = "given string did not contain any duration part")]
Empty,
/// A numeric value was invalid.
#[fail(display = "duration part has invalid numeric value")]
InvalidValue(std::num::ParseIntError),
/// The given duration string contained an invalid duration modifier.
#[fail(display = "duration part has unknown time identifier '{}'", _0)]
UnknownIdentifier(String),
}
/// Format the given duration in a human readable format.
/// This method builds a string of time components to represent
/// the given duration.
///
/// The following time units are used:
/// - `w`: weeks
/// - `d`: days
/// - `h`: hours
/// - `m`: minutes
/// - `s`: seconds
///
/// Only the two most significant units are returned.
/// If the duration is zero seconds or less `now` is returned.
///
/// The following time strings may be produced:
/// - `8w6d`
/// - `23h14m`
/// - `9m55s`
/// - `1s`
/// - `now`
pub fn format_duration(duration: impl Borrow) -> String {
// Get the total number of seconds, return immediately if zero or less
let mut secs = duration.borrow().num_seconds();
if secs <= 0 {
return "now".into();
}
// Build a list of time units, define a list for time components
let mut components = Vec::new();
let units = [
(60 * 60 * 24 * 7, "w"),
(60 * 60 * 24, "d"),
(60 * 60, "h"),
(60, "m"),
(1, "s"),
];
// Fill the list of time components based on the units which fit
for unit in &units {
if secs >= unit.0 {
components.push(format!("{}{}", secs / unit.0, unit.1));
secs %= unit.0;
}
}
// Show only the two most significant components and join them in a string
components.truncate(2);
components.join("")
}
/// Format the given boolean, as `yes` or `no`.
pub fn format_bool(b: bool) -> &'static str {
if b {
"yes"
} else {
"no"
}
}
/// Get the name of the executable that was invoked.
///
/// When a symbolic or hard link is used, the name of the link is returned.
///
/// This attempts to obtain the binary name in the following order:
/// - name in first item of program arguments via `std::env::args`
/// - current executable name via `std::env::current_exe`
/// - crate name
pub fn bin_name() -> String {
env::args_os()
.next()
.filter(|path| !path.is_empty())
.map(PathBuf::from)
.or_else(|| current_exe().ok())
.and_then(|p| p.file_name().map(|n| n.to_owned()))
.and_then(|n| n.into_string().ok())
.unwrap_or_else(|| crate_name!().into())
}
/// Ensure that there is enough free disk space available at the given `path`,
/// to store a file with the given `size`.
///
/// If an error occurred while querying the file system,
/// the error is reported to the user and the method returns.
///
/// If there is not enough disk space available,
/// an error is reported and the program will quit.
pub fn ensure_enough_space>(path: P, size: u64) {
// Get the available space at this path
let space = match available_space(path) {
Ok(space) => space,
Err(err) => {
print_error(err.context("failed to check available space on disk, ignoring"));
return;
}
};
// Return if enough disk space is available
if space >= size {
return;
}
// Create an info message giving details about the required space
let info = format!(
"{} of space required, but only {} is available",
format_bytes(size),
format_bytes(space),
);
// Print an descriptive error and quit
quit_error(
err_msg("not enough disk space available in the target directory")
.context("failed to download file"),
ErrorHintsBuilder::default()
.add_info(info)
.force(true)
.verbose(false)
.build()
.unwrap(),
);
}
/// Get the project directories instance for this application.
/// This may be used to determine the project, cache, configuration, data and
/// some other directory paths.
#[cfg(feature = "history")]
pub fn app_project_dirs() -> ProjectDirs {
ProjectDirs::from("", "", crate_name!())
.expect("failed to determine location of project directories")
}
/// Get the default path to use for the history file.
#[cfg(feature = "history")]
pub fn app_history_file_path() -> PathBuf {
app_project_dirs().cache_dir().join("history.toml")
}
/// Get the default path to use for the history file, as a string.
#[cfg(feature = "history")]
pub fn app_history_file_path_string() -> String {
app_history_file_path().to_str().unwrap().to_owned()
}
/// Check whether an environment variable with the given key is present in the context of the
/// current process. The environment variable doesn't have to hold any specific value.
/// Returns `true` if present, `false` if not.
pub fn env_var_present(key: impl AsRef) -> bool {
var_os(key).is_some()
}
/// Get a list of all features that were enabled during compilation.
pub fn features_list() -> Vec<&'static str> {
// Build the list
#[allow(unused_mut)]
let mut features = Vec::new();
// Add each feature
#[cfg(feature = "archive")]
features.push("archive");
#[cfg(feature = "clipboard")]
features.push("clipboard");
#[cfg(feature = "clipboard-bin")]
features.push("clipboard-bin");
#[cfg(feature = "clipboard-crate")]
features.push("clipboard-crate");
#[cfg(feature = "history")]
features.push("history");
#[cfg(feature = "qrcode")]
features.push("qrcode");
#[cfg(feature = "urlshorten")]
features.push("urlshorten");
#[cfg(feature = "infer-command")]
features.push("infer-command");
#[cfg(feature = "no-qcolor")]
features.push("no-color");
#[cfg(feature = "send2")]
features.push("send2");
#[cfg(feature = "send3")]
features.push("send3");
#[cfg(feature = "crypto-ring")]
features.push("crypto-ring");
#[cfg(feature = "crypto-openssl")]
features.push("crypto-openssl");
features
}
/// Get a list of supported API versions.
pub fn api_version_list() -> Vec<&'static str> {
// Build the list
#[allow(unused_mut)]
let mut versions = Vec::new();
// Add each feature
#[cfg(feature = "send2")]
versions.push("v2");
#[cfg(feature = "send3")]
versions.push("v3");
versions
}
/// Follow redirects on the given URL, and return the final full URL.
///
/// This is used to obtain share URLs from shortened links.
///
// TODO: extract this into module
pub fn follow_url(client: &Client, url: &Url) -> Result {
// Send the request, follow the URL, ensure success
let response = client
.get(url.as_str())
.send()
.map_err(FollowError::Request)?;
ensure_success(&response)?;
// Obtain the final URL
Ok(response.url().clone())
}
/// URL following error.
#[derive(Debug, Fail)]
pub enum FollowError {
/// Failed to send the shortening request.
#[fail(display = "failed to send URL follow request")]
Request(#[cause] reqwest::Error),
/// The server responded with a bad response.
#[fail(display = "failed to shorten URL, got bad response")]
Response(#[cause] ResponseError),
}
impl From for FollowError {
fn from(err: ResponseError) -> Self {
FollowError::Response(err)
}
}
/// Generate a random alphanumeric string with the given length.
pub fn rand_alphanum_string(len: usize) -> String {
let mut rng = thread_rng();
iter::repeat(())
.map(|()| rng.sample(Alphanumeric) as char)
.take(len)
.collect()
}
/// Read file from stdin.
pub fn stdin_read_file(prompt: bool) -> Result, StdinErr> {
if prompt {
#[cfg(not(windows))]
eprintln!("Enter input. Use [CTRL+D] to stop:");
#[cfg(windows)]
eprintln!("Enter input. Use [CTRL+Z] to stop:");
}
let mut data = vec![];
io::stdin()
.lock()
.read_to_end(&mut data)
.map_err(StdinErr::Stdin)?;
Ok(data)
}
/// URL following error.
#[derive(Debug, Fail)]
pub enum StdinErr {
#[fail(display = "failed to read from stdin")]
Stdin(#[cause] io::Error),
}