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