fpgcli 0.0.1

CLI executable built on flowerypassgen.
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

// Flowery Pass Gen CLI

use arboard::Clipboard;
use flowerypassgen::{gen_password, genoptions::GenOptions};
use std::env;

fn help() {
	println!(
"fpgcli - Flowery Pass Gen Command Line Interface

Arguments:
--help, -H, -?                 - Prints the help argument
--copy, -C                     - Copies the generated password into your clipboard
--length=<u32>, -L=<u32>       - Sets the password length to the given unsigned 32 bit integer value         - (default: 8)
--max-attempts=<u32>, -M=<u32> - Sets the maximum attempts to the given unsigned 32 bit integer value        - (default: 512)
--symbols=<bool>, -S=<bool>    - Determines whether the password can have symbols in it                      - (default: false)
--duplicates=<bool>, -D=<bool> - Determines whether the password can have duplicate instances of chars in it - (default: true)
");
}

fn main() {
	let mut opts: GenOptions = GenOptions { length: (8), max_attempts: (512), use_symbols: (false), use_duplicate_chars: (true) };
	let mut copy_to_clipboard: bool = false;

	// Could be better
	let mut args: Vec<String> = env::args().collect();
	args.remove(0);

	for arg in args {
		if ["--help", "-H", "-?"].contains(&arg.as_str()) {
			help();
			std::process::exit(0);
		} else if ["--copy", "-C"].contains(&arg.as_str()) {
			copy_to_clipboard = true;
		} else if arg.contains("=") {
			let arg_split: Vec<&str> = arg.as_str().split("=").collect();

			match arg_split[0] {
				"--length" | "-L" => {
					match arg_split[1].parse::<u32>() {
						Ok(n) => opts.length = n,
						Err(_) => eprintln!("Provided length '{}' is not of type u32", arg_split[1]),
					}
				},
				"--max-attempts" | "-M" => {
					match arg_split[1].parse::<u32>() {
						Ok(n) => opts.max_attempts = n,
						Err(_) => eprintln!("Provided maximum attempts '{}' is not of type u32", arg_split[1]),
					}
				},
				"--symbols" | "-S" => {
					opts.use_symbols = arg_split[1].to_lowercase() == "true" || arg_split[1] == "1";
				},
				"--duplicates" | "-D" => {
					opts.use_duplicate_chars = arg_split[1].to_lowercase() == "true" || arg_split[1] == "1";
				},
				_ => {
					eprintln!("Unrecognised argument {}.", arg_split[0]);
				}
			}
		} else {
			eprintln!("Unrecognised argument {}.", arg.as_str());
		}
	}

	let password = gen_password(&opts);

	if copy_to_clipboard {
		// TODO: KDE Plasma Klipper support because no library supports it 
		let mut ctx = Clipboard::new().unwrap();
		
		match ctx.set_text(password.clone()) {
			Ok(_) => { println!("Password written to clipboard!"); },
			Err(e) => {
				eprintln!("Failed to write password to clipboard due to error '{}', please copy manually. Password: {}", e, password)
			}
		}
	}
	else {
		println!("Password: {}", password);
	}
}