1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// 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 <http://www.gnu.org/licenses/>. *
// *************************************************************************
use std::ffi;
use std::io;
use std::result;
use crate::arg_defs;
use crate::commands;
use crate::error::Error;
use crate::RunCtx;
type Result<T> = result::Result<T, Error>;
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<W> 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<arg_defs::DeviceModel>,
pub stdout: &'io mut dyn io::Write,
pub stderr: &'io mut dyn io::Write,
pub admin_pin: Option<ffi::OsString>,
pub user_pin: Option<ffi::OsString>,
pub new_admin_pin: Option<ffi::OsString>,
pub new_user_pin: Option<ffi::OsString>,
pub password: Option<ffi::OsString>,
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)
}
}
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")?;
let otp_pin = if args.otp_pin {
Some(true)
} else if args.no_otp_pin {
Some(false)
} else {
None
};
commands::config_set(ctx, numlock, capslock, scrollock, otp_pin)
}
pub fn otp_set(ctx: &mut ExecCtx<'_>, args: arg_defs::OtpSetArgs) -> Result<()> {
let data = nitrokey::OtpSlotData {
number: args.slot,
name: args.name,
secret: args.secret,
mode: args.digits.into(),
use_enter: false,
token_id: None,
};
commands::otp_set(
ctx,
data,
args.algorithm,
args.counter,
args.time_window,
args.format,
)
}
/// 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;
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(())
}
}
}
}
|
