sq: Adapt sq keyserver to clap3's derive API.

4 files changed, 33 insertions, 18 deletions

diff --git a/sq/Cargo.toml b/sq/Cargo.toml
index a807f700..02ffd06e 100644
--- a/sq/Cargo.toml
+++ b/sq/Cargo.toml
@@ -44,6 +44,7 @@ anyhow = "1.0.18"
 clap = { version = "3", features = ["derive", "wrap_help"] }
 clap_complete = "3"
 sequoia-openpgp = { path = "../openpgp", version = "1.0.0", default-features = false }
+sequoia-net = { path = "../net", version = "0.24", default-features = false }
 subplot-build = "0.4.0"
 cfg-if = "1"
 
diff --git a/sq/src/commands/net.rs b/sq/src/commands/net.rs
index f05c9cf8..457298f5 100644
--- a/sq/src/commands/net.rs
+++ b/sq/src/commands/net.rs
@@ -28,6 +28,8 @@ use crate::{
     serialize_keyring,
 };
 
+use crate::sq_cli::KeyserverCommand;
+use crate::sq_cli::KeyserverSubcommands;
 
 fn parse_network_policy(m: &clap::ArgMatches) -> net::Policy {
     match m.value_of("policy").expect("has default value") {
@@ -39,10 +41,10 @@ fn parse_network_policy(m: &clap::ArgMatches) -> net::Policy {
     }
 }
 
-pub fn dispatch_keyserver(config: Config, m: &clap::ArgMatches) -> Result<()> {
-    let network_policy = parse_network_policy(m);
-    let mut ks = if let Some(uri) = m.value_of("server") {
-        KeyServer::new(network_policy, uri)
+pub fn dispatch_keyserver(config: Config, c: KeyserverCommand) -> Result<()> {
+    let network_policy = c.policy.into();
+    let mut ks = if let Some(uri) = c.server {
+        KeyServer::new(network_policy, &uri)
     } else {
         KeyServer::keys_openpgp_org(network_policy)
     }.context("Malformed keyserver URI")?;
@@ -52,9 +54,9 @@ pub fn dispatch_keyserver(config: Config, m: &clap::ArgMatches) -> Result<()> {
         .enable_time()
         .build()?;
 
-    match m.subcommand() {
-        Some(("get",  m)) => {
-            let query = m.value_of("query").unwrap();
+    match c.subcommand {
+         KeyserverSubcommands::Get(c) => {
+            let query = c.query;
 
             let handle = query.parse::<KeyHandle>();
 
@@ -63,35 +65,33 @@ pub fn dispatch_keyserver(config: Config, m: &clap::ArgMatches) -> Result<()> {
                     .context("Failed to retrieve cert")?;
 
                 let mut output =
-                    config.create_or_stdout_safe(m.value_of("output"))?;
-                if ! m.is_present("binary") {
+                    config.create_or_stdout_safe(c.output.as_deref())?;
+                if !c.binary {
                     cert.armored().serialize(&mut output)
                 } else {
                     cert.serialize(&mut output)
                 }.context("Failed to serialize cert")?;
-            } else if let Ok(Some(addr)) = UserID::from(query).email() {
+            } else if let Ok(Some(addr)) = UserID::from(query.as_str()).email() {
                 let certs = rt.block_on(ks.search(addr))
                     .context("Failed to retrieve certs")?;
 
                 let mut output =
-                    config.create_or_stdout_safe(m.value_of("output"))?;
-                serialize_keyring(&mut output, &certs,
-                                  m.is_present("binary"))?;
+                    config.create_or_stdout_safe(c.output.as_deref())?;
+                serialize_keyring(&mut output, &certs, c.binary)?;
             } else {
                 return Err(anyhow::anyhow!(
                     "Query must be a fingerprint, a keyid, \
                      or an email address: {:?}", query));
             }
         },
-        Some(("send",  m)) => {
-            let mut input = open_or_stdin(m.value_of("input"))?;
+        KeyserverSubcommands::Send(c) => {
+            let mut input = open_or_stdin(c.input.as_deref())?;
             let cert = Cert::from_reader(&mut input).
                 context("Malformed key")?;
 
             rt.block_on(ks.send(&cert))
                 .context("Failed to send key to server")?;
         },
-        _ => unreachable!(),
     }
 
     Ok(())
diff --git a/sq/src/sq.rs b/sq/src/sq.rs
index e99d2b3e..fa25bac6 100644
--- a/sq/src/sq.rs
+++ b/sq/src/sq.rs
@@ -716,8 +716,11 @@ fn main() -> Result<()> {
             _ => unreachable!(),
         },
 
-        Some(("keyserver",  m)) =>
-            commands::net::dispatch_keyserver(config, m)?,
+        Some(("keyserver",  m)) => {
+            use clap::FromArgMatches;
+            let command = sq_cli::KeyserverCommand::from_arg_matches(m)?;
+            commands::net::dispatch_keyserver(config, command)?
+        },
 
         Some(("key", m)) => {
             use clap::FromArgMatches;
diff --git a/sq/src/sq_cli.rs b/sq/src/sq_cli.rs
index 0bb08c2d..d336b448 100644
--- a/sq/src/sq_cli.rs
+++ b/sq/src/sq_cli.rs
@@ -2190,6 +2190,17 @@ pub enum KeyserverPolicy {
     Insecure,
 }
 
+impl From<KeyserverPolicy> for sequoia_net::Policy {
+    fn from(kp: KeyserverPolicy) -> Self {
+        match kp {
+            KeyserverPolicy::Offline => sequoia_net::Policy::Offline,
+            KeyserverPolicy::Anonymized => sequoia_net::Policy::Anonymized,
+            KeyserverPolicy::Encrypted => sequoia_net::Policy::Encrypted,
+            KeyserverPolicy::Insecure => sequoia_net::Policy::Insecure,
+        }
+    }
+}
+
 #[derive(Debug, Subcommand)]
 pub enum KeyserverSubcommands {
     Get(KeyserverGetCommand),