Allow input capture & emulation being disabled (#158)

* Input capture and emulation can now be disabled and will prompt the user to enable again.

* Improved error handling to deliver more useful error messages

src/dns.rs

@@ -1,23 +1,62 @@
-use anyhow::Result;
-use std::{error::Error, net::IpAddr};
+use std::net::IpAddr;
+use tokio::sync::mpsc::Receiver;
 
-use hickory_resolver::TokioAsyncResolver;
+use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
 
-pub struct DnsResolver {
+use crate::{client::ClientHandle, server::Server};
+
+pub(crate) struct DnsResolver {
     resolver: TokioAsyncResolver,
+    dns_request: Receiver<ClientHandle>,
 }
+
 impl DnsResolver {
-    pub(crate) async fn new() -> Result<Self> {
+    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
         let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self { resolver })
+        Ok(Self {
+            resolver,
+            dns_request,
+        })
     }
 
-    pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
-        log::info!("resolving {host} ...");
+    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
         let response = self.resolver.lookup_ip(host).await?;
         for ip in response.iter() {
             log::info!("{host}: adding ip {ip}");
         }
         Ok(response.iter().collect())
     }
+
+    pub(crate) async fn run(mut self, server: Server) {
+        tokio::select! {
+            _ = server.cancelled() => {},
+            _ = self.do_dns(&server) => {},
+        }
+    }
+
+    async fn do_dns(&mut self, server: &Server) {
+        loop {
+            let handle = self.dns_request.recv().await.expect("channel closed");
+
+            /* update resolving status */
+            let hostname = match server.get_hostname(handle) {
+                Some(hostname) => hostname,
+                None => continue,
+            };
+
+            log::info!("resolving ({handle}) `{hostname}` ...");
+            server.set_resolving(handle, true);
+
+            let ips = match self.resolve(&hostname).await {
+                Ok(ips) => ips,
+                Err(e) => {
+                    log::warn!("could not resolve host '{hostname}': {e}");
+                    vec![]
+                }
+            };
+
+            server.update_dns_ips(handle, ips);
+            server.set_resolving(handle, false);
+        }
+    }
 }