mirrors/rage
1
0
Fork 0
mirror of https://github.com/str4d/rage.git synced 2025-04-04 19:37:51 +03:00
Code Issues Projects Releases Packages Wiki Activity

Use log crate for all errors and warnings

Browse source
This commit is contained in:
Jack Grigg 2019-12-15 20:07:38 +00:00
parent b51f454019
commit 42ba920f0b
No known key found for this signature in database
GPG key ID: 9E8255172BBF9898
4 changed files with 52 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Cargo.toml
View file

@ -43,6 +43,7 @@ zeroize = "1"
dialoguer = { version = "0.4", optional = true }
dirs = { version = "2", optional = true }
gumdrop = { version = "0.6", optional = true }
log = { version = "0.4", optional = true }
# rage and rage-keygen dependencies
chrono = { version = "0.4", optional = true }
@ -53,7 +54,6 @@ minreq = { version = "1.4", features = ["https"], optional = true }
env_logger = { version = "0.7", optional = true }
fuse_mt = { version = "0.5", optional = true }
libc = { version = "0.2", optional = true }
log = { version = "0.4", optional = true }
tar = { version = "0.4", optional = true }
time = { version = "0.1", optional = true }
zip = { version = "0.5", optional = true }
@ -63,9 +63,9 @@ man = "0.3"
[features]
default = ["cli"]
cli-common = ["dialoguer", "dirs", "gumdrop"]
cli-common = ["dialoguer", "dirs", "gumdrop", "log"]
cli = ["cli-common", "chrono", "console", "env_logger", "minreq"]
mount = ["cli-common", "env_logger", "fuse_mt", "libc", "log", "tar", "time", "zip"]
mount = ["cli-common", "env_logger", "fuse_mt", "libc", "tar", "time", "zip"]
[[bin]]
name = "rage-mount"

8
src/bin/rage-keygen/main.rs
View file

@ -1,6 +1,6 @@
use age::cli_common::file_io;
use gumdrop::Options;
use std::env;
use log::error;
use std::io::Write;
#[derive(Debug, Options)]
@ -13,16 +13,14 @@ struct AgeOptions {
}
fn main() {
if env::var("RUST_LOG").is_ok() {
env_logger::builder().format_timestamp(None).init();
}
let opts = AgeOptions::parse_args_default_or_exit();
let mut output = match file_io::OutputWriter::new(opts.output, false) {
Ok(output) => output,
Err(e) => {
eprintln!("Failed to open output: {}", e);
error!("Failed to open output: {}", e);
return;
}
};
@ -38,6 +36,6 @@ fn main() {
writeln!(output, "# {}", sk.to_public().to_str())?;
writeln!(output, "{}", sk.to_str())
})() {
eprintln!("Failed to write to output: {}", e);
error!("Failed to write to output: {}", e);
}
}

26
src/bin/rage-mount/main.rs
View file

