Merge branch 'geoip-check'

mullvad-api/Cargo.toml

@@ -13,6 +13,7 @@ publish.workspace = true
 api-override = []
 
 [dependencies]
+libc = "0.2"
 chrono = { workspace = true }
 err-derive = { workspace = true }
 futures = "0.3"

mullvad-api/src/rest.rs

@@ -19,6 +19,7 @@ use hyper::{
 };
 use mullvad_types::account::AccountToken;
 use std::{
+    error::Error as StdError,
     future::Future,
     str::FromStr,
     sync::{Arc, Weak},
@@ -88,14 +89,28 @@ impl Error {
         matches!(self, Error::HyperError(_) | Error::TimeoutError)
     }
 
+    /// Return true if there was no route to the destination
+    pub fn is_offline(&self) -> bool {
+        match self {
+            Error::HyperError(error) if error.is_connect() => {
+                if let Some(cause) = error.source() {
+                    if let Some(err) = cause.downcast_ref::<std::io::Error>() {
+                        return err.raw_os_error() == Some(libc::ENETUNREACH);
+                    }
+                }
+                false
+            }
+            _ => false,
+        }
+    }
+
     pub fn is_aborted(&self) -> bool {
         matches!(self, Error::Aborted)
     }
 
     /// Returns a new instance for which `abortable_stream::Aborted` is mapped to `Self::Aborted`.
     fn map_aborted(self) -> Self {
         if let Error::HyperError(error) = &self {
-            use std::error::Error;
             let mut source = error.source();
             while let Some(error) = source {
                 let io_error: Option<&std::io::Error> = error.downcast_ref();

mullvad-daemon/src/geoip.rs

@@ -89,24 +89,8 @@ async fn send_location_request_internal(
 }
 
 fn log_network_error(err: Error, version: &'static str) {
-    use std::sync::Arc;
-    let err_message = &format!("Unable to fetch {version} GeoIP location");
-    match err {
-        Error::HyperError(hyper_err) if hyper_err.is_connect() => {
-            if let Some(cause) = Arc::into_inner(hyper_err).and_then(|x| x.into_cause()) {
-                if let Some(err) = cause.downcast_ref::<std::io::Error>() {
-                    // Don't log ENETUNREACH errors, they are not informative.
-                    if err.raw_os_error() == Some(libc::ENETUNREACH) {
-                        return;
-                    }
-                    log::debug!("{}: Hyper connect error: {}", err_message, cause);
-                }
-            } else {
-                log::error!("Hyper Connection error did not contain a cause!");
-            }
-        }
-        any_other_error => {
-            log::debug!("{}", any_other_error.display_chain_with_msg(err_message));
-        }
-    };
+    if !err.is_offline() {
+        let err_message = &format!("Unable to fetch {version} GeoIP location");
+        log::debug!("{}", err.display_chain_with_msg(err_message));
+    }
 }