diff --git a/Cargo.lock b/Cargo.lock
index 0568c28..1429158 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -891,9 +891,9 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "smallvec"
-version = "1.15.2"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+checksum = "b9be42f50aa861c555654aa3a37f52f4b1074bacf4e48fe0ef7fa584e80f1f0f"
 
 [[package]]
 name = "socket2"
diff --git a/examples/client.rs b/examples/client.rs
index aeab172..beb7baf 100644
--- a/examples/client.rs
+++ b/examples/client.rs
@@ -1,4 +1,7 @@
-use std::{net::SocketAddr, str::FromStr};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    str::FromStr,
+};
 
 use defguard_wireguard_rs::{
     InterfaceConfiguration, WGApi, WireguardInterfaceApi, key::Key, net::IpAddrMask, peer::Peer,
@@ -7,6 +10,8 @@ use x25519_dalek::{EphemeralSecret, PublicKey};
 
 #[cfg(not(target_os = "netbsd"))]
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    env_logger::init();
+
     // Create new API object for interface
     let ifname: String = if cfg!(target_os = "linux") || cfg!(target_os = "freebsd") {
         "wg0".into()
@@ -31,7 +36,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     log::info!("endpoint");
     // Your WireGuard server endpoint which client connects to
-    let endpoint: SocketAddr = "10.10.10.10:55001".parse().unwrap();
+    let endpoint = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(10, 10, 10, 10)), 55001);
     // Peer endpoint and interval
     peer.endpoint = Some(endpoint);
     peer.persistent_keepalive_interval = Some(25);