@ -50,26 +50,26 @@ where
}
fn main() {
env_logger::init();
env_logger::builder().format_timestamp(None).init();
let opts = AgeMountOptions::parse_args_default_or_exit();
if opts.filename.is_empty() {
error!("Error: Missing filename");
error!("Missing filename");
return;
}
if opts.mountpoint.is_empty() {
error!("Error: Missing mountpoint");
error!("Missing mountpoint");
return;
}
if opts.types.is_empty() {
error!("Error: Missing -t/--types");
error!("Missing -t/--types");
return;
}
let decryptor = if opts.passphrase {
if !opts.identity.is_empty() {
eprintln!("Error: -i/--identity can't be used with -p/--passphrase");
error!("-i/--identity can't be used with -p/--passphrase");
return;
}
@ -79,8 +79,8 @@ fn main() {
}
} else {
if opts.identity.is_empty() {
eprintln!("Error: missing identities.");
eprintln!("Did you forget to specify -i/--identity?");
error!("Missing identities.");
error!("Did you forget to specify -i/--identity?");
return;
}
@ -89,19 +89,19 @@ fn main() {
// Check for unsupported keys and alert the user
for identity in &identities {
if let age::IdentityKey::Unsupported(k) = identity.key() {
eprintln!(
error!(
"Unsupported key: {}",
identity.filename().unwrap_or_default()
);
eprintln!();
eprintln!("{}", k);
error!("");
error!("{}", k);
return;
}
}
age::Decryptor::Keys(identities)
}
Err(e) => {
eprintln!("Error while reading identities: {}", e);
error!("Failed to read identities: {}", e);
return;
}
}
@ -111,7 +111,7 @@ fn main() {
let file = match File::open(opts.filename) {
Ok(f) => f,
Err(e) => {
eprintln!("Failed to open file: {}", e);
error!("Failed to open file: {}", e);
return;
}
};
@ -121,7 +121,7 @@ fn main() {
{
Ok(stream) => stream,
Err(e) => {
eprintln!("Failed to decrypt file: {}", e);
error!("Failed to decrypt file: {}", e);
return;
}
};

68
src/bin/rage/main.rs
View file

@ -1,7 +1,7 @@
use age::cli_common::{file_io, get_config_dir, read_identities, read_passphrase};
use gumdrop::Options;
use log::{error, warn};
use std::collections::HashMap;
use std::env;
use std::fs::{read_to_string, File};
use std::io::{self, BufRead, BufReader, Write};
@ -54,7 +54,7 @@ fn read_recipients_list<R: BufRead>(filename: &str, buf: R) -> io::Result<Vec<ag
Ok(key) => recipients.push(key),
Err(<age::RecipientKey as std::str::FromStr>::Err::Ignore) => (),
Err(e) => {
eprintln!("{:?}", e);
error!("{:?}", e);
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("recipients file {} contains non-recipient data", filename),
@ -97,7 +97,7 @@ fn read_recipients(
recipients.push(pk);
} else if arg.starts_with(ALIAS_PREFIX) {
if seen_aliases.contains(&arg) {
eprintln!("Warning: duplicate {}", arg);
warn!("Duplicate {}", arg);
} else {
// Replace the alias in the arguments list with its expansion
arguments.extend(aliases.remove(&arg[ALIAS_PREFIX.len()..]).ok_or_else(|| {
@ -180,21 +180,19 @@ struct AgeOptions {
fn encrypt(opts: AgeOptions) {
if !opts.identity.is_empty() {
eprintln!("Error: -i/--identity can't be used in encryption mode.");
eprintln!("Did you forget to specify -d/--decrypt?");
error!("-i/--identity can't be used in encryption mode.");
error!("Did you forget to specify -d/--decrypt?");
return;
}
let encryptor = if opts.passphrase {
if !opts.recipient.is_empty() {
eprintln!("Error: -r/--recipient can't be used with -p/--passphrase");
error!("-r/--recipient can't be used with -p/--passphrase");
return;
}
if opts.input.is_none() {
eprintln!(
"Error: file to encrypt must be passed as an argument when using -p/--passphrase"
);
error!("File to encrypt must be passed as an argument when using -p/--passphrase");
return;
}
@ -204,15 +202,15 @@ fn encrypt(opts: AgeOptions) {
}
} else {
if opts.recipient.is_empty() {
eprintln!("Error: missing recipients.");
eprintln!("Did you forget to specify -r/--recipient?");
error!("Missing recipients.");
error!("Did you forget to specify -r/--recipient?");
return;
}
match read_recipients(opts.recipient, opts.aliases) {
Ok(recipients) => age::Encryptor::Keys(recipients),
Err(e) => {
eprintln!("Error while reading recipients: {}", e);
error!("Error while reading recipients: {}", e);
return;
}
}
@ -221,7 +219,7 @@ fn encrypt(opts: AgeOptions) {
let mut input = match file_io::InputReader::new(opts.input) {
Ok(input) => input,
Err(e) => {
eprintln!("Failed to open input: {}", e);
error!("Failed to open input: {}", e);
return;
}
};
@ -229,7 +227,7 @@ fn encrypt(opts: AgeOptions) {
let output = match file_io::OutputWriter::new(opts.output, true) {
Ok(output) => output,
Err(e) => {
eprintln!("Failed to open output: {}", e);
error!("Failed to open output: {}", e);
return;
}
};
@ -237,43 +235,41 @@ fn encrypt(opts: AgeOptions) {
match encryptor.wrap_output(output, opts.armor) {
Ok(mut w) => {
if let Err(e) = io::copy(&mut input, &mut w) {
eprintln!("Error while encrypting: {}", e);
error!("Error while encrypting: {}", e);
return;
}
if let Err(e) = w.flush() {
eprintln!("Error while encrypting: {}", e);
error!("Error while encrypting: {}", e);
return;
}
}
Err(e) => {
eprintln!("Failed to encrypt: {}", e);
error!("Failed to encrypt: {}", e);
}
}
}
fn decrypt(opts: AgeOptions) {
if opts.armor {
eprintln!("Error: -a/--armor can't be used with -d/--decrypt.");
eprintln!("Note that armored files are detected automatically.");
error!("-a/--armor can't be used with -d/--decrypt.");
error!("Note that armored files are detected automatically.");
return;
}
if !opts.recipient.is_empty() {
eprintln!("Error: -r/--recipient can't be used with -d/--decrypt.");
eprintln!("Did you mean to use -i/--identity to specify a private key?");
error!("-r/--recipient can't be used with -d/--decrypt.");
error!("Did you mean to use -i/--identity to specify a private key?");
return;
}
let decryptor = if opts.passphrase {
if !opts.identity.is_empty() {
eprintln!("Error: -i/--identity can't be used with -p/--passphrase");
error!("-i/--identity can't be used with -p/--passphrase");
return;
}
if opts.input.is_none() {
eprintln!(
"Error: file to decrypt must be passed as an argument when using -p/--passphrase"
);
error!("File to decrypt must be passed as an argument when using -p/--passphrase");
return;
}
@ -283,8 +279,8 @@ fn decrypt(opts: AgeOptions) {
}
} else {
if opts.identity.is_empty() {
eprintln!("Error: missing identities.");
eprintln!("Did you forget to specify -i/--identity?");
error!("Missing identities.");
error!("Did you forget to specify -i/--identity?");
return;
}
@ -293,19 +289,19 @@ fn decrypt(opts: AgeOptions) {
// Check for unsupported keys and alert the user
for identity in &identities {
if let age::IdentityKey::Unsupported(k) = identity.key() {
eprintln!(
error!(
"Unsupported key: {}",
identity.filename().unwrap_or_default()
);
eprintln!();
eprintln!("{}", k);
error!("");
error!("{}", k);
return;
}
}
age::Decryptor::Keys(identities)
}
Err(e) => {
eprintln!("Error while reading identities: {}", e);
error!("Error while reading identities: {}", e);
return;
}
}
@ -314,7 +310,7 @@ fn decrypt(opts: AgeOptions) {
let input = match file_io::InputReader::new(opts.input) {
Ok(input) => input,
Err(e) => {
eprintln!("Failed to open input: {}", e);
error!("Failed to open input: {}", e);
return;
}
};
@ -322,7 +318,7 @@ fn decrypt(opts: AgeOptions) {
let mut output = match file_io::OutputWriter::new(opts.output, false) {
Ok(output) => output,
Err(e) => {
eprintln!("Failed to open output: {}", e);
error!("Failed to open output: {}", e);
return;
}
};
@ -333,17 +329,15 @@ fn decrypt(opts: AgeOptions) {
match maybe_decrypted {
Ok(mut r) => {
if let Err(e) = io::copy(&mut r, &mut output) {
eprintln!("Error while decrypting: {}", e);
error!("Error while decrypting: {}", e);
}
}
Err(e) => eprintln!("Failed to decrypt: {}", e),
Err(e) => error!("Failed to decrypt: {}", e),
}
}
fn main() {
if env::var("RUST_LOG").is_ok() {
env_logger::builder().format_timestamp(None).init();
}
let opts = AgeOptions::parse_args_default_or_exit();