From fafbf4a1bf635d5eea049cf561fbf8aa293c8e2b Mon Sep 17 00:00:00 2001 From: Daniel Mueller Date: Sat, 11 Apr 2020 13:23:52 -0700 Subject: Merge remaining bits of args.rs into main.rs This change removes the args module by moving all remaining functionality in it into main.rs. The result is arguably a nice consolidation of all context related definitions in a single module. --- src/arg_util.rs | 2 +- src/args.rs | 99 ------------------------------------------------ src/commands.rs | 112 +++++++++++++++++++++++-------------------------------- src/main.rs | 85 ++++++++++++++++++++++++++++++++++++++++- src/pinentry.rs | 6 +-- src/tests/mod.rs | 2 +- 6 files changed, 134 insertions(+), 172 deletions(-) delete mode 100644 src/args.rs (limited to 'src') diff --git a/src/arg_util.rs b/src/arg_util.rs index c16c326..439a594 100644 --- a/src/arg_util.rs +++ b/src/arg_util.rs @@ -46,7 +46,7 @@ macro_rules! Command { impl $name { pub fn execute( self, - ctx: &mut crate::args::ExecCtx<'_>, + ctx: &mut crate::ExecCtx<'_>, ) -> crate::Result<()> { match self { $( diff --git a/src/args.rs b/src/args.rs deleted file mode 100644 index d0b2a88..0000000 --- a/src/args.rs +++ /dev/null @@ -1,99 +0,0 @@ -// args.rs - -// ************************************************************************* -// * Copyright (C) 2018-2020 Daniel Mueller (deso@posteo.net) * -// * * -// * This program is free software: you can redistribute it and/or modify * -// * it under the terms of the GNU General Public License as published by * -// * the Free Software Foundation, either version 3 of the License, or * -// * (at your option) any later version. * -// * * -// * This program is distributed in the hope that it will be useful, * -// * but WITHOUT ANY WARRANTY; without even the implied warranty of * -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * -// * GNU General Public License for more details. * -// * * -// * You should have received a copy of the GNU General Public License * -// * along with this program. If not, see . * -// ************************************************************************* - -use std::ffi; -use std::io; -use std::result; - -use crate::arg_defs; -use crate::error::Error; -use crate::RunCtx; - -type Result = result::Result; - -trait Stdio { - fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write); -} - -impl<'io> Stdio for RunCtx<'io> { - fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write) { - (self.stdout, self.stderr) - } -} - -impl Stdio for (&mut W, &mut W) -where - W: io::Write, -{ - fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write) { - (self.0, self.1) - } -} - -/// A command execution context that captures additional data pertaining -/// the command execution. -pub struct ExecCtx<'io> { - pub model: Option, - pub stdout: &'io mut dyn io::Write, - pub stderr: &'io mut dyn io::Write, - pub admin_pin: Option, - pub user_pin: Option, - pub new_admin_pin: Option, - pub new_user_pin: Option, - pub password: Option, - pub no_cache: bool, - pub verbosity: u64, -} - -impl<'io> Stdio for ExecCtx<'io> { - fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write) { - (self.stdout, self.stderr) - } -} - -/// Parse the command-line arguments and execute the selected command. -pub(crate) fn handle_arguments(ctx: &mut RunCtx<'_>, args: Vec) -> Result<()> { - use structopt::StructOpt; - - match arg_defs::Args::from_iter_safe(args.iter()) { - Ok(args) => { - let mut ctx = ExecCtx { - model: args.model, - stdout: ctx.stdout, - stderr: ctx.stderr, - admin_pin: ctx.admin_pin.take(), - user_pin: ctx.user_pin.take(), - new_admin_pin: ctx.new_admin_pin.take(), - new_user_pin: ctx.new_user_pin.take(), - password: ctx.password.take(), - no_cache: ctx.no_cache, - verbosity: args.verbose.into(), - }; - args.cmd.execute(&mut ctx) - } - Err(err) => { - if err.use_stderr() { - Err(err.into()) - } else { - println!(ctx, "{}", err.message)?; - Ok(()) - } - } - } -} diff --git a/src/commands.rs b/src/commands.rs index b40d552..208c039 100644 --- a/src/commands.rs +++ b/src/commands.rs @@ -32,10 +32,10 @@ use nitrokey::GenerateOtp; use nitrokey::GetPasswordSafe; use crate::arg_defs; -use crate::args; use crate::error; use crate::error::Error; use crate::pinentry; +use crate::ExecCtx; use crate::Result; /// Create an `error::Error` with an error message of the format `msg: err`. @@ -44,7 +44,7 @@ fn get_error(msg: &'static str, err: nitrokey::Error) -> Error { } /// Set `libnitrokey`'s log level based on the execution context's verbosity. -fn set_log_level(ctx: &mut args::ExecCtx<'_>) { +fn set_log_level(ctx: &mut ExecCtx<'_>) { let log_lvl = match ctx.verbosity { // The error log level is what libnitrokey uses by default. As such, // there is no harm in us setting that as well when the user did not @@ -60,9 +60,9 @@ fn set_log_level(ctx: &mut args::ExecCtx<'_>) { } /// Connect to any Nitrokey device and do something with it. -fn with_device(ctx: &mut args::ExecCtx<'_>, op: F) -> Result<()> +fn with_device(ctx: &mut ExecCtx<'_>, op: F) -> Result<()> where - F: FnOnce(&mut args::ExecCtx<'_>, nitrokey::DeviceWrapper<'_>) -> Result<()>, + F: FnOnce(&mut ExecCtx<'_>, nitrokey::DeviceWrapper<'_>) -> Result<()>, { let mut manager = nitrokey::take()?; set_log_level(ctx); @@ -81,9 +81,9 @@ where } /// Connect to a Nitrokey Storage device and do something with it. -fn with_storage_device(ctx: &mut args::ExecCtx<'_>, op: F) -> Result<()> +fn with_storage_device(ctx: &mut ExecCtx<'_>, op: F) -> Result<()> where - F: FnOnce(&mut args::ExecCtx<'_>, nitrokey::Storage<'_>) -> Result<()>, + F: FnOnce(&mut ExecCtx<'_>, nitrokey::Storage<'_>) -> Result<()>, { let mut manager = nitrokey::take()?; set_log_level(ctx); @@ -104,9 +104,9 @@ where /// Connect to any Nitrokey device, retrieve a password safe handle, and /// do something with it. -fn with_password_safe(ctx: &mut args::ExecCtx<'_>, mut op: F) -> Result<()> +fn with_password_safe(ctx: &mut ExecCtx<'_>, mut op: F) -> Result<()> where - F: FnMut(&mut args::ExecCtx<'_>, nitrokey::PasswordSafe<'_, '_>) -> Result<()>, + F: FnMut(&mut ExecCtx<'_>, nitrokey::PasswordSafe<'_, '_>) -> Result<()>, { with_device(ctx, |ctx, mut device| { let pin_entry = pinentry::PinEntry::from(arg_defs::PinType::User, &device)?; @@ -131,7 +131,7 @@ where /// /// If an error occurs, the error message `msg` is used. fn authenticate<'mgr, D, A, F>( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, device: D, pin_type: arg_defs::PinType, msg: &'static str, @@ -139,7 +139,7 @@ fn authenticate<'mgr, D, A, F>( ) -> Result where D: Device<'mgr>, - F: FnMut(&mut args::ExecCtx<'_>, D, &str) -> result::Result, + F: FnMut(&mut ExecCtx<'_>, D, &str) -> result::Result, { let pin_entry = pinentry::PinEntry::from(pin_type, &device)?; @@ -147,10 +147,7 @@ where } /// Authenticate the given device with the user PIN. -fn authenticate_user<'mgr, T>( - ctx: &mut args::ExecCtx<'_>, - device: T, -) -> Result> +fn authenticate_user<'mgr, T>(ctx: &mut ExecCtx<'_>, device: T) -> Result> where T: Device<'mgr>, { @@ -164,10 +161,7 @@ where } /// Authenticate the given device with the admin PIN. -fn authenticate_admin<'mgr, T>( - ctx: &mut args::ExecCtx<'_>, - device: T, -) -> Result> +fn authenticate_admin<'mgr, T>(ctx: &mut ExecCtx<'_>, device: T) -> Result> where T: Device<'mgr>, { @@ -208,14 +202,14 @@ fn get_volume_status(status: &nitrokey::VolumeStatus) -> &'static str { /// second or third try, it will call `op` with the data returned by the /// previous call to `op`. fn try_with_pin_and_data_with_pinentry( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, pin_entry: &pinentry::PinEntry, msg: &'static str, data: D, mut op: F, ) -> Result where - F: FnMut(&mut args::ExecCtx<'_>, D, &str) -> result::Result, + F: FnMut(&mut ExecCtx<'_>, D, &str) -> result::Result, E: error::TryInto, { let mut data = data; @@ -248,14 +242,14 @@ where /// Try to execute the given function with a PIN. fn try_with_pin_and_data( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, pin_entry: &pinentry::PinEntry, msg: &'static str, data: D, mut op: F, ) -> Result where - F: FnMut(&mut args::ExecCtx<'_>, D, &str) -> result::Result, + F: FnMut(&mut ExecCtx<'_>, D, &str) -> result::Result, E: Into + error::TryInto, { let pin = match pin_entry.pin_type() { @@ -284,7 +278,7 @@ where /// This function behaves exactly as `try_with_pin_and_data`, but /// it refrains from passing any data to it. fn try_with_pin( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, pin_entry: &pinentry::PinEntry, msg: &'static str, mut op: F, @@ -299,10 +293,7 @@ where } /// Pretty print the status of a Nitrokey Storage. -fn print_storage_status( - ctx: &mut args::ExecCtx<'_>, - status: &nitrokey::StorageStatus, -) -> Result<()> { +fn print_storage_status(ctx: &mut ExecCtx<'_>, status: &nitrokey::StorageStatus) -> Result<()> { println!( ctx, r#" Storage: @@ -333,7 +324,7 @@ fn print_storage_status( /// Query and pretty print the status that is common to all Nitrokey devices. fn print_status( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, model: &'static str, device: &nitrokey::DeviceWrapper<'_>, ) -> Result<()> { @@ -368,7 +359,7 @@ fn print_status( } /// Inquire the status of the nitrokey. -pub fn status(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn status(ctx: &mut ExecCtx<'_>) -> Result<()> { with_device(ctx, |ctx, device| { let model = match device { nitrokey::DeviceWrapper::Pro(_) => "Pro", @@ -379,7 +370,7 @@ pub fn status(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } /// List the attached Nitrokey devices. -pub fn list(ctx: &mut args::ExecCtx<'_>, no_connect: bool) -> Result<()> { +pub fn list(ctx: &mut ExecCtx<'_>, no_connect: bool) -> Result<()> { set_log_level(ctx); let device_infos = nitrokey::list_devices()?; @@ -417,7 +408,7 @@ pub fn list(ctx: &mut args::ExecCtx<'_>, no_connect: bool) -> Result<()> { } /// Perform a factory reset. -pub fn reset(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn reset(ctx: &mut ExecCtx<'_>) -> Result<()> { with_device(ctx, |ctx, mut device| { let pin_entry = pinentry::PinEntry::from(arg_defs::PinType::Admin, &device)?; @@ -441,10 +432,7 @@ pub fn reset(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } /// Change the configuration of the unencrypted volume. -pub fn unencrypted_set( - ctx: &mut args::ExecCtx<'_>, - mode: arg_defs::UnencryptedVolumeMode, -) -> Result<()> { +pub fn unencrypted_set(ctx: &mut ExecCtx<'_>, mode: arg_defs::UnencryptedVolumeMode) -> Result<()> { with_storage_device(ctx, |ctx, mut device| { let pin_entry = pinentry::PinEntry::from(arg_defs::PinType::Admin, &device)?; let mode = match mode { @@ -466,7 +454,7 @@ pub fn unencrypted_set( } /// Open the encrypted volume on the Nitrokey. -pub fn encrypted_open(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn encrypted_open(ctx: &mut ExecCtx<'_>) -> Result<()> { with_storage_device(ctx, |ctx, mut device| { let pin_entry = pinentry::PinEntry::from(arg_defs::PinType::User, &device)?; @@ -481,7 +469,7 @@ pub fn encrypted_open(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } /// Close the previously opened encrypted volume. -pub fn encrypted_close(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn encrypted_close(ctx: &mut ExecCtx<'_>) -> Result<()> { with_storage_device(ctx, |_ctx, mut device| { // Flush all filesystem caches to disk. We are mostly interested in // making sure that the encrypted volume on the Nitrokey we are @@ -496,7 +484,7 @@ pub fn encrypted_close(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } /// Create a hidden volume. -pub fn hidden_create(ctx: &mut args::ExecCtx<'_>, slot: u8, start: u8, end: u8) -> Result<()> { +pub fn hidden_create(ctx: &mut ExecCtx<'_>, slot: u8, start: u8, end: u8) -> Result<()> { with_storage_device(ctx, |ctx, mut device| { let pwd_entry = pinentry::PwdEntry::from(&device)?; let pwd = if let Some(pwd) = &ctx.password { @@ -515,7 +503,7 @@ pub fn hidden_create(ctx: &mut args::ExecCtx<'_>, slot: u8, start: u8, end: u8) } /// Open a hidden volume. -pub fn hidden_open(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn hidden_open(ctx: &mut ExecCtx<'_>) -> Result<()> { with_storage_device(ctx, |ctx, mut device| { let pwd_entry = pinentry::PwdEntry::from(&device)?; let pwd = if let Some(pwd) = &ctx.password { @@ -538,7 +526,7 @@ pub fn hidden_open(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } /// Close a previously opened hidden volume. -pub fn hidden_close(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn hidden_close(ctx: &mut ExecCtx<'_>) -> Result<()> { with_storage_device(ctx, |_ctx, mut device| { unsafe { sync() }; @@ -557,7 +545,7 @@ fn format_option(option: Option) -> String { } /// Read the Nitrokey configuration. -pub fn config_get(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn config_get(ctx: &mut ExecCtx<'_>) -> Result<()> { with_device(ctx, |ctx, device| { let config = device .get_config() @@ -579,7 +567,7 @@ pub fn config_get(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } /// Write the Nitrokey configuration. -pub fn config_set(ctx: &mut args::ExecCtx<'_>, args: arg_defs::ConfigSetArgs) -> Result<()> { +pub fn config_set(ctx: &mut ExecCtx<'_>, args: arg_defs::ConfigSetArgs) -> Result<()> { let numlock = arg_defs::ConfigOption::try_from(args.no_numlock, args.numlock, "numlock")?; let capslock = arg_defs::ConfigOption::try_from(args.no_capslock, args.capslock, "capslock")?; let scrollock = arg_defs::ConfigOption::try_from(args.no_scrollock, args.scrollock, "scrollock")?; @@ -609,7 +597,7 @@ pub fn config_set(ctx: &mut args::ExecCtx<'_>, args: arg_defs::ConfigSetArgs) -> } /// Lock the Nitrokey device. -pub fn lock(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn lock(ctx: &mut ExecCtx<'_>) -> Result<()> { with_device(ctx, |_ctx, mut device| { device .lock() @@ -637,7 +625,7 @@ fn get_unix_timestamp() -> Result { /// Generate a one-time password on the Nitrokey device. pub fn otp_get( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, slot: u8, algorithm: arg_defs::OtpAlgorithm, time: Option, @@ -700,7 +688,7 @@ fn prepare_base32_secret(secret: &str) -> Result { } /// Configure a one-time password slot on the Nitrokey device. -pub fn otp_set(ctx: &mut args::ExecCtx<'_>, mut args: arg_defs::OtpSetArgs) -> Result<()> { +pub fn otp_set(ctx: &mut ExecCtx<'_>, mut args: arg_defs::OtpSetArgs) -> Result<()> { let mut data = nitrokey::OtpSlotData { number: args.slot, name: mem::take(&mut args.name), @@ -739,11 +727,7 @@ pub fn otp_set(ctx: &mut args::ExecCtx<'_>, mut args: arg_defs::OtpSetArgs) -> R } /// Clear an OTP slot. -pub fn otp_clear( - ctx: &mut args::ExecCtx<'_>, - slot: u8, - algorithm: arg_defs::OtpAlgorithm, -) -> Result<()> { +pub fn otp_clear(ctx: &mut ExecCtx<'_>, slot: u8, algorithm: arg_defs::OtpAlgorithm) -> Result<()> { with_device(ctx, |ctx, device| { let mut device = authenticate_admin(ctx, device)?; match algorithm { @@ -756,7 +740,7 @@ pub fn otp_clear( } fn print_otp_status( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, algorithm: arg_defs::OtpAlgorithm, device: &nitrokey::DeviceWrapper<'_>, all: bool, @@ -790,7 +774,7 @@ fn print_otp_status( } /// Print the status of the OTP slots. -pub fn otp_status(ctx: &mut args::ExecCtx<'_>, all: bool) -> Result<()> { +pub fn otp_status(ctx: &mut ExecCtx<'_>, all: bool) -> Result<()> { with_device(ctx, |ctx, device| { println!(ctx, "alg\tslot\tname")?; print_otp_status(ctx, arg_defs::OtpAlgorithm::Hotp, &device, all)?; @@ -800,7 +784,7 @@ pub fn otp_status(ctx: &mut args::ExecCtx<'_>, all: bool) -> Result<()> { } /// Clear the PIN stored by various operations. -pub fn pin_clear(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn pin_clear(ctx: &mut ExecCtx<'_>) -> Result<()> { with_device(ctx, |_ctx, device| { pinentry::clear(&pinentry::PinEntry::from( arg_defs::PinType::Admin, @@ -815,11 +799,7 @@ pub fn pin_clear(ctx: &mut args::ExecCtx<'_>) -> Result<()> { /// /// If the user has set the respective environment variable for the /// given PIN type, it will be used. -fn choose_pin( - ctx: &mut args::ExecCtx<'_>, - pin_entry: &pinentry::PinEntry, - new: bool, -) -> Result { +fn choose_pin(ctx: &mut ExecCtx<'_>, pin_entry: &pinentry::PinEntry, new: bool) -> Result { let new_pin = match pin_entry.pin_type() { arg_defs::PinType::Admin => { if new { @@ -848,7 +828,7 @@ fn choose_pin( } /// Change a PIN. -pub fn pin_set(ctx: &mut args::ExecCtx<'_>, pin_type: arg_defs::PinType) -> Result<()> { +pub fn pin_set(ctx: &mut ExecCtx<'_>, pin_type: arg_defs::PinType) -> Result<()> { with_device(ctx, |ctx, mut device| { let pin_entry = pinentry::PinEntry::from(pin_type, &device)?; let new_pin = choose_pin(ctx, &pin_entry, true)?; @@ -871,7 +851,7 @@ pub fn pin_set(ctx: &mut args::ExecCtx<'_>, pin_type: arg_defs::PinType) -> Resu } /// Unblock and reset the user PIN. -pub fn pin_unblock(ctx: &mut args::ExecCtx<'_>) -> Result<()> { +pub fn pin_unblock(ctx: &mut ExecCtx<'_>) -> Result<()> { with_device(ctx, |ctx, mut device| { let pin_entry = pinentry::PinEntry::from(arg_defs::PinType::User, &device)?; let user_pin = choose_pin(ctx, &pin_entry, false)?; @@ -887,7 +867,7 @@ pub fn pin_unblock(ctx: &mut args::ExecCtx<'_>) -> Result<()> { } fn print_pws_data( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, description: &'static str, result: result::Result, quiet: bool, @@ -920,7 +900,7 @@ fn check_slot(pws: &nitrokey::PasswordSafe<'_, '_>, slot: u8) -> Result<()> { /// Read a PWS slot. pub fn pws_get( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, slot: u8, show_name: bool, show_login: bool, @@ -946,7 +926,7 @@ pub fn pws_get( /// Write a PWS slot. pub fn pws_set( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, slot: u8, name: &str, login: &str, @@ -960,7 +940,7 @@ pub fn pws_set( } /// Clear a PWS slot. -pub fn pws_clear(ctx: &mut args::ExecCtx<'_>, slot: u8) -> Result<()> { +pub fn pws_clear(ctx: &mut ExecCtx<'_>, slot: u8) -> Result<()> { with_password_safe(ctx, |_ctx, mut pws| { pws .erase_slot(slot) @@ -969,7 +949,7 @@ pub fn pws_clear(ctx: &mut args::ExecCtx<'_>, slot: u8) -> Result<()> { } fn print_pws_slot( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, pws: &nitrokey::PasswordSafe<'_, '_>, slot: usize, programmed: bool, @@ -990,7 +970,7 @@ fn print_pws_slot( } /// Print the status of all PWS slots. -pub fn pws_status(ctx: &mut args::ExecCtx<'_>, all: bool) -> Result<()> { +pub fn pws_status(ctx: &mut ExecCtx<'_>, all: bool) -> Result<()> { with_password_safe(ctx, |ctx, pws| { let slots = pws .get_slot_status() diff --git a/src/main.rs b/src/main.rs index 89c9d67..a2c4f48 100644 --- a/src/main.rs +++ b/src/main.rs @@ -69,7 +69,6 @@ mod redefine; mod arg_util; mod arg_defs; -mod args; mod commands; mod error; mod pinentry; @@ -93,6 +92,88 @@ const NITROCLI_NEW_USER_PIN: &str = "NITROCLI_NEW_USER_PIN"; const NITROCLI_PASSWORD: &str = "NITROCLI_PASSWORD"; const NITROCLI_NO_CACHE: &str = "NITROCLI_NO_CACHE"; +trait Stdio { + fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write); +} + +impl<'io> Stdio for RunCtx<'io> { + fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write) { + (self.stdout, self.stderr) + } +} + +impl Stdio for (&mut W, &mut W) +where + W: io::Write, +{ + fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write) { + (self.0, self.1) + } +} + +/// A command execution context that captures additional data pertaining +/// the command execution. +#[allow(missing_debug_implementations)] +pub struct ExecCtx<'io> { + /// The Nitrokey model to use. + pub model: Option, + /// See `RunCtx::stdout`. + pub stdout: &'io mut dyn io::Write, + /// See `RunCtx::stderr`. + pub stderr: &'io mut dyn io::Write, + /// See `RunCtx::admin_pin`. + pub admin_pin: Option, + /// See `RunCtx::user_pin`. + pub user_pin: Option, + /// See `RunCtx::new_admin_pin`. + pub new_admin_pin: Option, + /// See `RunCtx::new_user_pin`. + pub new_user_pin: Option, + /// See `RunCtx::password`. + pub password: Option, + /// See `RunCtx::no_cache`. + pub no_cache: bool, + /// The verbosity level to use for logging. + pub verbosity: u64, +} + +impl<'io> Stdio for ExecCtx<'io> { + fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write) { + (self.stdout, self.stderr) + } +} + +/// Parse the command-line arguments and execute the selected command. +fn handle_arguments(ctx: &mut RunCtx<'_>, args: Vec) -> Result<()> { + use structopt::StructOpt; + + match arg_defs::Args::from_iter_safe(args.iter()) { + Ok(args) => { + let mut ctx = ExecCtx { + model: args.model, + stdout: ctx.stdout, + stderr: ctx.stderr, + admin_pin: ctx.admin_pin.take(), + user_pin: ctx.user_pin.take(), + new_admin_pin: ctx.new_admin_pin.take(), + new_user_pin: ctx.new_user_pin.take(), + password: ctx.password.take(), + no_cache: ctx.no_cache, + verbosity: args.verbose.into(), + }; + args.cmd.execute(&mut ctx) + } + Err(err) => { + if err.use_stderr() { + Err(err.into()) + } else { + println!(ctx, "{}", err.message)?; + Ok(()) + } + } + } +} + /// The context used when running the program. pub(crate) struct RunCtx<'io> { /// The `Write` object used as standard output throughout the program. @@ -118,7 +199,7 @@ pub(crate) struct RunCtx<'io> { } fn run<'ctx, 'io: 'ctx>(ctx: &'ctx mut RunCtx<'io>, args: Vec) -> i32 { - match args::handle_arguments(ctx, args) { + match handle_arguments(ctx, args) { Ok(()) => 0, Err(err) => { let _ = eprintln!(ctx, "{}", err); diff --git a/src/pinentry.rs b/src/pinentry.rs index 878ed9e..47c8844 100644 --- a/src/pinentry.rs +++ b/src/pinentry.rs @@ -24,8 +24,8 @@ use std::process; use std::str; use crate::arg_defs; -use crate::args; use crate::error::Error; +use crate::ExecCtx; type CowStr = borrow::Cow<'static, str>; @@ -222,7 +222,7 @@ where /// dialog. It is used to choose an appropriate description and to /// decide whether a quality bar is shown in the dialog. pub fn inquire( - ctx: &mut args::ExecCtx<'_>, + ctx: &mut ExecCtx<'_>, entry: &E, mode: Mode, error_msg: Option<&str>, @@ -279,7 +279,7 @@ where } } -pub fn choose(ctx: &mut args::ExecCtx<'_>, entry: &E) -> crate::Result +pub fn choose(ctx: &mut ExecCtx<'_>, entry: &E) -> crate::Result where E: SecretEntry, { diff --git a/src/tests/mod.rs b/src/tests/mod.rs index 1edf8f2..abf63e3 100644 --- a/src/tests/mod.rs +++ b/src/tests/mod.rs @@ -178,7 +178,7 @@ impl Nitrocli { /// Run `nitrocli`'s `handle_arguments` function. pub fn handle(&mut self, args: &[&str]) -> crate::Result { - let (res, out, _) = self.do_run(args, |c, a| crate::args::handle_arguments(c, a)); + let (res, out, _) = self.do_run(args, |c, a| crate::handle_arguments(c, a)); res.map(|_| String::from_utf8_lossy(&out).into_owned()) } -- cgit v1.2.3