diff --git a/src/dns.rs b/src/dns.rs
index e8ad061..ed551d4 100644
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -13,6 +13,7 @@ use std::io::{Cursor, Error as IoError};
 use std::net::IpAddr;
 #[cfg(any(target_os = "freebsd", target_os = "linux", target_os = "netbsd"))]
 use std::{
+    fmt::Write as _,
     fs::{File, read_dir},
     io::Write,
     path::Path,
@@ -282,7 +283,7 @@ impl<'a> DnsConfig<'a> {
     fn resolvconf_stdin(&self) -> String {
         let mut stdin = String::new();
         for server in self.servers {
-            stdin.push_str(&format!("nameserver {server}\n"));
+            let _ = writeln!(stdin, "nameserver {server}");
         }
         // Routing-only domains have to be declared as search domains here, as that is the only way
         // of telling resolvconf which domains this interface resolves.
@@ -295,7 +296,7 @@ impl<'a> DnsConfig<'a> {
         if !domains.is_empty() {
             // resolv.conf(5) holds a single search list, and a second `search` line overrides the
             // first one rather than extending it.
-            stdin.push_str(&format!("search {}\n", domains.join(" ")));
+            let _ = writeln!(stdin, "search {}", domains.join(" "));
         }
         stdin
     }
@@ -478,16 +479,15 @@ fn systemd_resolved_available() -> bool {
         debug!("{RESOLVED_RUNTIME_DIR} does not exist, assuming systemd-resolved is not running");
         return false;
     }
-    match get_command_path(RESOLVECTL) {
-        Ok(Some(_)) => true,
-        _ => {
-            warn!(
-                "systemd-resolved appears to be running, but the `{RESOLVECTL}` command could \
-                not be found in PATH. Falling back to `{RESOLVCONF}`, which cannot configure \
-                split DNS on this host."
-            );
-            false
-        }
+    if let Ok(Some(_)) = get_command_path(RESOLVECTL) {
+        true
+    } else {
+        warn!(
+            "systemd-resolved appears to be running, but the `{RESOLVECTL}` command could not be \
+            found in PATH. Falling back to `{RESOLVCONF}`, which cannot configure split DNS on \
+            this host."
+        );
+        false
     }
 }
 
diff --git a/src/netlink.rs b/src/netlink.rs
index 5e97f29..6eb308a 100644
--- a/src/netlink.rs
+++ b/src/netlink.rs
@@ -484,11 +484,10 @@ pub(crate) fn set_link_up(if_name: &str) -> NetlinkResult<()> {
     Ok(())
 }
 
-#[cfg(test)]
 /// Get default route for a given address family.
-pub(crate) fn get_gateway(address_family: AddressFamily) -> NetlinkResult<Option<IpAddr>> {
+pub(crate) fn get_gateway(ip_version: IpVersion) -> NetlinkResult<Option<IpAddr>> {
     let header = RouteHeader {
-        address_family,
+        address_family: ip_version.address_family(),
         table: RouteHeader::RT_TABLE_MAIN,
         // protocol: RouteProtocol::Boot, // doesn't filter
         // scope: RouteScope::Universe,   // doesn't filter
@@ -522,13 +521,70 @@ pub(crate) fn get_gateway(address_family: AddressFamily) -> NetlinkResult<Option
                 }
             }
         } else {
-            debug!("unknown nlmsg response")
+            debug!("unknown nlmsg response");
         }
     }
 
     Ok(None)
 }
 
+/// Convert an [`IpAddr`] into a netlink [`RouteAddress`].
+fn route_address(address: IpAddr) -> RouteAddress {
+    match address {
+        IpAddr::V4(ipv4) => RouteAddress::Inet(ipv4),
+        IpAddr::V6(ipv6) => RouteAddress::Inet6(ipv6),
+    }
+}
+
+/// Set a route to `dest` through `gateway`, replacing an existing one, if any.
+///
+/// When `is_blackhole` is set, traffic to `dest` is dropped and `gateway` is ignored.
+pub(crate) fn add_gateway(
+    dest: &IpAddrMask,
+    gateway: IpAddr,
+    is_blackhole: bool,
+) -> NetlinkResult<()> {
+    if !is_blackhole && dest.address.is_ipv4() != gateway.is_ipv4() {
+        error!("Destination {dest} and gateway {gateway} IP versions don't match");
+        return Err(NetlinkError::AddRouteError);
+    }
+
+    let mut message = RouteMessage::default();
+    message.header = RouteHeader {
+        address_family: dest.address_family(),
+        destination_prefix_length: dest.cidr,
+        table: RouteHeader::RT_TABLE_MAIN,
+        scope: RouteScope::Universe,
+        kind: if is_blackhole {
+            RouteType::BlackHole
+        } else {
+            RouteType::Unicast
+        },
+        protocol: RouteProtocol::Boot,
+        ..Default::default()
+    };
+    message
+        .attributes
+        .push(RouteAttribute::Destination(route_address(dest.address)));
+    if !is_blackhole {
+        message
+            .attributes
+            .push(RouteAttribute::Gateway(route_address(gateway)));
+    }
+
+    match netlink_request(
+        RouteNetlinkMessage::NewRoute(message),
+        NLM_F_REQUEST | NLM_F_ACK | NLM_F_CREATE | NLM_F_REPLACE,
+        NETLINK_ROUTE,
+    ) {
+        Ok(_msg) => Ok(()),
+        Err(err) => {
+            error!("Failed to set gateway for {dest}: {err}");
+            Err(NetlinkError::AddRouteError)
+        }
+    }
+}
+
 /// Add a route for an interface.
 pub(crate) fn add_route(
     ifname: &str,
@@ -545,10 +601,6 @@ pub(crate) fn add_route(
         protocol: RouteProtocol::Boot,
         ..Default::default()
     };
-    let route_address = match address.address {
-        IpAddr::V4(ipv4) => RouteAddress::Inet(ipv4),
-        IpAddr::V6(ipv6) => RouteAddress::Inet6(ipv6),
-    };
     message.header = header;
     let Some(interface_index) = get_interface_index(ifname)? else {
         error!("Failed to add WireGuard interface route interface {ifname} index not found");
@@ -560,7 +612,7 @@ pub(crate) fn add_route(
         .push(RouteAttribute::Oif(interface_index));
     message
         .attributes
-        .push(RouteAttribute::Destination(route_address));
+        .push(RouteAttribute::Destination(route_address(address.address)));
     if let Some(table) = table {
         message.attributes.push(RouteAttribute::Table(table));
     }
@@ -856,7 +908,7 @@ mod tests {
         Err(NetlinkError::AttributeNotFound)
     }
 
-    #[ignore]
+    #[ignore = "destructive"]
     #[test]
     fn docker_networking() {
         const IF_NAME: &str = "wg0";
@@ -885,11 +937,12 @@ mod tests {
         delete_interface(IF_NAME).unwrap();
     }
 
-    #[ignore]
+    #[ignore = "destructive"]
     #[test]
     fn docker_peers() {
         use x25519_dalek::{EphemeralSecret, PublicKey};
 
+        const IF_NAME: &str = "wg0";
         const MAX_PEERS: usize = 1600;
 
         let secret = EphemeralSecret::random();
@@ -906,7 +959,6 @@ mod tests {
             host.peers.insert(key, peer);
         }
 
-        const IF_NAME: &str = "wg0";
         create_interface(IF_NAME).unwrap();
         set_host(IF_NAME, &host).unwrap();
 
@@ -917,10 +969,10 @@ mod tests {
         delete_interface(IF_NAME).unwrap();
     }
 
-    #[ignore]
+    #[ignore = "destructive"]
     #[test]
     fn docker_gateway() {
-        let gateway = get_gateway(AddressFamily::Inet).unwrap();
+        let gateway = get_gateway(IpVersion::IPv4).unwrap();
         assert!(gateway.is_some());
     }
 
@@ -928,7 +980,7 @@ mod tests {
     // - `ip link add dev wg0 type wireguard`
     // - `ip link set up dev wg0`
     // - `ip route add default dev wg0 scope link table 51820`
-    #[ignore]
+    #[ignore = "destructive"]
     #[test]
     fn docker_route() {
         let count = count_routes(IpVersion::IPv4, 51820).unwrap();
diff --git a/src/utils.rs b/src/utils.rs
index 4af2ec6..2889c2c 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,5 +1,3 @@
-#[cfg(any(target_os = "freebsd", target_os = "macos", target_os = "netbsd"))]
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::net::{SocketAddr, ToSocketAddrs};
 #[cfg(any(
     feature = "check_dependencies",
@@ -8,26 +6,24 @@ use std::net::{SocketAddr, ToSocketAddrs};
     target_os = "netbsd"
 ))]
 use std::path::PathBuf;
+#[cfg(not(target_os = "windows"))]
+use std::{
+    collections::HashSet,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
 #[cfg(target_os = "linux")]
-use std::{collections::HashSet, fs::OpenOptions, io::Write};
+use std::{fs::OpenOptions, io::Write};
 
-#[cfg(not(target_os = "windows"))]
-use crate::Peer;
 use crate::WireguardInterfaceError;
 #[cfg(any(target_os = "freebsd", target_os = "macos", target_os = "netbsd"))]
-use crate::{
-    IpVersion,
-    bsd::{add_gateway, add_linked_route, get_gateway},
-    net::IpAddrMask,
-};
+use crate::bsd::{IoError, add_gateway, add_linked_route, delete_gateway, get_gateway};
 #[cfg(target_os = "linux")]
-use crate::{IpVersion, netlink};
+use crate::netlink::{self, add_gateway, get_gateway};
+#[cfg(not(target_os = "windows"))]
+use crate::{IpVersion, Peer, net::IpAddrMask};
 
 #[cfg(target_os = "linux")]
-fn setup_default_route(
-    ifname: &str,
-    addr: &super::IpAddrMask,
-) -> Result<(), WireguardInterfaceError> {
+fn setup_default_route(ifname: &str, addr: &IpAddrMask) -> Result<(), WireguardInterfaceError> {
     const DEFAULT_FWMARK_TABLE: u32 = 51820; // specific to wg-quick
 
     debug!("Found default route in AllowedIPs: {addr:?}");
@@ -80,7 +76,56 @@ fn setup_default_route(
     Ok(())
 }
 
-/// Adds routing entries for allowed IPs of WireGuard peers on a Linux system.
+#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "netbsd"))]
+fn setup_default_route(ifname: &str, addr: &IpAddrMask) -> Result<(), WireguardInterfaceError> {
+    debug!(
+        "Found default route in the allowed IPs: {addr}, interface: {ifname}, \
+        proceeding with default route initial setup."
+    );
+    // FIXME: currently it is impossible to add another default route, so use the hack from
+    // wg-quick for Darwin.
+    let default_routes = if addr.address.is_ipv4() {
+        // 0.0.0.0/1
+        [
+            IpAddrMask::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 1),
+            IpAddrMask::new(IpAddr::V4(Ipv4Addr::new(128, 0, 0, 0)), 1),
+        ]
+    } else {
+        // ::/1
+        [
+            IpAddrMask::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 1),
+            IpAddrMask::new(IpAddr::V6(Ipv6Addr::new(0x8000, 0, 0, 0, 0, 0, 0, 0)), 1),
+        ]
+    };
+    for addr in default_routes {
+        match add_linked_route(&addr, ifname) {
+            Ok(()) => debug!("Route to {addr} has been added for interface {ifname}"),
+            Err(IoError::Io(err)) => {
+                if let Some(raw_os_err) = err.raw_os_error()
+                    && raw_os_err == libc::ENETUNREACH
+                {
+                    warn!(
+                        "Failed to add default route {addr} for interface {ifname}: \
+                        Network is unreachable. This may happen if interface's IP address \
+                        is not the same IP version as the default gateway ({addr}) \
+                        that was tried to be set, in this case this warning can be \
+                        ignored. Otherwise, there may be some other issues with network \
+                        configuration."
+                    );
+                } else {
+                    error!("Failed to add route to {addr} for interface {ifname}: {err}");
+                }
+            }
+            Err(err) => {
+                error!("Failed to add route to {addr} for interface {ifname}: {err}");
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Adds routing entries for allowed IPs of WireGuard peers.
 ///
 /// Iterates over the provided list of peers and installs routing rules based on their
 /// allowed IP addresses. It distinguishes between IPv4 and IPv6 addresses, and handles
@@ -94,79 +139,92 @@ fn setup_default_route(
 /// # Returns
 /// * `Ok(())` on success.
 /// * `Err(WireguardInterfaceError)` if any route setup fails.
-///
-#[cfg(target_os = "linux")]
+#[cfg(not(target_os = "windows"))]
 pub(crate) fn add_peer_routing(
     peers: &[Peer],
     ifname: &str,
 ) -> Result<(), WireguardInterfaceError> {
     debug!("Adding peer routing for interface: {ifname}");
 
-    // (ipv4, ipv6)
-    let mut allowed_ips = (HashSet::new(), HashSet::new());
-    let mut default_routes = (None, None);
+    let mut allowed_ips_v4 = HashSet::new();
+    let mut allowed_ips_v6 = HashSet::new();
+    let mut default_route_v4 = None;
+    let mut default_route_v6 = None;
 
     // Gather allowed IPs and default routes
     for peer in peers {
         for addr in &peer.allowed_ips {
-            if addr.address.is_unspecified() {
+            if addr.address.is_unspecified() && addr.cidr == 0 {
                 // Default route - store for later
                 if addr.address.is_ipv4() {
-                    default_routes.0 = Some(addr);
+                    default_route_v4 = Some(addr);
                 } else {
-                    default_routes.1 = Some(addr);
+                    default_route_v6 = Some(addr);
                 }
                 continue;
             }
             // Regular route - add to set
             if addr.address.is_ipv4() {
-                allowed_ips.0.insert(addr);
+                allowed_ips_v4.insert(addr);
             } else {
-                allowed_ips.1.insert(addr);
+                allowed_ips_v6.insert(addr);
             }
         }
     }
-    debug!("Allowed IPs that will be used during the peer routing setup: {allowed_ips:?}");
 
     // Add default route if present, otherwise setup individual allowed IP routes
-    if let Some(default_route) = default_routes.0 {
+    if let Some(default_route) = default_route_v4 {
         setup_default_route(ifname, default_route)?;
     } else {
-        for allowed_ip in allowed_ips.0 {
-            debug!("Adding a route for allowed IPv4: {allowed_ip}");
-            netlink::add_route(ifname, allowed_ip, None)?;
-            debug!("Route added for allowed IPv4: {allowed_ip}");
+        for addr in allowed_ips_v4 {
+            debug!("Adding a route for allowed IPv4: {addr}");
+
+            #[cfg(not(target_os = "linux"))]
+            let result = add_linked_route(addr, ifname);
+            #[cfg(target_os = "linux")]
+            let result = netlink::add_route(ifname, addr, None);
+
+            if let Err(err) = result {
+                warn!(
+                    "Failed to add route for allowed IPv4 {addr} \
+                    on interface {ifname}: {err}."
+                );
+            } else {
+                debug!("Route added for allowed IPv4: {addr}");
+            }
         }
     }
-    if let Some(default_route) = default_routes.1 {
+    if let Some(default_route) = default_route_v6 {
         if let Err(err) = setup_default_route(ifname, default_route) {
             warn!("Failed to setup IPv6 default route for interface {ifname}: {err}.");
         }
     } else {
-        for allowed_ip in allowed_ips.1 {
-            debug!("Adding a route for allowed IPv6: {allowed_ip}");
-            if let Err(err) = netlink::add_route(ifname, allowed_ip, None) {
+        for addr in allowed_ips_v6 {
+            debug!("Adding a route for allowed IPv6: {addr}");
+
+            #[cfg(not(target_os = "linux"))]
+            let result = add_linked_route(addr, ifname);
+            #[cfg(target_os = "linux")]
+            let result = netlink::add_route(ifname, addr, None);
+
+            if let Err(err) = result {
                 warn!(
-                    "Failed to add route for allowed IPv6 {allowed_ip} \
+                    "Failed to add route for allowed IPv6 {addr} \
                     on interface {ifname}: {err}."
                 );
             } else {
-                debug!("Route added for allowed IPv6: {allowed_ip}");
+                debug!("Route added for allowed IPv6: {addr}");
             }
         }
     }
+
     debug!("Peers routing added successfully");
     Ok(())
 }
 
-/// Helper function to add routing.
-#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "netbsd"))]
-pub(crate) fn add_peer_routing(
-    peers: &[Peer],
-    ifname: &str,
-) -> Result<(), WireguardInterfaceError> {
-    use crate::bsd::{IoError, delete_gateway};
-
+/// Condfigure peers with `endpoint` field set.
+#[cfg(not(target_os = "windows"))]
+pub(crate) fn configure_endpoints(peers: &[Peer]) {
     let gateway_v4 = get_gateway(IpVersion::IPv4);
     if let Ok(Some(gateway)) = gateway_v4 {
         debug!("Default gateway for IPv4: {gateway}");
@@ -176,103 +234,15 @@ pub(crate) fn add_peer_routing(
         debug!("Default gateway for IPv6: {gateway}");
     }
 
-    debug!("Adding peer routing for interface: {ifname}");
     for peer in peers {
-        debug!("Processing peer: {}", peer.public_key);
-        for addr in &peer.allowed_ips {
-            debug!("Processing route for allowed IP: {addr}, interface: {ifname}");
-            // FIXME: currently it is impossible to add another default route, so use the hack from
-            // wg-quick for Darwin.
-            if addr.address.is_unspecified() && addr.cidr == 0 {
-                debug!(
-                    "Found following default route in the allowed IPs: {addr}, interface: \
-                    {ifname}, proceeding with default route initial setup."
-                );
-
-                let (default1, default2) = if addr.address.is_ipv4() {
-                    // 0.0.0.0/1
-                    (
-                        IpAddrMask::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 1),
-                        IpAddrMask::new(IpAddr::V4(Ipv4Addr::new(128, 0, 0, 0)), 1),
-                    )
-                } else {
-                    // ::/1
-                    (
-                        IpAddrMask::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 1),
-                        IpAddrMask::new(IpAddr::V6(Ipv6Addr::new(0x8000, 0, 0, 0, 0, 0, 0, 0)), 1),
-                    )
-                };
-                match add_linked_route(&default1, ifname) {
-                    Ok(()) => debug!("Route to {default1} has been added for interface {ifname}"),
-                    Err(IoError::Io(err)) => {
-                        if let Some(raw_os_err) = err.raw_os_error()
-                            && raw_os_err == libc::ENETUNREACH
-                        {
-                            warn!(
-                                "Failed to add default route {default1} for interface {ifname}: \
-                                Network is unreachable. This may happen if interface's IP address \
-                                is not the same IP version as the default gateway ({default1}) \
-                                that was tried to be set, in this case this warning can be \
-                                ignored. Otherwise, there may be some other issues with network \
-                                configuration."
-                            );
-                        } else {
-                            error!(
-                                "Failed to add route to {default1} for interface {ifname}: {err}"
-                            );
-                        }
-                    }
-                    Err(err) => {
-                        error!("Failed to add route to {default1} for interface {ifname}: {err}");
-                    }
-                }
-                match add_linked_route(&default2, ifname) {
-                    Ok(()) => debug!("Route to {default2} has been added for interface {ifname}"),
-                    Err(IoError::Io(err)) => {
-                        if let Some(raw_os_err) = err.raw_os_error()
-                            && raw_os_err == libc::ENETUNREACH
-                        {
-                            warn!(
-                                "Failed to add default route {default2} for interface {ifname}: \
-                                Network is unreachable. This may happen if interface's IP address \
-                                is not the same IP version as the default gateway ({default2}) \
-                                that was tried to be set, in this case this warning can be \
-                                ignored. Otherwise, there may be some other issues with network \
-                                configuration."
-                            );
-                        } else {
-                            error!(
-                                "Failed to add route to {default2} for interface {ifname}: {err}"
-                            );
-                        }
-                    }
-                    Err(err) => {
-                        error!("Failed to add route to {default2} for interface {ifname}: {err}");
-                    }
-                }
-            } else {
-                // Equivalent to `route -n add -inet[6] <allowed_ip> -interface <ifname>`.
-                match add_linked_route(addr, ifname) {
-                    Ok(()) => debug!("Route to {addr} has been added for interface {ifname}"),
-                    Err(err) => {
-                        error!("Failed to add route to {addr} for interface {ifname}: {err}");
-                    }
-                }
-            }
-        }
-
         // Logic below is valid only in case an endpoint has been configured for the peer.
         let Some(endpoint) = peer.endpoint else {
             continue;
         };
 
         let endpoint_ip = IpAddrMask::host(endpoint.ip());
-        let localhost = if endpoint.is_ipv4() {
-            IpAddr::V4(Ipv4Addr::LOCALHOST)
-        } else {
-            IpAddr::V6(Ipv6Addr::LOCALHOST)
-        };
-
+        // Note: unlike on BSD, there is no need to delete a gateway on Linux.
+        #[cfg(not(target_os = "linux"))]
         match delete_gateway(&endpoint_ip) {
             Ok(()) => {
                 debug!("Former route to {endpoint_ip} has been removed, if it existed.");
@@ -291,8 +261,8 @@ pub(crate) fn add_peer_routing(
             match gateway_v6 {
                 Ok(Some(gateway)) => {
                     debug!(
-                        "Default gateway for IPv6 has been found before: {gateway}, routing the \
-                        traffic destined to {endpoint_ip} through it."
+                        "Default gateway for IPv6: {gateway}, routing the traffic destined to \
+                        {endpoint_ip} through it."
                     );
                     match add_gateway(&endpoint_ip, gateway, false) {
                         Ok(()) => {
@@ -310,7 +280,7 @@ pub(crate) fn add_peer_routing(
                         "Default gateway for IPv6 has not been found, routing the traffic destined \
                         to {endpoint_ip} through localhost as a blackhole route."
                     );
-                    match add_gateway(&endpoint_ip, localhost, true) {
+                    match add_gateway(&endpoint_ip, IpAddr::V6(Ipv6Addr::LOCALHOST), true) {
                         Ok(()) => debug!("Blackhole route to {endpoint_ip} has been added"),
                         Err(err) => {
                             error!("Failed to add blackhole route to {endpoint_ip}: {err}");
@@ -329,8 +299,8 @@ pub(crate) fn add_peer_routing(
             match gateway_v4 {
                 Ok(Some(gateway)) => {
                     debug!(
-                        "Default gateway for IPv4 has been found before: {gateway}, routing the \
-                        traffic destined to {endpoint_ip} through it."
+                        "Default gateway for IPv4: {gateway}, routing the traffic destined to \
+                        {endpoint_ip} through it."
                     );
                     match add_gateway(&endpoint_ip, gateway, false) {
                         Ok(()) => {
@@ -348,7 +318,7 @@ pub(crate) fn add_peer_routing(
                         "Default gateway for IPv4 has not been found, routing the traffic destined \
                         to {endpoint_ip} through localhost as a blackhole route."
                     );
-                    match add_gateway(&endpoint_ip, localhost, true) {
+                    match add_gateway(&endpoint_ip, IpAddr::V4(Ipv4Addr::LOCALHOST), true) {
                         Ok(()) => debug!("Blackhole route to {endpoint_ip} has been added"),
                         Err(err) => {
                             error!("Failed to add blackhole route to {endpoint_ip}: {err}");
@@ -361,9 +331,6 @@ pub(crate) fn add_peer_routing(
             }
         }
     }
-
-    debug!("Peers routing added successfully");
-    Ok(())
 }
 
 /// Clean fwmark rules while removing interface (based on wg-quick).
diff --git a/src/wgapi_freebsd.rs b/src/wgapi_freebsd.rs
index 0aeaee6..3391229 100644
--- a/src/wgapi_freebsd.rs
+++ b/src/wgapi_freebsd.rs
@@ -2,7 +2,7 @@ use crate::{
     Host, InterfaceConfiguration, IpAddrMask, Key, Peer, WireguardInterfaceApi,
     WireguardInterfaceError, bsd,
     dns::{DnsConfig, clear_dns},
-    utils::add_peer_routing,
+    utils::{add_peer_routing, configure_endpoints},
     wgapi::{Kernel, WGApi},
 };
 
@@ -50,12 +50,8 @@ impl WireguardInterfaceApi for WGApi<Kernel> {
     /// ## Note:
     /// Based on ip type `<inet>` will be equal to `-inet` or `-inet6`
     fn configure_peer_routing(&self, peers: &[Peer]) -> Result<(), WireguardInterfaceError> {
-        debug!("Configuring peer routing for interface {}", self.ifname);
         add_peer_routing(peers, &self.ifname)?;
-        info!(
-            "Peer routing configured successfully for interface {}",
-            self.ifname
-        );
+        configure_endpoints(peers);
         Ok(())
     }
 
diff --git a/src/wgapi_linux.rs b/src/wgapi_linux.rs
index ad6112e..2bec58b 100644
--- a/src/wgapi_linux.rs
+++ b/src/wgapi_linux.rs
@@ -3,7 +3,7 @@ use crate::{
     WireguardInterfaceError,
     dns::{DnsConfig, clear_dns},
     netlink,
-    utils::{add_peer_routing, clean_fwmark_rules},
+    utils::{add_peer_routing, clean_fwmark_rules, configure_endpoints},
     wgapi::{Kernel, WGApi},
 };
 
@@ -64,12 +64,7 @@ impl WireguardInterfaceApi for WGApi<Kernel> {
 
         // Assign IP addresses to the interface.
         for address in &config.addresses {
-            debug!("Assigning address {address} to interface {}", self.ifname);
             self.assign_address(address)?;
-            debug!(
-                "Address {address} assigned to interface {} successfully",
-                self.ifname
-            );
         }
 
         // configure interface
@@ -108,6 +103,7 @@ impl WireguardInterfaceApi for WGApi<Kernel> {
     ///
     fn configure_peer_routing(&self, peers: &[Peer]) -> Result<(), WireguardInterfaceError> {
         add_peer_routing(peers, &self.ifname)?;
+        configure_endpoints(peers);
         Ok(())
     }
 
@@ -122,12 +118,12 @@ impl WireguardInterfaceApi for WGApi<Kernel> {
             self.ifname
         );
         trace!("WireGuard host configuration: {host:?}");
-        if let Some(fwmark) = host.fwmark {
-            if fwmark != 0 {
-                debug!("Cleaning fwmark rules for interface {}", self.ifname);
-                clean_fwmark_rules(fwmark)?;
-                debug!("Fwmark rules cleaned for interface {}", self.ifname);
-            }
+        if let Some(fwmark) = host.fwmark
+            && fwmark != 0
+        {
+            debug!("Cleaning fwmark rules for interface {}", self.ifname);
+            clean_fwmark_rules(fwmark)?;
+            debug!("Fwmark rules cleaned for interface {}", self.ifname);
         }
         // Clear the DNS configuration while the interface is still around, as
         // systemd-resolved cannot revert the settings of a link which no longer exists.
diff --git a/src/wgapi_userspace.rs b/src/wgapi_userspace.rs
index 33f0c92..563f1df 100644
--- a/src/wgapi_userspace.rs
+++ b/src/wgapi_userspace.rs
@@ -21,7 +21,7 @@ use crate::{
     Host, InterfaceConfiguration, IpAddrMask, Key, Peer,
     dns::DnsConfig,
     error::WireguardInterfaceError,
-    utils::add_peer_routing,
+    utils::{add_peer_routing, configure_endpoints},
     wgapi::{Userspace, WGApi},
     wireguard_interface::WireguardInterfaceApi,
 };
@@ -243,6 +243,7 @@ impl WireguardInterfaceApi for WGApi<Userspace> {
     ///   `<gateway>`- Gateway extracted using `netstat -nr -f <inet>`.
     fn configure_peer_routing(&self, peers: &[Peer]) -> Result<(), WireguardInterfaceError> {
         add_peer_routing(peers, &self.ifname)?;
+        configure_endpoints(peers);
         Ok(())
     }