1 files changed, 4 insertions, 127 deletions

diff --git a/sq/src/sq.rs b/sq/src/sq.rs
index 3a97bee0..39c30527 100644
--- a/sq/src/sq.rs
+++ b/sq/src/sq.rs
@@ -9,14 +9,9 @@ use chrono::{DateTime, offset::Utc};
 
 use buffered_reader::File;
 use sequoia_openpgp as openpgp;
-use sequoia_net;
 
 use openpgp::{
     Result,
-    Fingerprint,
-    KeyID,
-    KeyHandle,
-    packet::UserID,
 };
 use crate::openpgp::{armor, Cert};
 use sequoia_autocrypt as autocrypt;
@@ -29,7 +24,6 @@ use crate::openpgp::serialize::{Serialize, stream::{Message, Armorer}};
 use crate::openpgp::cert::prelude::*;
 use crate::openpgp::policy::StandardPolicy as P;
 use sequoia_net as net;
-use sequoia_net::{KeyServer, wkd};
 
 mod sq_cli;
 mod commands;
@@ -269,13 +263,6 @@ fn main() -> Result<()> {
         network_policy,
     };
 
-
-    let mut rt = tokio::runtime::Builder::new()
-        .basic_scheduler()
-        .enable_io()
-        .enable_time()
-        .build()?;
-
     match matches.subcommand() {
         ("decrypt",  Some(m)) => {
             let mut input = open_or_stdin(m.value_of("input"))?;
@@ -500,126 +487,16 @@ fn main() -> Result<()> {
             _ => unreachable!(),
         },
 
-        ("keyserver",  Some(m)) => {
-            let mut ks = if let Some(uri) = m.value_of("server") {
-                KeyServer::new(network_policy, &uri)
-            } else {
-                KeyServer::keys_openpgp_org(network_policy)
-            }.context("Malformed keyserver URI")?;
-
-            match m.subcommand() {
-                ("get",  Some(m)) => {
-                    let query = m.value_of("query").unwrap();
-
-                    let handle: Option<KeyHandle> = {
-                        let q_fp = query.parse::<Fingerprint>();
-                        let q_id = query.parse::<KeyID>();
-                        if let Ok(Fingerprint::V4(_)) = q_fp {
-                            q_fp.ok().map(Into::into)
-                        } else if let Ok(KeyID::V4(_)) = q_id {
-                            q_fp.ok().map(Into::into)
-                        } else {
-                            None
-                        }
-                    };
-
-                    if let Some(handle) = handle {
-                        let cert = rt.block_on(ks.get(handle))
-                            .context("Failed to retrieve cert")?;
-
-                        let mut output =
-                            create_or_stdout(m.value_of("output"), force)?;
-                        if ! m.is_present("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() {
-                        let certs = rt.block_on(ks.search(addr))
-                            .context("Failed to retrieve certs")?;
-
-                        let mut output =
-                            create_or_stdout_pgp(m.value_of("output"), force,
-                                                 m.is_present("binary"),
-                                                 armor::Kind::PublicKey)?;
-                        for cert in certs {
-                            cert.serialize(&mut output)
-                                .context("Failed to serialize cert")?;
-                        }
-                        output.finalize()?;
-                    } else {
-                        Err(anyhow::anyhow!(
-                            "Query must be a fingerprint, a keyid, \
-                             or an email address: {:?}", query))?;
-                    }
-                },
-                ("send",  Some(m)) => {
-                    let mut input = open_or_stdin(m.value_of("input"))?;
-                    let cert = Cert::from_reader(&mut input).
-                        context("Malformed key")?;
+        ("keyserver",  Some(m)) =>
+            commands::net::dispatch_keyserver(config, m)?,
 
-                    rt.block_on(ks.send(&cert))
-                        .context("Failed to send key to server")?;
-                },
-                _ => unreachable!(),
-            }
-        },
         ("key", Some(m)) => match m.subcommand() {
             ("generate", Some(m)) => commands::key::generate(m, force)?,
             ("adopt", Some(m)) => commands::key::adopt(m, policy)?,
             _ => unreachable!(),
         },
-        ("wkd",  Some(m)) => {
-            match m.subcommand() {
-                ("url",  Some(m)) => {
-                    let email_address = m.value_of("input").unwrap();
-                    let wkd_url = wkd::Url::from(email_address)?;
-                    // XXX: Add other subcomand to specify whether it should be
-                    // created with the advanced or the direct method.
-                    let url = wkd_url.to_url(None)?;
-                    println!("{}", url);
-                },
-                ("get",  Some(m)) => {
-                    let email_address = m.value_of("input").unwrap();
-                    // XXX: EmailAddress could be created here to
-                    // check it's a valid email address, print the error to
-                    // stderr and exit.
-                    // Because it might be created a WkdServer struct, not
-                    // doing it for now.
-                    let certs = rt.block_on(wkd::get(&email_address))?;
-                    // ```text
-                    //     The HTTP GET method MUST return the binary representation of the
-                    //     OpenPGP key for the given mail address.
-                    // [draft-koch]: https://datatracker.ietf.org/doc/html/draft-koch-openpgp-webkey-service-07
-                    // ```
-                    // But to keep the parallelism with `store export` and `keyserver get`,
-                    // The output is armored if not `--binary` option is given.
-                    let mut output = create_or_stdout(m.value_of("output"), force)?;
-                    serialize_keyring(&mut output, &certs,
-                                      m.is_present("binary"))?;
-                },
-                ("generate", Some(m)) => {
-                    let domain = m.value_of("domain").unwrap();
-                    let f = open_or_stdin(m.value_of("input"))?;
-                    let base_path =
-                        m.value_of("base_directory").expect("required");
-                    let variant = if m.is_present("direct_method") {
-                        wkd::Variant::Direct
-                    } else {
-                        wkd::Variant::Advanced
-                    };
-                    let parser = CertParser::from_reader(f)?;
-                    let certs: Vec<Cert> = parser.filter_map(|cert| cert.ok())
-                        .collect();
-                    for cert in certs {
-                        wkd::insert(&base_path, domain, variant, &cert)
-                            .context(format!("Failed to generate the WKD in \
-                                              {}.", base_path))?;
-                    }
-                },
-                _ => unreachable!(),
-            }
-        },
+
+        ("wkd",  Some(m)) => commands::net::dispatch_wkd(config, m)?,
         _ => unreachable!(),
     }