Merge branch 'fix-clippy-warnings'

19 files changed, 84 insertions, 89 deletions

diff --git a/mullvad-daemon/src/account_history.rs b/mullvad-daemon/src/account_history.rs
index ab6797a6fa..486c258177 100644
--- a/mullvad-daemon/src/account_history.rs
+++ b/mullvad-daemon/src/account_history.rs
@@ -85,9 +85,9 @@ impl AccountHistory {
     }
 
     /// Remove account token from the account history
-    pub fn remove_account_token(&mut self, account_token: AccountToken) -> Result<()> {
+    pub fn remove_account_token(&mut self, account_token: &AccountToken) -> Result<()> {
         self.accounts
-            .retain(|existing_token| existing_token != &account_token);
+            .retain(|existing_token| existing_token != account_token);
         self.save()
     }
 
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index e88c4cd0e1..541d904875 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -147,7 +147,7 @@ impl DaemonExecutionState {
         };
     }
 
-    pub fn is_running(&mut self) -> bool {
+    pub fn is_running(&self) -> bool {
         use self::DaemonExecutionState::*;
 
         match self {
@@ -180,7 +180,7 @@ pub struct Daemon {
 }
 
 impl Daemon {
-    pub fn new(
+    pub fn start(
         log_dir: Option<PathBuf>,
         resource_dir: PathBuf,
         cache_dir: PathBuf,
@@ -307,16 +307,17 @@ impl Daemon {
     fn handle_event(&mut self, event: DaemonEvent) -> Result<()> {
         use DaemonEvent::*;
         match event {
-            TunnelStateTransition(transition) => {
-                Ok(self.handle_tunnel_state_transition(transition))
-            }
+            TunnelStateTransition(transition) => self.handle_tunnel_state_transition(transition),
             GenerateTunnelParameters(tunnel_parameters_tx, retry_attempt) => {
-                Ok(self.handle_generate_tunnel_parameters(tunnel_parameters_tx, retry_attempt))
+                self.handle_generate_tunnel_parameters(&tunnel_parameters_tx, retry_attempt)
+            }
+            ManagementInterfaceEvent(event) => self.handle_management_interface_event(event),
+            ManagementInterfaceExited => {
+                return Err(ErrorKind::ManagementInterfaceError("Server exited unexpectedly").into())
             }
-            ManagementInterfaceEvent(event) => Ok(self.handle_management_interface_event(event)),
-            ManagementInterfaceExited => self.handle_management_interface_exited(),
-            TriggerShutdown => Ok(self.handle_trigger_shutdown_event()),
+            TriggerShutdown => self.handle_trigger_shutdown_event(),
         }
+        Ok(())
     }
 
     fn handle_tunnel_state_transition(&mut self, tunnel_state: TunnelStateTransition) {
@@ -330,9 +331,8 @@ impl Daemon {
             Blocked(ref reason) => {
                 info!("Blocking all network connections, reason: {}", reason);
 
-                match reason {
-                    BlockReason::AuthFailed(_) => self.schedule_reconnect(Duration::from_secs(60)),
-                    _ => {}
+                if let BlockReason::AuthFailed(_) = reason {
+                    self.schedule_reconnect(Duration::from_secs(60))
                 }
             }
             _ => {}
@@ -345,13 +345,13 @@ impl Daemon {
 
     fn handle_generate_tunnel_parameters(
         &mut self,
-        tunnel_parameters_tx: mpsc::Sender<TunnelParameters>,
+        tunnel_parameters_tx: &mpsc::Sender<TunnelParameters>,
         retry_attempt: u32,
     ) {
         let result = self
             .settings
             .get_account_token()
-            .ok_or(Error::from("No account token configured"))
+            .ok_or_else(|| Error::from("No account token configured"))
             .map(|account_token| {
                 match self.settings.get_relay_settings() {
                     RelaySettings::CustomTunnelEndpoint(custom_relay) => custom_relay
@@ -370,7 +370,7 @@ impl Daemon {
                     tunnel_parameters_tx
                         .send(TunnelParameters {
                             endpoint,
-                            options: self.settings.get_tunnel_options().clone(),
+                            options: self.settings.get_tunnel_options(),
                             username: account_token,
                         })
                         .map_err(|_| Error::from("Tunnel parameters receiver stopped listening"))
@@ -641,15 +641,11 @@ impl Daemon {
     }
 
     fn oneshot_send<T>(tx: oneshot::Sender<T>, t: T, msg: &'static str) {
-        if let Err(_) = tx.send(t) {
+        if tx.send(t).is_err() {
             warn!("Unable to send {} to management interface client", msg);
         }
     }
 
-    fn handle_management_interface_exited(&self) -> Result<()> {
-        Err(ErrorKind::ManagementInterfaceError("Server exited unexpectedly").into())
-    }
-
     fn handle_trigger_shutdown_event(&mut self) {
         self.state.shutdown(&self.tunnel_state);
         self.disconnect_tunnel();
diff --git a/mullvad-daemon/src/main.rs b/mullvad-daemon/src/main.rs
index 60f3b9a878..d06f0101e1 100644
--- a/mullvad-daemon/src/main.rs
+++ b/mullvad-daemon/src/main.rs
@@ -53,7 +53,7 @@ fn main() {
     let exit_code = match run() {
         Ok(_) => 0,
         Err(error) => {
-            if let &ErrorKind::LogError(_) = error.kind() {
+            if let ErrorKind::LogError(_) = error.kind() {
                 eprintln!("{}", error.display_chain());
             } else {
                 error!("{}", error.display_chain());
@@ -89,11 +89,11 @@ fn run() -> Result<()> {
         info!("Logging to {}", log_dir.display());
     }
 
-    run_platform(config)
+    run_platform(&config)
 }
 
 #[cfg(windows)]
-fn run_platform(config: cli::Config) -> Result<()> {
+fn run_platform(config: &cli::Config) -> Result<()> {
     if config.run_as_service {
         system_service::run()
     } else {
@@ -111,11 +111,11 @@ fn run_platform(config: cli::Config) -> Result<()> {
 }
 
 #[cfg(not(windows))]
-fn run_platform(config: cli::Config) -> Result<()> {
+fn run_platform(config: &cli::Config) -> Result<()> {
     run_standalone(config)
 }
 
-fn run_standalone(config: cli::Config) -> Result<()> {
+fn run_standalone(config: &cli::Config) -> Result<()> {
     if !running_as_admin() {
         warn!("Running daemon as a non-administrator user, clients might refuse to connect");
     }
@@ -133,7 +133,7 @@ fn run_standalone(config: cli::Config) -> Result<()> {
     Ok(())
 }
 
-fn create_daemon(config: cli::Config) -> Result<Daemon> {
+fn create_daemon(config: &cli::Config) -> Result<Daemon> {
     let log_dir = if config.log_to_file {
         Some(mullvad_paths::log_dir().chain_err(|| "Unable to get log directory")?)
     } else {
@@ -142,7 +142,7 @@ fn create_daemon(config: cli::Config) -> Result<Daemon> {
     let resource_dir = mullvad_paths::get_resource_dir();
     let cache_dir = mullvad_paths::cache_dir().chain_err(|| "Unable to get cache dir")?;
 
-    Daemon::new(
+    Daemon::start(
         log_dir,
         resource_dir,
         cache_dir,
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 318d0a6210..43d3ebca83 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -212,7 +212,7 @@ impl ManagementInterfaceServer {
         let server = talpid_ipc::IpcServer::start_with_metadata(
             meta_io,
             meta_extractor,
-            path.to_string_lossy().to_string(),
+            &path.to_string_lossy(),
         )?;
         Ok(ManagementInterfaceServer {
             server,
@@ -301,7 +301,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterface<T> {
     }
 
     fn unsubscribe<V>(
-        id: SubscriptionId,
+        id: &SubscriptionId,
         subscriptions_lock: &RwLock<HashMap<SubscriptionId, pubsub::Sink<V>>>,
     ) -> BoxFuture<(), Error> {
         let was_removed = subscriptions_lock.write().unwrap().remove(&id).is_some();
@@ -329,9 +329,9 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterface<T> {
     /// Converts the given error to an error that can be given to the caller of the API.
     /// Will let any actual RPC error through as is, any other error is changed to an internal
     /// error.
-    fn map_rpc_error(error: mullvad_rpc::Error) -> Error {
+    fn map_rpc_error(error: &mullvad_rpc::Error) -> Error {
         match error.kind() {
-            &mullvad_rpc::ErrorKind::JsonRpcError(ref rpc_error) => {
+            mullvad_rpc::ErrorKind::JsonRpcError(ref rpc_error) => {
                 // We have to manually copy the error since we have different
                 // versions of the jsonrpc_core library at the moment.
                 Error {
@@ -372,7 +372,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
                         "Unable to get account data from API: {}",
                         error.display_chain()
                     );
-                    Self::map_rpc_error(error)
+                    Self::map_rpc_error(&error)
                 })
             });
         Box::new(future)
@@ -517,7 +517,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
         debug!("remove_account_from_history");
         Box::new(future::result(
             self.load_history()
-                .and_then(|mut history| history.remove_account_token(account_token))
+                .and_then(|mut history| history.remove_account_token(&account_token))
                 .map_err(|error| {
                     error!(
                         "Unable to remove account from history: {}",
@@ -579,7 +579,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
                         "Unable to get version data from API: {}",
                         error.display_chain()
                     );
-                    Self::map_rpc_error(error)
+                    Self::map_rpc_error(&error)
                 })
             });
 
@@ -597,7 +597,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
 
     fn new_state_unsubscribe(&self, id: SubscriptionId) -> BoxFuture<(), Error> {
         debug!("new_state_unsubscribe");
-        Self::unsubscribe(id, &self.subscriptions.new_state_subscriptions)
+        Self::unsubscribe(&id, &self.subscriptions.new_state_subscriptions)
     }
 
     fn settings_subscribe(&self, _: Self::Metadata, subscriber: pubsub::Subscriber<Settings>) {
@@ -607,7 +607,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
 
     fn settings_unsubscribe(&self, id: SubscriptionId) -> BoxFuture<(), Error> {
         debug!("settings_unsubscribe");
-        Self::unsubscribe(id, &self.subscriptions.settings_subscriptions)
+        Self::unsubscribe(&id, &self.subscriptions.settings_subscriptions)
     }
 }
 
diff --git a/mullvad-daemon/src/relays.rs b/mullvad-daemon/src/relays.rs
index a36ded1628..c3c1a967ed 100644
--- a/mullvad-daemon/src/relays.rs
+++ b/mullvad-daemon/src/relays.rs
@@ -368,7 +368,7 @@ impl RelaySelector {
         self.rng
             .choose(&tunnels.openvpn)
             .cloned()
-            .map(|openvpn_endpoint| TunnelEndpointData::OpenVpn(openvpn_endpoint))
+            .map(TunnelEndpointData::OpenVpn)
     }
 
     /// Try to read the relays, first from cache and if that fails from the resources.
diff --git a/mullvad-daemon/src/system_service.rs b/mullvad-daemon/src/system_service.rs
index ee08cae841..6a2d54b326 100644
--- a/mullvad-daemon/src/system_service.rs
+++ b/mullvad-daemon/src/system_service.rs
@@ -67,7 +67,7 @@ fn run_service() -> Result<()> {
         .unwrap();
 
     let config = cli::get_config();
-    let result = ::create_daemon(config).and_then(|daemon| {
+    let result = ::create_daemon(&config).and_then(|daemon| {
         let shutdown_handle = daemon.shutdown_handle();
 
         // Register monitor that translates `ServiceControl` to Daemon events
diff --git a/mullvad-ipc-client/src/lib.rs b/mullvad-ipc-client/src/lib.rs
index ca08f92333..e450b7cd6d 100644
--- a/mullvad-ipc-client/src/lib.rs
+++ b/mullvad-ipc-client/src/lib.rs
@@ -105,7 +105,7 @@ pub fn new_standalone_transport<
 
     rx.wait()
         .chain_err(|| ErrorKind::TransportError)?
-        .map(|client_handle| DaemonRpcClient::new(client_handle))
+        .map(DaemonRpcClient::new)
 }
 
 fn spawn_transport<F: Send + FnOnce(String) -> Result<T>, T: jsonrpc_client_core::Transport>(
diff --git a/mullvad-problem-report/src/main.rs b/mullvad-problem-report/src/main.rs
index cc5ff62ef3..1ffa870f4e 100644
--- a/mullvad-problem-report/src/main.rs
+++ b/mullvad-problem-report/src/main.rs
@@ -46,7 +46,7 @@ const REPORT_MAX_SIZE: usize = (5 * LOG_MAX_READ_BYTES) + EXTRA_BYTES;
 
 
 /// Field delimeter in generated problem report
-const LOG_DELIMITER: &'static str = "====================";
+const LOG_DELIMITER: &str = "====================";
 
 /// Line separator character sequence
 #[cfg(not(windows))]
diff --git a/mullvad-rpc/src/rest.rs b/mullvad-rpc/src/rest.rs
index 988dfba7c0..ea374b14b8 100644
--- a/mullvad-rpc/src/rest.rs
+++ b/mullvad-rpc/src/rest.rs
@@ -59,7 +59,7 @@ fn create_request_processing_future<CC: hyper::client::Connect>(
             .and_then(|response: hyper::Response| response.body().concat2().from_err())
             .map(|response_chunk| response_chunk.to_vec())
             .then(move |response_result| {
-                if let Err(_) = response_tx.send(response_result) {
+                if response_tx.send(response_result).is_err() {
                     warn!("Unable to send response back to caller");
                 }
                 Ok(())
diff --git a/mullvad-types/src/settings.rs b/mullvad-types/src/settings.rs
index bca23e1786..ef7a981652 100644
--- a/mullvad-types/src/settings.rs
+++ b/mullvad-types/src/settings.rs
@@ -191,7 +191,7 @@ impl Settings {
         }
     }
 
-    pub fn get_tunnel_options(&self) -> &TunnelOptions {
-        &self.tunnel_options
+    pub fn get_tunnel_options(&self) -> TunnelOptions {
+        self.tunnel_options
     }
 }
diff --git a/talpid-core/src/security/linux/dns/network_manager.rs b/talpid-core/src/security/linux/dns/network_manager.rs
index 5bdddc7174..6db4893336 100644
--- a/talpid-core/src/security/linux/dns/network_manager.rs
+++ b/talpid-core/src/security/linux/dns/network_manager.rs
@@ -46,7 +46,7 @@ impl NetworkManager {
         Ok(())
     }
 
-    fn as_manager<'a>(&'a self) -> dbus::ConnPath<'a, &'a dbus::Connection> {
+    fn as_manager(&self) -> dbus::ConnPath<&dbus::Connection> {
         self.dbus_connection
             .with_path(NM_BUS, NM_OBJECT_PATH, RPC_TIMEOUT_MS)
     }
diff --git a/talpid-core/src/security/linux/dns/static_resolv_conf.rs b/talpid-core/src/security/linux/dns/static_resolv_conf.rs
index 6ece9ba44c..06d3bf3134 100644
--- a/talpid-core/src/security/linux/dns/static_resolv_conf.rs
+++ b/talpid-core/src/security/linux/dns/static_resolv_conf.rs
@@ -1,7 +1,6 @@
 extern crate notify;
 
 use std::net::IpAddr;
-use std::ops::DerefMut;
 use std::sync::{mpsc, Arc, Mutex, MutexGuard};
 use std::{fs, io, thread};
 
@@ -124,18 +123,18 @@ impl DnsWatcher {
             .watch(RESOLV_CONF_PATH, RecursiveMode::NonRecursive)
             .chain_err(|| ErrorKind::WatchResolvConf)?;
 
-        thread::spawn(move || Self::event_loop(event_rx, state));
+        thread::spawn(move || Self::event_loop(event_rx, &state));
 
         Ok(DnsWatcher { _watcher: watcher })
     }
 
-    fn event_loop(events: mpsc::Receiver<notify::RawEvent>, state: Arc<Mutex<Option<State>>>) {
+    fn event_loop(events: mpsc::Receiver<notify::RawEvent>, state: &Arc<Mutex<Option<State>>>) {
         for _ in events {
-            let locked_state = state
+            let mut locked_state = state
                 .lock()
                 .expect("a thread panicked while using the DNS configuration state");
 
-            if let Err(error) = Self::update(locked_state) {
+            if let Err(error) = Self::update(locked_state.as_mut()) {
                 let chained_error = error
                     .chain_err(|| "Failed to update DNS state after DNS settings have changed.");
                 error!("{}", chained_error.display_chain());
@@ -143,8 +142,8 @@ impl DnsWatcher {
         }
     }
 
-    fn update(mut locked_state: MutexGuard<Option<State>>) -> Result<()> {
-        if let &mut Some(ref mut state) = locked_state.deref_mut() {
+    fn update(state: Option<&mut State>) -> Result<()> {
+        if let Some(state) = state {
             let mut new_config = read_config()?;
             let desired_nameservers = state
                 .desired_dns
diff --git a/talpid-core/src/security/linux/dns/systemd_resolved.rs b/talpid-core/src/security/linux/dns/systemd_resolved.rs
index 78e55a048b..5558ce2279 100644
--- a/talpid-core/src/security/linux/dns/systemd_resolved.rs
+++ b/talpid-core/src/security/linux/dns/systemd_resolved.rs
@@ -50,12 +50,12 @@ const RPC_TIMEOUT_MS: i32 = 1000;
 
 lazy_static! {
     static ref LINK_INTERFACE: Interface<'static> =
-        Interface::from_slice("org.freedesktop.resolve1.Link".as_bytes()).unwrap();
+        Interface::from_slice(b"org.freedesktop.resolve1.Link").unwrap();
     static ref MANAGER_INTERFACE: Interface<'static> =
-        Interface::from_slice("org.freedesktop.resolve1.Manager".as_bytes()).unwrap();
-    static ref GET_LINK_METHOD: Member<'static> = Member::from_slice("GetLink".as_bytes()).unwrap();
-    static ref SET_DNS_METHOD: Member<'static> = Member::from_slice("SetDNS".as_bytes()).unwrap();
-    static ref REVERT_METHOD: Member<'static> = Member::from_slice("Revert".as_bytes()).unwrap();
+        Interface::from_slice(b"org.freedesktop.resolve1.Manager").unwrap();
+    static ref GET_LINK_METHOD: Member<'static> = Member::from_slice(b"GetLink").unwrap();
+    static ref SET_DNS_METHOD: Member<'static> = Member::from_slice(b"SetDNS").unwrap();
+    static ref REVERT_METHOD: Member<'static> = Member::from_slice(b"Revert").unwrap();
 }
 
 pub struct SystemdResolved {
@@ -116,7 +116,7 @@ impl SystemdResolved {
             .any(|nameserver| nameserver == resolved_dns_server))
     }
 
-    fn as_manager_object<'a>(&'a self) -> dbus::ConnPath<'a, &'a dbus::Connection> {
+    fn as_manager_object(&self) -> dbus::ConnPath<&dbus::Connection> {
         self.dbus_connection
             .with_path(RESOLVED_BUS, "/org/freedesktop/resolve1", RPC_TIMEOUT_MS)
     }
diff --git a/talpid-core/src/security/linux/mod.rs b/talpid-core/src/security/linux/mod.rs
index e336fe21bd..0fb5b394be 100644
--- a/talpid-core/src/security/linux/mod.rs
+++ b/talpid-core/src/security/linux/mod.rs
@@ -257,14 +257,14 @@ impl<'a> PolicyBatch<'a> {
         let allowed_states = nftnl::expr::ct::States::ESTABLISHED.bits();
         in_rule.add_expr(&nft_expr!(bitwise mask allowed_states, xor 0u32))?;
         in_rule.add_expr(&nft_expr!(cmp != 0u32))?;
-        add_verdict(&mut in_rule, Verdict::Accept)?;
+        add_verdict(&mut in_rule, &Verdict::Accept)?;
 
         self.batch.add(&in_rule, nftnl::MsgType::Add)?;
 
 
         let mut out_rule = Rule::new(&self.out_chain)?;
         check_endpoint(&mut out_rule, End::Dst, endpoint)?;
-        add_verdict(&mut out_rule, Verdict::Accept)?;
+        add_verdict(&mut out_rule, &Verdict::Accept)?;
 
         self.batch.add(&out_rule, nftnl::MsgType::Add)?;
 
@@ -285,7 +285,7 @@ impl<'a> PolicyBatch<'a> {
         rule.add_expr(&nft_expr!(payload ipv4 daddr))?;
         rule.add_expr(&nft_expr!(cmp != tunnel.gateway))?;
 
-        add_verdict(&mut rule, Verdict::Drop)?;
+        add_verdict(&mut rule, &Verdict::Drop)?;
 
         self.batch.add(&rule, nftnl::MsgType::Add)?;
         Ok(())
@@ -310,14 +310,14 @@ impl<'a> PolicyBatch<'a> {
                 let mut rule = Rule::new(chain)?;
                 check_net(&mut rule, End::Src, IpNetwork::V4(*net))?;
                 check_net(&mut rule, End::Dst, IpNetwork::V4(*net))?;
-                add_verdict(&mut rule, Verdict::Accept)?;
+                add_verdict(&mut rule, &Verdict::Accept)?;
                 self.batch.add(&rule, nftnl::MsgType::Add)?;
             }
             for net in &*super::LOCAL_INET6_NETS {
                 let mut rule = Rule::new(chain)?;
                 check_net(&mut rule, End::Src, IpNetwork::V6(*net))?;
                 check_net(&mut rule, End::Dst, IpNetwork::V6(*net))?;
-                add_verdict(&mut rule, Verdict::Accept)?;
+                add_verdict(&mut rule, &Verdict::Accept)?;
                 self.batch.add(&rule, nftnl::MsgType::Add)?;
             }
         }
@@ -326,7 +326,7 @@ impl<'a> PolicyBatch<'a> {
             let mut rule = Rule::new(&self.out_chain)?;
             check_net(&mut rule, End::Src, IpNetwork::V4(*net))?;
             check_net(&mut rule, End::Dst, IpNetwork::V4(*super::MULTICAST_NET))?;
-            add_verdict(&mut rule, Verdict::Accept)?;
+            add_verdict(&mut rule, &Verdict::Accept)?;
 
             self.batch.add(&rule, nftnl::MsgType::Add)?;
 
@@ -334,7 +334,7 @@ impl<'a> PolicyBatch<'a> {
             let mut rule = Rule::new(&self.out_chain)?;
             check_net(&mut rule, End::Src, IpNetwork::V4(*net))?;
             check_ip(&mut rule, End::Dst, *super::SSDP_IP)?;
-            add_verdict(&mut rule, Verdict::Accept)?;
+            add_verdict(&mut rule, &Verdict::Accept)?;
 
             self.batch.add(&rule, nftnl::MsgType::Add)?;
         }
@@ -346,7 +346,7 @@ impl<'a> PolicyBatch<'a> {
                 End::Dst,
                 IpNetwork::V6(*super::MULTICAST_INET6_NET),
             )?;
-            add_verdict(&mut rule, Verdict::Accept)?;
+            add_verdict(&mut rule, &Verdict::Accept)?;
             self.batch.add(&rule, nftnl::MsgType::Add)?;
         }
         Ok(())
@@ -372,7 +372,7 @@ fn allow_dhcp_rule<'a>(chain: &'a Chain, direction: Direction) -> Result<Rule<'a
         }
     }
 
-    add_verdict(&mut rule, Verdict::Accept)?;
+    add_verdict(&mut rule, &Verdict::Accept)?;
 
     Ok(rule)
 }
@@ -384,7 +384,7 @@ fn allow_interface_rule<'a>(
 ) -> Result<Rule<'a>> {
     let mut rule = Rule::new(&chain)?;
     check_iface(&mut rule, direction, iface)?;
-    add_verdict(&mut rule, Verdict::Accept)?;
+    add_verdict(&mut rule, &Verdict::Accept)?;
 
     Ok(rule)
 }
@@ -496,9 +496,10 @@ fn l4proto(protocol: TransportProtocol) -> u8 {
     }
 }
 
-fn add_verdict(rule: &mut Rule, verdict: expr::Verdict) -> Result<()> {
+fn add_verdict(rule: &mut Rule, verdict: &expr::Verdict) -> Result<()> {
     if *ADD_COUNTERS {
         rule.add_expr(&nft_expr!(counter))?;
     }
-    Ok(rule.add_expr(&verdict)?)
+    rule.add_expr(verdict)?;
+    Ok(())
 }
diff --git a/talpid-core/src/tunnel/mod.rs b/talpid-core/src/tunnel/mod.rs
index 4a37296575..791c83ce2d 100644
--- a/talpid-core/src/tunnel/mod.rs
+++ b/talpid-core/src/tunnel/mod.rs
@@ -102,10 +102,10 @@ impl TunnelEvent {
     /// Converts an `OpenVpnPluginEvent` to a `TunnelEvent`.
     /// Returns `None` if there is no corresponding `TunnelEvent`.
     fn from_openvpn_event(
-        event: &OpenVpnPluginEvent,
+        event: OpenVpnPluginEvent,
         env: &HashMap<String, String>,
     ) -> Option<TunnelEvent> {
-        match *event {
+        match event {
             OpenVpnPluginEvent::AuthFailed => {
                 let reason = env.get("auth_failed_reason").cloned();
                 Some(TunnelEvent::AuthFailed(reason))
@@ -148,7 +148,7 @@ pub struct TunnelMonitor {
 impl TunnelMonitor {
     /// Creates a new `TunnelMonitor` that connects to the given remote and notifies `on_event`
     /// on tunnel state changes.
-    pub fn new<L>(
+    pub fn start<L>(
         tunnel_endpoint: TunnelEndpoint,
         tunnel_options: &TunnelOptions,
         tunnel_alias: Option<OsString>,
@@ -180,13 +180,13 @@ impl TunnelMonitor {
                 // The user-pass file has been read. Try to delete it early.
                 let _ = fs::remove_file(&user_pass_file_path);
             }
-            match TunnelEvent::from_openvpn_event(&event, &env) {
+            match TunnelEvent::from_openvpn_event(event, &env) {
                 Some(tunnel_event) => on_event(tunnel_event),
                 None => debug!("Ignoring OpenVpnEvent {:?}", event),
             }
         };
 
-        let monitor = openvpn::OpenVpnMonitor::new(
+        let monitor = openvpn::OpenVpnMonitor::start(
             cmd,
             on_openvpn_event,
             Self::get_plugin_path(resource_dir)?,
diff --git a/talpid-core/src/tunnel/openvpn.rs b/talpid-core/src/tunnel/openvpn.rs
index 0eeae37faf..d3956ad5db 100644
--- a/talpid-core/src/tunnel/openvpn.rs
+++ b/talpid-core/src/tunnel/openvpn.rs
@@ -44,7 +44,7 @@ pub struct OpenVpnMonitor<C: OpenVpnBuilder = OpenVpnCommand> {
 impl OpenVpnMonitor<OpenVpnCommand> {
     /// Creates a new `OpenVpnMonitor` with the given listener and using the plugin at the given
     /// path.
-    pub fn new<L, P>(cmd: OpenVpnCommand, on_event: L, plugin_path: P) -> Result<Self>
+    pub fn start<L, P>(cmd: OpenVpnCommand, on_event: L, plugin_path: P) -> Result<Self>
     where
         L: Fn(OpenVpnPluginEvent, HashMap<String, String>) + Send + Sync + 'static,
         P: AsRef<Path>,
@@ -233,7 +233,7 @@ mod event_server {
         let mut io = IoHandler::new();
         io.extend_with(rpc.to_delegate());
         let meta_io: MetaIoHandler<()> = MetaIoHandler::from(io);
-        talpid_ipc::IpcServer::start(meta_io, ipc_path)
+        talpid_ipc::IpcServer::start(meta_io, &ipc_path)
     }
 
     build_rpc_trait! {
@@ -289,7 +289,7 @@ mod tests {
 
         fn start(&self) -> io::Result<Self::ProcessHandle> {
             self.process_handle
-                .ok_or(io::Error::new(io::ErrorKind::Other, "failed to start"))
+                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "failed to start"))
         }
     }
 
@@ -354,7 +354,7 @@ mod tests {
         let builder = TestOpenVpnBuilder::default();
         let error = OpenVpnMonitor::new_internal(builder, |_, _| {}, "").unwrap_err();
         match error.kind() {
-            &ErrorKind::ChildProcessError(_) => (),
+            ErrorKind::ChildProcessError(_) => (),
             _ => panic!("Wrong error"),
         }
     }
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index f2ce3e0b4e..f86b34f1e0 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -96,7 +96,7 @@ impl ConnectingState {
         };
         let log_file = Self::prepare_tunnel_log_file(&parameters, log_dir)?;
 
-        Ok(TunnelMonitor::new(
+        Ok(TunnelMonitor::start(
             parameters.endpoint,
             &parameters.options,
             TUNNEL_INTERFACE_ALIAS.to_owned().map(OsString::from),
diff --git a/talpid-ipc/src/lib.rs b/talpid-ipc/src/lib.rs
index aeecb35b7f..30883eaf90 100644
--- a/talpid-ipc/src/lib.rs
+++ b/talpid-ipc/src/lib.rs
@@ -54,14 +54,14 @@ pub struct IpcServer {
 }
 
 impl IpcServer {
-    pub fn start<M: Metadata + Default>(handler: MetaIoHandler<M>, path: String) -> Result<Self> {
+    pub fn start<M: Metadata + Default>(handler: MetaIoHandler<M>, path: &str) -> Result<Self> {
         Self::start_with_metadata(handler, NoopExtractor, path)
     }
 
     pub fn start_with_metadata<M, E>(
         handler: MetaIoHandler<M>,
         meta_extractor: E,
-        path: String,
+        path: &str,
     ) -> Result<Self>
     where
         M: Metadata + Default,
@@ -71,15 +71,15 @@ impl IpcServer {
             .chain_err(|| ErrorKind::PermissionsError)?;
         let server = ServerBuilder::with_meta_extractor(handler, meta_extractor)
             .set_security_attributes(security_attributes)
-            .start(&path)
+            .start(path)
             .chain_err(|| ErrorKind::IpcServerError)
             .and_then(|(fut, start, server)| {
                 thread::spawn(move || tokio::run(fut));
                 start
                     .wait()
                     .expect("server panicked")
-                    .map(|e| Err(e))
-                    .unwrap_or(Ok(server))
+                    .map(Err)
+                    .unwrap_or_else(|| Ok(server))
                     .chain_err(|| ErrorKind::IpcServerError)
             })
             .map(|server| IpcServer {
diff --git a/talpid-ipc/tests/ipc-client-server.rs b/talpid-ipc/tests/ipc-client-server.rs
index a155813efe..24781db081 100644
--- a/talpid-ipc/tests/ipc-client-server.rs
+++ b/talpid-ipc/tests/ipc-client-server.rs
@@ -76,7 +76,7 @@ fn create_server() -> (talpid_ipc::IpcServer, mpsc::Receiver<i64>) {
     } else {
         format!("/tmp/ipc-test-{}", uuid)
     };
-    let server = talpid_ipc::IpcServer::start(io.into(), ipc_path).unwrap();
+    let server = talpid_ipc::IpcServer::start(io.into(), &ipc_path).unwrap();
     (server, rx)
 }
 
@@ -93,6 +93,5 @@ fn create_client(ipc_path: String) -> jsonrpc_client_core::ClientHandle {
         client.wait().unwrap();
     });
 
-    let handle = rx.wait().expect("Failed to construct a valid client");
-    handle
+    rx.wait().expect("Failed to construct a valid client")
 }