Skip to content

Commit

Permalink
Use closures instead of command functions
Browse files Browse the repository at this point in the history 
To simplify the code, this patch replaces the one-line argument handling
functions with closures.
  • Loading branch information
@robinkrahl @d-e-s-o
robinkrahl authored and d-e-s-o committed Jan 7, 2020
1 parent dbbc88e commit fc58fa0
Showing 1 changed file with 40 additions and 169 deletions.
209 changes: 40 additions & 169 deletions src/args.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -111,16 +111,16 @@ impl From<DeviceModel> for nitrokey::Model {
/// A top-level command for nitrocli.
#[allow(unused_doc_comments)]
Command! {Command, [
Config(ConfigArgs) => config,
Encrypted(EncryptedArgs) => encrypted,
Hidden(HiddenArgs) => hidden,
Lock(LockArgs) => lock,
Otp(OtpArgs) => otp,
Pin(PinArgs) => pin,
Pws(PwsArgs) => pws,
Reset(ResetArgs) => reset,
Status(StatusArgs) => status,
Unencrypted(UnencryptedArgs) => unencrypted,
Config(ConfigArgs) => |ctx, args: ConfigArgs| args.subcmd.execute(ctx),
Encrypted(EncryptedArgs) => |ctx, args: EncryptedArgs| args.subcmd.execute(ctx),
Hidden(HiddenArgs) => |ctx, args: HiddenArgs| args.subcmd.execute(ctx),
Lock(LockArgs) => |ctx, _| commands::lock(ctx),
Otp(OtpArgs) => |ctx, args: OtpArgs| args.subcmd.execute(ctx),
Pin(PinArgs) => |ctx, args: PinArgs| args.subcmd.execute(ctx),
Pws(PwsArgs) => |ctx, args: PwsArgs| args.subcmd.execute(ctx),
Reset(ResetArgs) => |ctx, _| commands::reset(ctx),
Status(StatusArgs) => |ctx, _| commands::status(ctx),
Unencrypted(UnencryptedArgs) => |ctx, args: UnencryptedArgs| args.subcmd.execute(ctx),
]}

/// Reads or writes the device configuration
Expand Down Expand Up @@ -374,7 +374,7 @@ pub struct UnencryptedSetArgs {
}

Command! {ConfigCommand, [
Get(ConfigGetArgs) => config_get,
Get(ConfigGetArgs) => |ctx, _| commands::config_get(ctx),
Set(ConfigSetArgs) => config_set,
]}

Expand Down Expand Up @@ -414,10 +414,14 @@ impl<T> ConfigOption<T> {
}

Command! {OtpCommand, [
Clear(OtpClearArgs) => otp_clear,
Get(OtpGetArgs) => otp_get,
Clear(OtpClearArgs) => |ctx, args: OtpClearArgs| {
commands::otp_clear(ctx, args.slot, args.algorithm)
},
Get(OtpGetArgs) => |ctx, args: OtpGetArgs| {
commands::otp_get(ctx, args.slot, args.algorithm, args.time)
},
Set(OtpSetArgs) => otp_set,
Status(OtpStatusArgs) => otp_status,
Status(OtpStatusArgs) => |ctx, args: OtpStatusArgs| commands::otp_status(ctx, args.all),
]}

Enum! {OtpAlgorithm, [
Expand Down Expand Up @@ -446,101 +450,46 @@ Enum! {OtpSecretFormat, [
]}

Command! {PinCommand, [
Clear(PinClearArgs) => pin_clear,
Set(PinSetArgs) => pin_set,
Unblock(PinUnblockArgs) => pin_unblock,
Clear(PinClearArgs) => |ctx, _| commands::pin_clear(ctx),
Set(PinSetArgs) => |ctx, args: PinSetArgs| commands::pin_set(ctx, args.pintype),
Unblock(PinUnblockArgs) => |ctx, _| commands::pin_unblock(ctx),
]}

Command! {PwsCommand, [
Clear(PwsClearArgs) => pws_clear,
Get(PwsGetArgs) => pws_get,
Set(PwsSetArgs) => pws_set,
Status(PwsStatusArgs) => pws_status,
Clear(PwsClearArgs) => |ctx, args: PwsClearArgs| commands::pws_clear(ctx, args.slot),
Get(PwsGetArgs) => |ctx, args: PwsGetArgs| {
commands::pws_get(ctx, args.slot, args.name, args.login, args.password, args.quiet)
},
Set(PwsSetArgs) => |ctx, args: PwsSetArgs| {
commands::pws_set(ctx, args.slot, &args.name, &args.login, &args.password)
},
Status(PwsStatusArgs) => |ctx, args: PwsStatusArgs| commands::pws_status(ctx, args.all),
]}

/// Inquire the status of the Nitrokey.
fn status(ctx: &mut ExecCtx<'_>, _args: StatusArgs) -> Result<()> {
commands::status(ctx)
}

/// Perform a factory reset.
fn reset(ctx: &mut ExecCtx<'_>, _args: ResetArgs) -> Result<()> {
commands::reset(ctx)
}

Command! {UnencryptedCommand, [
Set(UnencryptedSetArgs) => unencrypted_set,
Set(UnencryptedSetArgs) => |ctx, args: UnencryptedSetArgs| {
commands::unencrypted_set(ctx, args.mode)
},
]}

Enum! {UnencryptedVolumeMode, [
ReadWrite => "read-write",
ReadOnly => "read-only",
]}

/// Execute an unencrypted subcommand.
fn unencrypted(ctx: &mut ExecCtx<'_>, args: UnencryptedArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

/// Change the configuration of the unencrypted volume.
fn unencrypted_set(ctx: &mut ExecCtx<'_>, args: UnencryptedSetArgs) -> Result<()> {
commands::unencrypted_set(ctx, args.mode)
}

Command! {EncryptedCommand, [
Close(EncryptedCloseArgs) => encrypted_close,
Open(EncryptedOpenArgs) => encrypted_open,
Close(EncryptedCloseArgs) => |ctx, _| commands::encrypted_close(ctx),
Open(EncryptedOpenArgs) => |ctx, _| commands::encrypted_open(ctx),
]}

/// Execute an encrypted subcommand.
fn encrypted(ctx: &mut ExecCtx<'_>, args: EncryptedArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

/// Open the encrypted volume on the Nitrokey.
fn encrypted_open(ctx: &mut ExecCtx<'_>, _args: EncryptedOpenArgs) -> Result<()> {
commands::encrypted_open(ctx)
}

/// Close the previously opened encrypted volume.
fn encrypted_close(ctx: &mut ExecCtx<'_>, _args: EncryptedCloseArgs) -> Result<()> {
commands::encrypted_close(ctx)
}

Command! {HiddenCommand, [
Close(HiddenCloseArgs) => hidden_close,
Create(HiddenCreateArgs) => hidden_create,
Open(HiddenOpenArgs) => hidden_open,
Close(HiddenCloseArgs) => |ctx, _| commands::hidden_close(ctx),
Create(HiddenCreateArgs) => |ctx, args: HiddenCreateArgs| {
commands::hidden_create(ctx, args.slot, args.start, args.end)
},
Open(HiddenOpenArgs) => |ctx, _| commands::hidden_open(ctx),
]}

/// Execute a hidden subcommand.
fn hidden(ctx: &mut ExecCtx<'_>, args: HiddenArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

fn hidden_create(ctx: &mut ExecCtx<'_>, args: HiddenCreateArgs) -> Result<()> {
commands::hidden_create(ctx, args.slot, args.start, args.end)
}

fn hidden_open(ctx: &mut ExecCtx<'_>, _args: HiddenOpenArgs) -> Result<()> {
commands::hidden_open(ctx)
}

fn hidden_close(ctx: &mut ExecCtx<'_>, _args: HiddenCloseArgs) -> Result<()> {
commands::hidden_close(ctx)
}

/// Execute a config subcommand.
fn config(ctx: &mut ExecCtx<'_>, args: ConfigArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

/// Read the Nitrokey configuration.
fn config_get(ctx: &mut ExecCtx<'_>, _args: ConfigGetArgs) -> Result<()> {
commands::config_get(ctx)
}

/// Write the Nitrokey configuration.
fn config_set(ctx: &mut ExecCtx<'_>, args: ConfigSetArgs) -> Result<()> {
let numlock = ConfigOption::try_from(args.no_numlock, args.numlock, "numlock")?;
let capslock = ConfigOption::try_from(args.no_capslock, args.capslock, "capslock")?;
Expand All @@ -555,23 +504,7 @@ fn config_set(ctx: &mut ExecCtx<'_>, args: ConfigSetArgs) -> Result<()> {
commands::config_set(ctx, numlock, capslock, scrollock, otp_pin)
}

/// Lock the Nitrokey.
fn lock(ctx: &mut ExecCtx<'_>, _args: LockArgs) -> Result<()> {
commands::lock(ctx)
}

/// Execute an OTP subcommand.
fn otp(ctx: &mut ExecCtx<'_>, args: OtpArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

/// Generate a one-time password on the Nitrokey device.
fn otp_get(ctx: &mut ExecCtx<'_>, args: OtpGetArgs) -> Result<()> {
commands::otp_get(ctx, args.slot, args.algorithm, args.time)
}

/// Configure a one-time password slot on the Nitrokey device.
pub fn otp_set(ctx: &mut ExecCtx<'_>, args: OtpSetArgs) -> Result<()> {
fn otp_set(ctx: &mut ExecCtx<'_>, args: OtpSetArgs) -> Result<()> {
let data = nitrokey::OtpSlotData {
number: args.slot,
name: args.name,
Expand All @@ -590,68 +523,6 @@ pub fn otp_set(ctx: &mut ExecCtx<'_>, args: OtpSetArgs) -> Result<()> {
)
}

/// Clear an OTP slot.
fn otp_clear(ctx: &mut ExecCtx<'_>, args: OtpClearArgs) -> Result<()> {
commands::otp_clear(ctx, args.slot, args.algorithm)
}

/// Print the status of the OTP slots.
fn otp_status(ctx: &mut ExecCtx<'_>, args: OtpStatusArgs) -> Result<()> {
commands::otp_status(ctx, args.all)
}

/// Execute a PIN subcommand.
fn pin(ctx: &mut ExecCtx<'_>, args: PinArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

/// Clear the PIN as cached by various other commands.
fn pin_clear(ctx: &mut ExecCtx<'_>, _args: PinClearArgs) -> Result<()> {
commands::pin_clear(ctx)
}

/// Change a PIN.
fn pin_set(ctx: &mut ExecCtx<'_>, args: PinSetArgs) -> Result<()> {
commands::pin_set(ctx, args.pintype)
}

/// Unblock and reset the user PIN.
fn pin_unblock(ctx: &mut ExecCtx<'_>, _args: PinUnblockArgs) -> Result<()> {
commands::pin_unblock(ctx)
}

/// Execute a PWS subcommand.
fn pws(ctx: &mut ExecCtx<'_>, args: PwsArgs) -> Result<()> {
args.subcmd.execute(ctx)
}

/// Access a slot of the password safe on the Nitrokey.
fn pws_get(ctx: &mut ExecCtx<'_>, args: PwsGetArgs) -> Result<()> {
commands::pws_get(
ctx,
args.slot,
args.name,
args.login,
args.password,
args.quiet,
)
}

/// Set a slot of the password safe on the Nitrokey.
fn pws_set(ctx: &mut ExecCtx<'_>, args: PwsSetArgs) -> Result<()> {
commands::pws_set(ctx, args.slot, &args.name, &args.login, &args.password)
}

/// Clear a PWS slot.
fn pws_clear(ctx: &mut ExecCtx<'_>, args: PwsClearArgs) -> Result<()> {
commands::pws_clear(ctx, args.slot)
}

/// Print the status of the PWS slots.
fn pws_status(ctx: &mut ExecCtx<'_>, args: PwsStatusArgs) -> Result<()> {
commands::pws_status(ctx, args.all)
}

/// Parse the command-line arguments and execute the selected command.
pub(crate) fn handle_arguments(ctx: &mut RunCtx<'_>, args: Vec<String>) -> Result<()> {
use structopt::StructOpt;
Expand Down

0 comments on commit fc58fa0

Please sign in to comment.