feat(dns): resolve hostnames asynchronously

10 files changed, 251 insertions, 178 deletions

diff --git a/src/main.rs b/src/main.rs
index 7626615..d499432 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,9 +5,10 @@ mod os;
 mod tests;
 
 use display::{RawTerminalBackend, Ui};
-use network::{Connection, DnsQueue, Sniffer, Utilization};
-
-use ::std::net::IpAddr;
+use network::{
+    dns::{self, IpTable},
+    Connection, Sniffer, Utilization,
+};
 
 use ::pnet::datalink::{DataLinkReceiver, NetworkInterface};
 use ::std::collections::HashMap;
@@ -54,7 +55,7 @@ fn try_main() -> Result<(), failure::Error> {
 
     use os::get_input;
     let opts = Opt::from_args();
-    let os_input = get_input(&opts.interface)?;
+    let os_input = get_input(&opts.interface, !opts.no_resolve)?;
     let raw_mode = opts.raw;
     if raw_mode {
         let terminal_backend = RawTerminalBackend {};
@@ -69,7 +70,7 @@ fn try_main() -> Result<(), failure::Error> {
                 "Failed to get stdout: 'what' does not (yet) support piping, is it being piped?"
             ),
         }
-    };
+    }
     Ok(())
 }
 
@@ -78,7 +79,7 @@ pub struct OsInputOutput {
     pub network_frames: Box<dyn DataLinkReceiver>,
     pub get_open_sockets: fn() -> HashMap<Connection, String>,
     pub keyboard_events: Box<dyn Iterator<Item = Event> + Send>,
-    pub lookup_addr: Box<dyn Fn(&IpAddr) -> Option<String> + Send>,
+    pub dns_client: Option<dns::Client>,
     pub on_winch: Box<dyn Fn(Box<dyn Fn()>) + Send>,
     pub cleanup: Box<dyn Fn() + Send>,
     pub write_to_stdout: Box<dyn FnMut(String) + Send>,
@@ -94,46 +95,17 @@ where
 
     let keyboard_events = os_input.keyboard_events;
     let get_open_sockets = os_input.get_open_sockets;
-    let lookup_addr = os_input.lookup_addr;
     let mut write_to_stdout = os_input.write_to_stdout;
+    let mut dns_client = os_input.dns_client;
     let on_winch = os_input.on_winch;
     let cleanup = os_input.cleanup;
 
     let raw_mode = opts.raw;
-    let no_resolve = opts.no_resolve;
 
     let mut sniffer = Sniffer::new(os_input.network_interface, os_input.network_frames);
     let network_utilization = Arc::new(Mutex::new(Utilization::new()));
     let ui = Arc::new(Mutex::new(Ui::new(terminal_backend)));
 
-    let dns_queue = if no_resolve {
-        Arc::new(None)
-    } else {
-        Arc::new(Some(DnsQueue::new()))
-    };
-    let ip_to_host = Arc::new(Mutex::new(HashMap::new()));
-
-    if !no_resolve {
-        active_threads.push(
-            thread::Builder::new()
-                .name("dns_resolver".to_string())
-                .spawn({
-                    let dns_queue = dns_queue.clone();
-                    let ip_to_host = ip_to_host.clone();
-                    move || {
-                        if let Some(dns_queue) = Option::as_ref(&dns_queue) {
-                            while let Some(ip) = dns_queue.wait_for_job() {
-                                if let Some(addr) = lookup_addr(&IpAddr::V4(ip)) {
-                                    ip_to_host.lock().unwrap().insert(ip, addr);
-                                }
-                            }
-                        }
-                    }
-                })
-                .unwrap(),
-        );
-    }
-
     if !raw_mode {
         active_threads.push(
             thread::Builder::new()
@@ -158,25 +130,22 @@ where
         .spawn({
             let running = running.clone();
             let network_utilization = network_utilization.clone();
-            let ip_to_host = ip_to_host.clone();
-            let dns_queue = dns_queue.clone();
             let ui = ui.clone();
             move || {
                 while running.load(Ordering::Acquire) {
                     let render_start_time = Instant::now();
                     let utilization = { network_utilization.lock().unwrap().clone_and_reset() };
                     let connections_to_procs = get_open_sockets();
-                    let ip_to_host = { ip_to_host.lock().unwrap().clone() };
-                    let mut unresolved_ips = Vec::new();
-                    for connection in connections_to_procs.keys() {
-                        if !ip_to_host.contains_key(&connection.remote_socket.ip) {
-                            unresolved_ips.push(connection.remote_socket.ip);
-                        }
-                    }
-                    if let Some(dns_queue) = Option::as_ref(&dns_queue) {
-                        if !unresolved_ips.is_empty() {
-                            dns_queue.resolve_ips(unresolved_ips);
-                        }
+                    let mut ip_to_host = IpTable::new();
+                    if let Some(dns_client) = dns_client.as_mut() {
+                        ip_to_host = dns_client.cache();
+                        let unresolved_ips = connections_to_procs
+                            .keys()
+                            .filter(|conn| !ip_to_host.contains_key(&conn.remote_socket.ip))
+                            .map(|conn| conn.remote_socket.ip)
+                            .collect::<Vec<_>>();
+
+                        dns_client.resolve(unresolved_ips);
                     }
                     {
                         let mut ui = ui.lock().unwrap();
@@ -194,9 +163,6 @@ where
                     let mut ui = ui.lock().unwrap();
                     ui.end();
                 }
-                if let Some(dns_queue) = Option::as_ref(&dns_queue) {
-                    dns_queue.end();
-                }
             }
         })
         .unwrap();
diff --git a/src/network/dns/client.rs b/src/network/dns/client.rs
new file mode 100644
index 0000000..bf479d4
--- /dev/null
+++ b/src/network/dns/client.rs
@@ -0,0 +1,80 @@
+use crate::network::dns::{resolver::Lookup, IpTable};
+use std::{
+    future::Future,
+    net::Ipv4Addr,
+    sync::{Arc, Mutex},
+    thread::{Builder, JoinHandle},
+};
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{self, Sender},
+};
+
+const CHANNEL_SIZE: usize = 1_000;
+
+pub struct Client {
+    cache: Arc<Mutex<IpTable>>,
+    tx: Option<Sender<Vec<Ipv4Addr>>>,
+    handle: Option<JoinHandle<()>>,
+}
+
+impl Client {
+    pub fn new<R, B>(resolver: R, background: B) -> Result<Self, failure::Error>
+    where
+        R: Lookup + Send + Sync + 'static,
+        B: Future<Output = ()> + Send + 'static,
+    {
+        let cache = Arc::new(Mutex::new(IpTable::new()));
+        let mut runtime = Runtime::new()?;
+        let (tx, mut rx) = mpsc::channel::<Vec<Ipv4Addr>>(CHANNEL_SIZE);
+
+        let handle = Builder::new().name("resolver".into()).spawn({
+            let cache = cache.clone();
+            move || {
+                runtime.block_on(async {
+                    let resolver = Arc::new(resolver);
+                    tokio::spawn(background);
+
+                    while let Some(ips) = rx.recv().await {
+                        for ip in ips {
+                            tokio::spawn({
+                                let resolver = resolver.clone();
+                                let cache = cache.clone();
+                                async move {
+                                    if let Some(name) = resolver.lookup(ip).await {
+                                        let mut cache = cache.lock().unwrap();
+                                        cache.insert(ip, name);
+                                    }
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        })?;
+
+        Ok(Self {
+            cache,
+            tx: Some(tx),
+            handle: Some(handle),
+        })
+    }
+
+    pub fn resolve(&mut self, ips: Vec<Ipv4Addr>) {
+        // Discard the message if the channel is full; it will be retried eventually.
+        let _ = self.tx.as_mut().unwrap().try_send(ips);
+    }
+
+    pub fn cache(&mut self) -> IpTable {
+        let cache = self.cache.lock().unwrap();
+        cache.clone()
+    }
+}
+
+impl Drop for Client {
+    fn drop(&mut self) {
+        // Do the Option dance to be able to drop the sender so that the receiver finishes and the thread can be joined.
+        drop(self.tx.take().unwrap());
+        self.handle.take().unwrap().join().unwrap();
+    }
+}
diff --git a/src/network/dns/mod.rs b/src/network/dns/mod.rs
new file mode 100644
index 0000000..be1464e
--- /dev/null
+++ b/src/network/dns/mod.rs
@@ -0,0 +1,9 @@
+use std::{collections::HashMap, net::Ipv4Addr};
+
+mod client;
+mod resolver;
+
+pub use client::*;
+pub use resolver::*;
+
+pub type IpTable = HashMap<Ipv4Addr, String>;
diff --git a/src/network/dns/resolver.rs b/src/network/dns/resolver.rs
new file mode 100644
index 0000000..69f6308
--- /dev/null
+++ b/src/network/dns/resolver.rs
@@ -0,0 +1,36 @@
+use async_trait::async_trait;
+use std::{future::Future, net::Ipv4Addr};
+use trust_dns_resolver::{error::ResolveErrorKind, AsyncResolver};
+
+#[async_trait]
+pub trait Lookup {
+    async fn lookup(&self, ip: Ipv4Addr) -> Option<String>;
+}
+
+pub struct Resolver(AsyncResolver);
+
+impl Resolver {
+    pub fn new() -> Result<(Self, impl Future<Output = ()>), failure::Error> {
+        let (resolver, background) = AsyncResolver::from_system_conf()?;
+        Ok((Self(resolver), background))
+    }
+}
+
+#[async_trait]
+impl Lookup for Resolver {
+    async fn lookup(&self, ip: Ipv4Addr) -> Option<String> {
+        let lookup_future = self.0.reverse_lookup(ip.into());
+        match lookup_future.await {
+            Ok(names) => {
+                // Take the first result and convert it to a string
+                names.into_iter().next().map(|name| name.to_string())
+            }
+            Err(e) => match e.kind() {
+                // If the IP is not associated with a hostname, store the IP
+                // so that we don't retry indefinitely
+                ResolveErrorKind::NoRecordsFound { .. } => Some(ip.to_string()),
+                _ => None,
+            },
+        }
+    }
+}
diff --git a/src/network/dns_queue.rs b/src/network/dns_queue.rs
deleted file mode 100644
index 0110df2..0000000
--- a/src/network/dns_queue.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use ::std::collections::VecDeque;
-use ::std::net::Ipv4Addr;
-use ::std::sync::{Condvar, Mutex};
-
-pub struct DnsQueue {
-    jobs: Mutex<Option<VecDeque<Ipv4Addr>>>,
-    cvar: Condvar,
-}
-
-impl DnsQueue {
-    pub fn new() -> Self {
-        DnsQueue {
-            jobs: Mutex::new(Some(VecDeque::new())),
-            cvar: Condvar::new(),
-        }
-    }
-}
-
-impl DnsQueue {
-    pub fn resolve_ips(&self, unresolved_ips: Vec<Ipv4Addr>) {
-        let mut jobs = self.jobs.lock().unwrap();
-        if let Some(queue) = jobs.as_mut() {
-            queue.extend(unresolved_ips);
-            self.cvar.notify_all();
-        }
-    }
-    pub fn wait_for_job(&self) -> Option<Ipv4Addr> {
-        let mut jobs = self.jobs.lock().unwrap();
-        loop {
-            match jobs.as_mut()?.pop_front() {
-                Some(job) => return Some(job),
-                None => jobs = self.cvar.wait(jobs).unwrap(),
-            }
-        }
-    }
-    pub fn end(&self) {
-        let mut jobs = self.jobs.lock().unwrap();
-        *jobs = None;
-        self.cvar.notify_all();
-    }
-}
diff --git a/src/network/mod.rs b/src/network/mod.rs
index 033414b..725a58b 100644
--- a/src/network/mod.rs
+++ b/src/network/mod.rs
@@ -1,9 +1,8 @@
 mod connection;
-mod dns_queue;
+pub mod dns;
 mod sniffer;
 mod utilization;
 
 pub use connection::*;
-pub use dns_queue::*;
 pub use sniffer::*;
 pub use utilization::*;
diff --git a/src/os/shared.rs b/src/os/shared.rs
index 1149725..313b941 100644
--- a/src/os/shared.rs
+++ b/src/os/shared.rs
@@ -5,7 +5,6 @@ use ::std::io::{self, stdin, Write};
 use ::termion::event::Event;
 use ::termion::input::TermRead;
 
-use ::std::net::IpAddr;
 use ::std::time;
 
 use signal_hook::iterator::Signals;
@@ -14,7 +13,7 @@ use signal_hook::iterator::Signals;
 use crate::os::linux::get_open_sockets;
 #[cfg(target_os = "macos")]
 use crate::os::macos::get_open_sockets;
-use crate::OsInputOutput;
+use crate::{network::dns, OsInputOutput};
 
 pub struct KeyboardEvents;
 
@@ -46,10 +45,6 @@ fn get_interface(interface_name: &str) -> Option<NetworkInterface> {
         .find(|iface| iface.name == interface_name)
 }
 
-fn lookup_addr(ip: &IpAddr) -> Option<String> {
-    ::dns_lookup::lookup_addr(ip).ok()
-}
-
 fn sigwinch() -> (Box<dyn Fn(Box<dyn Fn()>) + Send>, Box<dyn Fn() + Send>) {
     let signals = Signals::new(&[signal_hook::SIGWINCH]).unwrap();
     let on_winch = {
@@ -78,7 +73,7 @@ fn create_write_to_stdout() -> Box<dyn FnMut(String) + Send> {
     })
 }
 
-pub fn get_input(interface_name: &str) -> Result<OsInputOutput, failure::Error> {
+pub fn get_input(interface_name: &str, resolve: bool) -> Result<OsInputOutput, failure::Error> {
     let keyboard_events = Box::new(KeyboardEvents);
     let network_interface = match get_interface(interface_name) {
         Some(interface) => interface,
@@ -87,16 +82,22 @@ pub fn get_input(interface_name: &str) -> Result<OsInputOutput, failure::Error>
         }
     };
     let network_frames = get_datalink_channel(&network_interface)?;
-    let lookup_addr = Box::new(lookup_addr);
     let write_to_stdout = create_write_to_stdout();
     let (on_winch, cleanup) = sigwinch();
+    let dns_client = if resolve {
+        let (resolver, background) = dns::Resolver::new()?;
+        let dns_client = dns::Client::new(resolver, background)?;
+        Some(dns_client)
+    } else {
+        None
+    };
 
     Ok(OsInputOutput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
diff --git a/src/tests/cases/raw_mode.rs b/src/tests/cases/raw_mode.rs
index 3658f28..26a1801 100644
--- a/src/tests/cases/raw_mode.rs
+++ b/src/tests/cases/raw_mode.rs
@@ -1,5 +1,5 @@
 use crate::tests::fakes::{
-    create_fake_lookup_addr, create_fake_on_winch, get_interface, get_open_sockets, KeyboardEvents,
+    create_fake_dns_client, create_fake_on_winch, get_interface, get_open_sockets, KeyboardEvents,
     NetworkFrames, TestBackend,
 };
 
@@ -85,7 +85,7 @@ fn one_packet_of_traffic() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -102,7 +102,7 @@ fn one_packet_of_traffic() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -154,7 +154,7 @@ fn bi_directional_traffic() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -171,7 +171,7 @@ fn bi_directional_traffic() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -225,7 +225,7 @@ fn multiple_packets_of_traffic_from_different_connections() {
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let stdout = Arc::new(Mutex::new(Vec::new()));
     let write_to_stdout = Box::new({
         let stdout = stdout.clone();
@@ -242,7 +242,7 @@ fn multiple_packets_of_traffic_from_different_connections() {
         on_winch,
         cleanup,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         write_to_stdout,
     };
     let opts = Opt {
@@ -292,7 +292,7 @@ fn multiple_packets_of_traffic_from_single_connection() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -309,7 +309,7 @@ fn multiple_packets_of_traffic_from_single_connection() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -361,7 +361,7 @@ fn one_process_with_multiple_connections() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -378,7 +378,7 @@ fn one_process_with_multiple_connections() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -444,7 +444,7 @@ fn multiple_processes_with_multiple_connections() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -461,7 +461,7 @@ fn multiple_processes_with_multiple_connections() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -513,7 +513,7 @@ fn multiple_connections_from_remote_address() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -530,7 +530,7 @@ fn multiple_connections_from_remote_address() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -584,7 +584,7 @@ fn sustained_traffic_from_one_process() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -601,7 +601,7 @@ fn sustained_traffic_from_one_process() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -669,7 +669,7 @@ fn sustained_traffic_from_multiple_processes() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -686,7 +686,7 @@ fn sustained_traffic_from_multiple_processes() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -782,7 +782,7 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -799,7 +799,7 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -908,7 +908,7 @@ fn traffic_with_host_names() {
         IpAddr::V4("10.0.0.2".parse().unwrap()),
         String::from("i-like-cheese.com"),
     );
-    let lookup_addr = create_fake_lookup_addr(ips_to_hostnames);
+    let dns_client = create_fake_dns_client(ips_to_hostnames);
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -925,7 +925,7 @@ fn traffic_with_host_names() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -1034,7 +1034,7 @@ fn no_resolve_mode() {
         IpAddr::V4("10.0.0.2".parse().unwrap()),
         String::from("i-like-cheese.com"),
     );
-    let lookup_addr = create_fake_lookup_addr(ips_to_hostnames);
+    let dns_client = None;
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
@@ -1051,7 +1051,7 @@ fn no_resolve_mode() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
diff --git a/src/tests/cases/ui.rs b/src/tests/cases/ui.rs
index 4b81f87..f2f5374 100644
--- a/src/tests/cases/ui.rs
+++ b/src/tests/cases/ui.rs
@@ -1,6 +1,6 @@
 use crate::tests::fakes::TerminalEvent::*;
 use crate::tests::fakes::{
-    create_fake_lookup_addr, create_fake_on_winch, get_interface, get_open_sockets, KeyboardEvents,
+    create_fake_dns_client, create_fake_on_winch, get_interface, get_open_sockets, KeyboardEvents,
     NetworkFrames, TestBackend,
 };
 
@@ -71,7 +71,7 @@ fn basic_startup() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -81,7 +81,7 @@ fn basic_startup() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -130,7 +130,7 @@ fn one_packet_of_traffic() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -140,7 +140,7 @@ fn one_packet_of_traffic() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -201,7 +201,7 @@ fn bi_directional_traffic() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let write_to_stdout = Box::new({ move |_output: String| {} });
     let cleanup = Box::new(|| {});
@@ -211,7 +211,7 @@ fn bi_directional_traffic() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -274,7 +274,7 @@ fn multiple_packets_of_traffic_from_different_connections() {
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let write_to_stdout = Box::new({ move |_output: String| {} });
 
     let os_input = OsInputOutput {
@@ -284,7 +284,7 @@ fn multiple_packets_of_traffic_from_different_connections() {
         on_winch,
         cleanup,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         write_to_stdout,
     };
     let opts = Opt {
@@ -343,7 +343,7 @@ fn multiple_packets_of_traffic_from_single_connection() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -353,7 +353,7 @@ fn multiple_packets_of_traffic_from_single_connection() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -414,7 +414,7 @@ fn one_process_with_multiple_connections() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -424,7 +424,7 @@ fn one_process_with_multiple_connections() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -499,7 +499,7 @@ fn multiple_processes_with_multiple_connections() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -509,7 +509,7 @@ fn multiple_processes_with_multiple_connections() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -570,7 +570,7 @@ fn multiple_connections_from_remote_address() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -580,7 +580,7 @@ fn multiple_connections_from_remote_address() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -643,7 +643,7 @@ fn sustained_traffic_from_one_process() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -653,7 +653,7 @@ fn sustained_traffic_from_one_process() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -730,7 +730,7 @@ fn sustained_traffic_from_multiple_processes() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -740,7 +740,7 @@ fn sustained_traffic_from_multiple_processes() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -845,7 +845,7 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -855,7 +855,7 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -973,7 +973,7 @@ fn traffic_with_host_names() {
         IpAddr::V4("10.0.0.2".parse().unwrap()),
         String::from("i-like-cheese.com"),
     );
-    let lookup_addr = create_fake_lookup_addr(ips_to_hostnames);
+    let dns_client = create_fake_dns_client(ips_to_hostnames);
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -983,7 +983,7 @@ fn traffic_with_host_names() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -1101,7 +1101,7 @@ fn no_resolve_mode() {
         IpAddr::V4("10.0.0.2".parse().unwrap()),
         String::from("i-like-cheese.com"),
     );
-    let lookup_addr = create_fake_lookup_addr(ips_to_hostnames);
+    let dns_client = None;
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -1111,7 +1111,7 @@ fn no_resolve_mode() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -1163,7 +1163,7 @@ fn traffic_with_winch_event() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(true);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -1173,7 +1173,7 @@ fn traffic_with_winch_event() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -1249,7 +1249,7 @@ fn layout_full_width_under_30_height() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);
     let cleanup = Box::new(|| {});
     let write_to_stdout = Box::new({ move |_output: String| {} });
@@ -1259,7 +1259,7 @@ fn layout_full_width_under_30_height() {
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr,
+        dns_client,
         on_winch,
         cleanup,
         write_to_stdout,
@@ -1334,7 +1334,7 @@ fn layout_under_150_width_full_height() {
         terminal_height,
     );
     let network_interface = get_interface();
-    let lookup_addr = create_fake_lookup_addr(HashMap::new());
+    let dns_client = create_fake_dns_client(HashMap::new());
     let on_winch = create_fake_on_winch(false);