diff --git a/external/cursive b/external/cursive
index c6e77531..298b1254 160000
--- a/external/cursive
+++ b/external/cursive
@@ -1 +1 @@
-Subproject commit c6e775311417fbd1cb57aab313cc2f0504d74627
+Subproject commit 298b12545798d6b6a9e1a469467b89a15106cf7e
diff --git a/external/cursive-flexi-logger-view b/external/cursive-flexi-logger-view
index bdfdcb0b..7f998c82 160000
--- a/external/cursive-flexi-logger-view
+++ b/external/cursive-flexi-logger-view
@@ -1 +1 @@
-Subproject commit bdfdcb0b962cc28651e3c205393da1a3b330e739
+Subproject commit 7f998c82d171e6de783b3250006ae8e2b6316597
diff --git a/external/cursive_buffered_backend b/external/cursive_buffered_backend
index f254ffdf..70c55412 160000
--- a/external/cursive_buffered_backend
+++ b/external/cursive_buffered_backend
@@ -1 +1 @@
-Subproject commit f254ffdf8a84ff714844fd7d27e57deab2be00e3
+Subproject commit 70c55412ea1ee97f9d60eb25e3a514b6968caa35
diff --git a/external/if-addrs b/external/if-addrs
index d16e76ce..5a9754fe 160000
--- a/external/if-addrs
+++ b/external/if-addrs
@@ -1 +1 @@
-Subproject commit d16e76ce1f6edb03300e3f9ee264fcd611799fdb
+Subproject commit 5a9754fee6e92a7c6e8d8e93738d252acf58cb1c
diff --git a/veilid-cli/src/client_api_connection.rs b/veilid-cli/src/client_api_connection.rs
index 26303266..d2d16e82 100644
--- a/veilid-cli/src/client_api_connection.rs
+++ b/veilid-cli/src/client_api_connection.rs
@@ -16,7 +16,7 @@ struct VeilidClientImpl {
 
 impl VeilidClientImpl {
     pub fn new(comproc: CommandProcessor) -> Self {
-        Self { comproc: comproc }
+        Self { comproc }
     }
 }
 
@@ -64,7 +64,7 @@ impl ClientApiConnection {
     pub fn new(comproc: CommandProcessor) -> Self {
         Self {
             inner: Rc::new(RefCell::new(ClientApiConnectionInner {
-                comproc: comproc,
+                comproc,
                 connect_addr: None,
                 disconnector: None,
                 server: None,
@@ -75,9 +75,9 @@ impl ClientApiConnection {
 
     async fn handle_connection(&mut self) -> Result<()> {
         trace!("ClientApiConnection::handle_connection");
-        let connect_addr = self.inner.borrow().connect_addr.unwrap().clone();
+        let connect_addr = self.inner.borrow().connect_addr.unwrap();
         // Connect the TCP socket
-        let stream = async_std::net::TcpStream::connect(connect_addr.clone()).await?;
+        let stream = async_std::net::TcpStream::connect(connect_addr).await?;
         // If it succeed, disable nagle algorithm
         stream.set_nodelay(true)?;
 
diff --git a/veilid-cli/src/command_processor.rs b/veilid-cli/src/command_processor.rs
index c9a4de23..deeea36e 100644
--- a/veilid-cli/src/command_processor.rs
+++ b/veilid-cli/src/command_processor.rs
@@ -59,7 +59,7 @@ impl CommandProcessor {
     pub fn new(ui: UI, settings: &Settings) -> Self {
         Self {
             inner: Rc::new(RefCell::new(CommandProcessorInner {
-                ui: ui,
+                ui,
                 capi: None,
                 reconnect: settings.autoreconnect,
                 finished: false,
@@ -205,7 +205,7 @@ detach              - detach the server from the Veilid network
             // Loop while we want to keep the connection
             let mut first = true;
             while self.inner().reconnect {
-                let server_addr_opt = self.inner_mut().server_addr.clone();
+                let server_addr_opt = self.inner_mut().server_addr;
                 let server_addr = match server_addr_opt {
                     None => break,
                     Some(addr) => addr,
@@ -213,15 +213,15 @@ detach              - detach the server from the Veilid network
                 if first {
                     info!("Connecting to server at {}", server_addr);
                     self.set_connection_state(ConnectionState::Retrying(
-                        server_addr.clone(),
+                        server_addr,
                         SystemTime::now(),
                     ));
                 } else {
                     debug!("Retrying connection to {}", server_addr);
                 }
                 let mut capi = self.capi();
-                let res = capi.connect(server_addr.clone()).await;
-                if let Ok(_) = res {
+                let res = capi.connect(server_addr).await;
+                if res.is_ok() {
                     info!(
                         "Connection to server at {} terminated normally",
                         server_addr
@@ -234,7 +234,7 @@ detach              - detach the server from the Veilid network
                 }
 
                 self.set_connection_state(ConnectionState::Retrying(
-                    server_addr.clone(),
+                    server_addr,
                     SystemTime::now(),
                 ));
 
@@ -260,7 +260,7 @@ detach              - detach the server from the Veilid network
         self.inner_mut().server_addr = server_addr;
     }
     pub fn get_server_address(&self) -> Option<SocketAddr> {
-        self.inner().server_addr.clone()
+        self.inner().server_addr
     }
     // called by client_api_connection
     // calls into ui
diff --git a/veilid-cli/src/main.rs b/veilid-cli/src/main.rs
index 61a29173..e4e36e25 100644
--- a/veilid-cli/src/main.rs
+++ b/veilid-cli/src/main.rs
@@ -70,7 +70,7 @@ async fn main() -> Result<()> {
         matches.occurrences_of("config-file") == 0,
         matches.value_of_os("config-file").unwrap(),
     )
-    .map_err(|x| Box::new(x))?;
+    .map_err(Box::new)?;
 
     // Set config from command line
     if matches.occurrences_of("debug") != 0 {
diff --git a/veilid-cli/src/settings.rs b/veilid-cli/src/settings.rs
index c21edc1d..0be42d26 100644
--- a/veilid-cli/src/settings.rs
+++ b/veilid-cli/src/settings.rs
@@ -1,7 +1,7 @@
-use config;
+
 use directories::*;
-use log;
-use serde;
+
+
 use serde_derive::*;
 use std::ffi::OsStr;
 use std::net::{SocketAddr, ToSocketAddrs};
@@ -118,7 +118,7 @@ impl<'de> serde::Deserialize<'de> for NamedSocketAddrs {
         let s = String::deserialize(deserializer)?;
         let addr_iter = s
             .to_socket_addrs()
-            .map_err(|x| serde::de::Error::custom(x))?;
+            .map_err(serde::de::Error::custom)?;
         Ok(NamedSocketAddrs {
             name: s,
             addrs: addr_iter.collect(),
diff --git a/veilid-cli/src/ui.rs b/veilid-cli/src/ui.rs
index de299163..bb66494f 100644
--- a/veilid-cli/src/ui.rs
+++ b/veilid-cli/src/ui.rs
@@ -26,7 +26,7 @@ struct Dirty<T> {
 impl<T> Dirty<T> {
     pub fn new(value: T) -> Self {
         Self {
-            value: value,
+            value,
             dirty: true,
         }
     }
@@ -122,7 +122,7 @@ impl UI {
                 cmd_history_position: 0,
                 cmd_history_max_size: settings.interface.command_line.history_size,
                 connection_dialog_state: None,
-                cb_sink: cb_sink,
+                cb_sink,
             })),
         };
 
@@ -203,7 +203,7 @@ impl UI {
 
         siv.add_fullscreen_layer(mainlayout);
 
-        UI::setup_colors(&mut siv, &mut inner, &settings);
+        UI::setup_colors(&mut siv, &mut inner, settings);
         UI::setup_quit_handler(&mut siv);
 
         drop(inner);
@@ -347,7 +347,7 @@ impl UI {
     }
     pub fn add_node_event(&mut self, event: &str) {
         let inner = self.inner.borrow_mut();
-        let color = inner.log_colors.get(&Level::Info).unwrap().clone();
+        let color = *inner.log_colors.get(&Level::Info).unwrap();
         for line in event.lines() {
             cursive_flexi_logger_view::push_to_log(StyledString::styled(line, color));
         }
@@ -470,11 +470,10 @@ impl UI {
         match Self::run_command(s, text) {
             Ok(_) => {}
             Err(e) => {
-                let color = Self::inner_mut(s)
+                let color = *Self::inner_mut(s)
                     .log_colors
                     .get(&Level::Error)
-                    .unwrap()
-                    .clone();
+                    .unwrap();
 
                 cursive_flexi_logger_view::push_to_log(StyledString::styled(
                     format!("> {}", text),
@@ -668,7 +667,7 @@ impl UI {
             return true;
         }
 
-        return false;
+        false
     }
 
     fn refresh_connection_dialog(s: &mut Cursive) {
@@ -686,13 +685,13 @@ impl UI {
                 };
                 debug!("address is {}", addr);
                 let mut edit = s.find_name::<EditView>("connection-address").unwrap();
-                edit.set_content(addr.to_string());
+                edit.set_content(addr);
                 edit.set_enabled(true);
                 let mut dlg = s.find_name::<Dialog>("connection-dialog").unwrap();
                 dlg.add_button("Connect", Self::submit_connection_address);
             }
             ConnectionState::Connected(_, _) => {
-                return;
+                
             }
             ConnectionState::Retrying(addr, _) => {
                 //
@@ -717,7 +716,7 @@ impl UI {
 
         match inner.ui_state.connection_state.get() {
             ConnectionState::Disconnected => {
-                status.append_styled(format!("Disconnected "), ColorStyle::highlight_inactive());
+                status.append_styled("Disconnected ".to_string(), ColorStyle::highlight_inactive());
                 status.append_styled("|", ColorStyle::highlight_inactive());
             }
             ConnectionState::Retrying(addr, _) => {
diff --git a/veilid-server/src/client_api.rs b/veilid-server/src/client_api.rs
index 4ce9c377..467f6595 100644
--- a/veilid-server/src/client_api.rs
+++ b/veilid-server/src/client_api.rs
@@ -44,7 +44,7 @@ struct RegistrationImpl {
 impl RegistrationImpl {
     fn new(id: u64, registrations: Rc<RefCell<RegistrationMap>>) -> Self {
         Self {
-            id: id,
+            id,
             registration_map: registrations,
         }
     }
@@ -75,7 +75,7 @@ impl VeilidServerImpl {
         Self {
             next_id: 0,
             registration_map: Rc::new(RefCell::new(RegistrationMap::new())),
-            veilid_api: veilid_api,
+            veilid_api,
         }
     }
 }
@@ -175,7 +175,7 @@ impl ClientApi {
     pub fn new(veilid_api: veilid_core::VeilidAPI) -> Rc<Self> {
         Rc::new(Self {
             inner: RefCell::new(ClientApiInner {
-                veilid_api: veilid_api,
+                veilid_api,
                 registration_map: Rc::new(RefCell::new(RegistrationMap::new())),
                 stop: Eventual::new(),
                 join_handle: None,
@@ -283,13 +283,10 @@ impl ClientApi {
             let registration_map2 = registration_map1.clone();
             async_std::task::spawn_local(request.send().promise.map(move |r| match r {
                 Ok(_) => {
-                    registration_map2
+                    if let Some(ref mut s) = registration_map2
                         .borrow_mut()
                         .registrations
-                        .get_mut(&id)
-                        .map(|ref mut s| {
-                            s.requests_in_flight -= 1;
-                        });
+                        .get_mut(&id) { s.requests_in_flight -= 1; }
                 }
                 Err(e) => {
                     debug!("Got error: {:?}. Dropping registation.", e);
@@ -309,7 +306,7 @@ impl ClientApi {
 
         let bind_futures = bind_addrs
             .iter()
-            .map(|addr| self.clone().handle_incoming(addr.clone(), client.clone()));
+            .map(|addr| self.clone().handle_incoming(*addr, client.clone()));
         let bind_futures_join = futures::future::try_join_all(bind_futures);
         self.inner.borrow_mut().join_handle = Some(async_std::task::spawn_local(bind_futures_join));
     }
diff --git a/veilid-server/src/main.rs b/veilid-server/src/main.rs
index 2597d0df..9c97645a 100644
--- a/veilid-server/src/main.rs
+++ b/veilid-server/src/main.rs
@@ -7,7 +7,7 @@ pub mod veilid_client_capnp {
     include!(concat!(env!("OUT_DIR"), "/proto/veilid_client_capnp.rs"));
 }
 
-use cfg_if;
+
 
 cfg_if::cfg_if! {
     if #[cfg(windows)] {
diff --git a/veilid-server/src/settings.rs b/veilid-server/src/settings.rs
index 4185eed2..e1e93e51 100644
--- a/veilid-server/src/settings.rs
+++ b/veilid-server/src/settings.rs
@@ -1,8 +1,8 @@
-use config;
+
 use directories::*;
 use log::*;
 use parking_lot::*;
-use serde;
+
 use serde_derive::*;
 use std::ffi::OsStr;
 use std::net::{SocketAddr, ToSocketAddrs};
@@ -184,7 +184,7 @@ impl FromStr for ParsedURL {
 
         Ok(Self {
             urlstring: s.to_string(),
-            url: url,
+            url,
         })
     }
 }
@@ -195,7 +195,7 @@ impl<'de> serde::Deserialize<'de> for ParsedURL {
         D: serde::Deserializer<'de>,
     {
         let s = String::deserialize(deserializer)?;
-        Ok(ParsedURL::from_str(s.as_str()).map_err(|x| serde::de::Error::custom(x))?)
+        ParsedURL::from_str(s.as_str()).map_err(serde::de::Error::custom)
     }
 }
 
@@ -222,7 +222,7 @@ impl<'de> serde::Deserialize<'de> for NamedSocketAddrs {
         D: serde::Deserializer<'de>,
     {
         let s = String::deserialize(deserializer)?;
-        Ok(NamedSocketAddrs::from_str(s.as_str()).map_err(|x| serde::de::Error::custom(x))?)
+        NamedSocketAddrs::from_str(s.as_str()).map_err(serde::de::Error::custom)
     }
 }
 
@@ -709,11 +709,7 @@ impl Settings {
                     inner.core.network.protocol.udp.listen_address.name.clone(),
                 )),
                 "network.protocol.udp.public_address" => Ok(Box::new(
-                    if let Some(a) = &inner.core.network.protocol.udp.public_address {
-                        Some(a.name.clone())
-                    } else {
-                        None
-                    },
+                    inner.core.network.protocol.udp.public_address.as_ref().map(|a| a.name.clone()),
                 )),
                 "network.protocol.tcp.connect" => {
                     Ok(Box::new(inner.core.network.protocol.tcp.connect))
@@ -728,11 +724,7 @@ impl Settings {
                     inner.core.network.protocol.tcp.listen_address.name.clone(),
                 )),
                 "network.protocol.tcp.public_address" => Ok(Box::new(
-                    if let Some(a) = &inner.core.network.protocol.tcp.public_address {
-                        Some(a.name.clone())
-                    } else {
-                        None
-                    },
+                    inner.core.network.protocol.tcp.public_address.as_ref().map(|a| a.name.clone()),
                 )),
                 "network.protocol.ws.connect" => {
                     Ok(Box::new(inner.core.network.protocol.ws.connect))
@@ -748,11 +740,7 @@ impl Settings {
                     Ok(Box::new(inner.core.network.protocol.ws.path.clone()))
                 }
                 "network.protocol.ws.public_address" => Ok(Box::new(
-                    if let Some(a) = &inner.core.network.protocol.ws.public_address {
-                        Some(a.name.clone())
-                    } else {
-                        None
-                    },
+                    inner.core.network.protocol.ws.public_address.as_ref().map(|a| a.name.clone()),
                 )),
                 "network.protocol.wss.connect" => {
                     Ok(Box::new(inner.core.network.protocol.wss.connect))
@@ -770,11 +758,7 @@ impl Settings {
                     Ok(Box::new(inner.core.network.protocol.wss.path.clone()))
                 }
                 "network.protocol.wss.public_address" => Ok(Box::new(
-                    if let Some(a) = &inner.core.network.protocol.wss.public_address {
-                        Some(a.name.clone())
-                    } else {
-                        None
-                    },
+                    inner.core.network.protocol.wss.public_address.as_ref().map(|a| a.name.clone()),
                 )),
                 "network.leases.max_server_signal_leases" => {
                     Ok(Box::new(inner.core.network.leases.max_server_signal_leases))
@@ -845,7 +829,7 @@ mod tests {
             veilid_core::DHTKeySecret::default()
         );
         //
-        assert!(s.core.network.bootstrap.len() == 0);
+        assert!(s.core.network.bootstrap.is_empty());
         //
         assert_eq!(s.core.network.rpc.concurrency, 0);
         assert_eq!(s.core.network.rpc.queue_size, 1024);
diff --git a/veilid-server/src/unix.rs b/veilid-server/src/unix.rs
index 5f7f44aa..2fa6f630 100644
--- a/veilid-server/src/unix.rs
+++ b/veilid-server/src/unix.rs
@@ -168,7 +168,7 @@ pub async fn main() -> Result<(), String> {
             Some(x) => {
                 println!("Overriding bootstrap with: ");
                 let mut out: Vec<settings::ParsedURL> = Vec::new();
-                for x in x.split(",") {
+                for x in x.split(',') {
                     println!("    {}", x);
                     out.push(
                         settings::ParsedURL::from_str(x)
@@ -251,7 +251,7 @@ pub async fn main() -> Result<(), String> {
             move |change: veilid_core::VeilidStateChange| -> veilid_core::SystemPinBoxFuture<()> {
                 let sender = sender.clone();
                 Box::pin(async move {
-                    if let Err(_) = sender.send(change).await {
+                    if sender.send(change).await.is_err() {
                         error!("error sending state change callback");
                     }
                 })
@@ -308,11 +308,7 @@ pub async fn main() -> Result<(), String> {
     // Idle while waiting to exit
     let shutdown_switch = {
         let shutdown_switch_locked = SHUTDOWN_SWITCH.lock();
-        if let Some(ss) = &*shutdown_switch_locked {
-            Some(ss.instance())
-        } else {
-            None
-        }
+        (*shutdown_switch_locked).as_ref().map(|ss| ss.instance())
     };
     if let Some(shutdown_switch) = shutdown_switch {
         shutdown_switch.await;