lint

src/dns.rs

@@ -10,8 +10,8 @@ pub enum DnsResolver {
 impl DnsResolver {
     pub async fn lookup_host(&self, domain: &str, port: u16) -> anyhow::Result<Vec<SocketAddr>> {
         let addrs: Vec<SocketAddr> = match self {
-            DnsResolver::System => tokio::net::lookup_host(format!("{}:{}", domain, port)).await?.collect(),
-            DnsResolver::TrustDns(dns_resolver) => dns_resolver
+            Self::System => tokio::net::lookup_host(format!("{}:{}", domain, port)).await?.collect(),
+            Self::TrustDns(dns_resolver) => dns_resolver
                 .lookup_ip(domain)
                 .await?
                 .into_iter()

src/main.rs

@@ -344,11 +344,8 @@ enum LocalProtocol {
 }
 
 impl LocalProtocol {
-    pub fn is_reverse_tunnel(&self) -> bool {
-        matches!(
-            self,
-            LocalProtocol::ReverseTcp | LocalProtocol::ReverseUdp { .. } | LocalProtocol::ReverseSocks5
-        )
+    pub const fn is_reverse_tunnel(&self) -> bool {
+        matches!(self, Self::ReverseTcp | Self::ReverseUdp { .. } | Self::ReverseSocks5)
     }
 }
 
@@ -394,12 +391,10 @@ fn parse_local_bind(arg: &str) -> Result<(SocketAddr, &str), io::Error> {
     } else {
         // Maybe ipv4 addr
         let (ipv4_str, remaining) = arg.split_once(':').unwrap_or((arg, ""));
-
-        match Ipv4Addr::from_str(ipv4_str) {
-            Ok(ip4_addr) => (IpAddr::V4(ip4_addr), remaining),
-            // Must be the port, so we default to ipv4 bind
-            Err(_) => (IpAddr::V4(Ipv4Addr::from_str("127.0.0.1").unwrap()), arg),
-        }
+        Ipv4Addr::from_str(ipv4_str).map_or_else(
+            |_| (IpAddr::V4(Ipv4Addr::from_str("127.0.0.1").unwrap()), arg),
+            |ip4_addr| (IpAddr::V4(ip4_addr), remaining),
+        )
     };
 
     let remaining = remaining.trim_start_matches(':');
@@ -689,14 +684,14 @@ pub struct WsClientConfig {
 }
 
 impl WsClientConfig {
-    pub fn websocket_scheme(&self) -> &'static str {
+    pub const fn websocket_scheme(&self) -> &'static str {
         match self.remote_addr.tls().is_some() {
             false => "ws",
             true => "wss",
         }
     }
 
-    pub fn cnx_pool(&self) -> &bb8::Pool<WsClientConfig> {
+    pub fn cnx_pool(&self) -> &bb8::Pool<Self> {
         self.cnx_pool.as_ref().unwrap()
     }
 
@@ -707,16 +702,19 @@ impl WsClientConfig {
     pub fn tls_server_name(&self) -> ServerName<'static> {
         static INVALID_DNS_NAME: Lazy<DnsName> = Lazy::new(|| DnsName::try_from("dns-name-invalid.com").unwrap());
 
-        match self.remote_addr.tls().and_then(|tls| tls.tls_sni_override.as_ref()) {
-            None => match &self.remote_addr.host() {
-                Host::Domain(domain) => {
-                    ServerName::DnsName(DnsName::try_from(domain.clone()).unwrap_or_else(|_| INVALID_DNS_NAME.clone()))
-                }
-                Host::Ipv4(ip) => ServerName::IpAddress(IpAddr::V4(*ip).into()),
-                Host::Ipv6(ip) => ServerName::IpAddress(IpAddr::V6(*ip).into()),
-            },
-            Some(sni_override) => ServerName::DnsName(sni_override.clone()),
-        }
+        self.remote_addr
+            .tls()
+            .and_then(|tls| tls.tls_sni_override.as_ref())
+            .map_or_else(
+                || match &self.remote_addr.host() {
+                    Host::Domain(domain) => ServerName::DnsName(
+                        DnsName::try_from(domain.clone()).unwrap_or_else(|_| INVALID_DNS_NAME.clone()),
+                    ),
+                    Host::Ipv4(ip) => ServerName::IpAddress(IpAddr::V4(*ip).into()),
+                    Host::Ipv6(ip) => ServerName::IpAddress(IpAddr::V6(*ip).into()),
+                },
+                |sni_override| ServerName::DnsName(sni_override.clone()),
+            )
     }
 }
 

src/restrictions/config_reloader.rs

@@ -90,7 +90,7 @@ impl RestrictionsRulesReloader {
         self.restrictions = Arc::new(restrictions);
     }
 
-    pub fn restrictions_rules(&self) -> &Arc<RestrictionsRules> {
+    pub const fn restrictions_rules(&self) -> &Arc<RestrictionsRules> {
         &self.restrictions
     }
 

src/restrictions/mod.rs

@@ -17,15 +17,12 @@ pub mod config_reloader;
 pub mod types;
 
 impl RestrictionsRules {
-    pub fn from_config_file(config_path: &Path) -> anyhow::Result<RestrictionsRules> {
-        let restrictions: RestrictionsRules = serde_yaml::from_reader(BufReader::new(File::open(config_path)?))?;
+    pub fn from_config_file(config_path: &Path) -> anyhow::Result<Self> {
+        let restrictions: Self = serde_yaml::from_reader(BufReader::new(File::open(config_path)?))?;
         Ok(restrictions)
     }
 
-    pub fn from_path_prefix(
-        path_prefixes: &[String],
-        restrict_to: &[(String, u16)],
-    ) -> anyhow::Result<RestrictionsRules> {
+    pub fn from_path_prefix(path_prefixes: &[String], restrict_to: &[(String, u16)]) -> anyhow::Result<Self> {
         let tunnels_restrictions = if restrict_to.is_empty() {
             let r = types::AllowConfig::Tunnel(types::AllowTunnelConfig {
                 protocol: vec![],
@@ -108,6 +105,6 @@ impl RestrictionsRules {
                 .collect::<Result<Vec<_>, anyhow::Error>>()?
         };
 
-        Ok(RestrictionsRules { restrictions })
+        Ok(Self { restrictions })
     }
 }

src/restrictions/types.rs

@@ -160,11 +160,11 @@ impl From<&LocalProtocol> for ReverseTunnelConfigProtocol {
             | LocalProtocol::Socks5 { .. }
             | LocalProtocol::TProxyTcp { .. }
             | LocalProtocol::TProxyUdp { .. }
-            | LocalProtocol::Unix { .. } => ReverseTunnelConfigProtocol::Unknown,
-            LocalProtocol::ReverseTcp => ReverseTunnelConfigProtocol::Tcp,
-            LocalProtocol::ReverseUdp { .. } => ReverseTunnelConfigProtocol::Udp,
-            LocalProtocol::ReverseSocks5 => ReverseTunnelConfigProtocol::Socks5,
-            LocalProtocol::ReverseUnix { .. } => ReverseTunnelConfigProtocol::Unix,
+            | LocalProtocol::Unix { .. } => Self::Unknown,
+            LocalProtocol::ReverseTcp => Self::Tcp,
+            LocalProtocol::ReverseUdp { .. } => Self::Udp,
+            LocalProtocol::ReverseSocks5 => Self::Socks5,
+            LocalProtocol::ReverseUnix { .. } => Self::Unix,
         }
     }
 }
@@ -179,9 +179,9 @@ impl From<&LocalProtocol> for TunnelConfigProtocol {
             | LocalProtocol::Socks5 { .. }
             | LocalProtocol::TProxyTcp { .. }
             | LocalProtocol::TProxyUdp { .. }
-            | LocalProtocol::Unix { .. } => TunnelConfigProtocol::Unknown,
-            LocalProtocol::Tcp { .. } => TunnelConfigProtocol::Tcp,
-            LocalProtocol::Udp { .. } => TunnelConfigProtocol::Udp,
+            | LocalProtocol::Unix { .. } => Self::Unknown,
+            LocalProtocol::Tcp { .. } => Self::Tcp,
+            LocalProtocol::Udp { .. } => Self::Udp,
         }
     }
 }

src/socks5.rs

@@ -29,8 +29,8 @@ pub enum Socks5Stream {
 impl Socks5Stream {
     pub fn local_protocol(&self) -> LocalProtocol {
         match self {
-            Socks5Stream::Tcp(_) => LocalProtocol::Tcp { proxy_protocol: false },
-            Socks5Stream::Udp(s) => LocalProtocol::Udp {
+            Self::Tcp(_) => LocalProtocol::Tcp { proxy_protocol: false },
+            Self::Udp(s) => LocalProtocol::Udp {
                 timeout: s.watchdog_deadline.as_ref().map(|x| x.period()),
             },
         }
@@ -113,7 +113,7 @@ pub async fn run_server(bind: SocketAddr, timeout: Option<Duration>) -> Result<S
             };
 
             // Special case for UDP Associate where we return the bind addr of the udp server
-            if let Some(fast_socks5::Socks5Command::UDPAssociate) = cnx.cmd() {
+            if matches!(cnx.cmd(), Some(fast_socks5::Socks5Command::UDPAssociate)) {
                 let mut cnx = cnx.into_inner();
                 let ret = cnx.write_all(&new_reply(&ReplyError::Succeeded, bind)).await;
 
@@ -193,8 +193,8 @@ impl AsyncRead for Socks5Stream {
         buf: &mut ReadBuf<'_>,
     ) -> Poll<std::io::Result<()>> {
         match self.get_mut() {
-            Socks5Stream::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_read(cx, buf),
-            Socks5Stream::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_read(cx, buf),
+            Self::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_read(cx, buf),
+            Self::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_read(cx, buf),
         }
     }
 }
@@ -202,22 +202,22 @@ impl AsyncRead for Socks5Stream {
 impl AsyncWrite for Socks5Stream {
     fn poll_write(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>, buf: &[u8]) -> Poll<Result<usize, Error>> {
         match self.get_mut() {
-            Socks5Stream::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_write(cx, buf),
-            Socks5Stream::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_write(cx, buf),
+            Self::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_write(cx, buf),
+            Self::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_write(cx, buf),
         }
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Error>> {
         match self.get_mut() {
-            Socks5Stream::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_flush(cx),
-            Socks5Stream::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_flush(cx),
+            Self::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_flush(cx),
+            Self::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_flush(cx),
         }
     }
 
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Error>> {
         match self.get_mut() {
-            Socks5Stream::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_shutdown(cx),
-            Socks5Stream::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_shutdown(cx),
+            Self::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_shutdown(cx),
+            Self::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_shutdown(cx),
         }
     }
 
@@ -227,15 +227,15 @@ impl AsyncWrite for Socks5Stream {
         bufs: &[IoSlice<'_>],
     ) -> Poll<Result<usize, Error>> {
         match self.get_mut() {
-            Socks5Stream::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_write_vectored(cx, bufs),
-            Socks5Stream::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_write_vectored(cx, bufs),
+            Self::Tcp(s) => unsafe { Pin::new_unchecked(s) }.poll_write_vectored(cx, bufs),
+            Self::Udp(s) => unsafe { Pin::new_unchecked(s) }.poll_write_vectored(cx, bufs),
         }
     }
 
     fn is_write_vectored(&self) -> bool {
         match self {
-            Socks5Stream::Tcp(s) => s.is_write_vectored(),
-            Socks5Stream::Udp(s) => s.is_write_vectored(),
+            Self::Tcp(s) => s.is_write_vectored(),
+            Self::Udp(s) => s.is_write_vectored(),
         }
     }
 }

src/tcp.rs

@@ -97,16 +97,7 @@ pub async fn connect(
         }
     }
 
-    if let Some(cnx) = cnx {
-        Ok(cnx)
-    } else {
-        Err(anyhow!(
-            "Cannot connect to tcp endpoint {}:{} reason {:?}",
-            host,
-            port,
-            last_err
-        ))
-    }
+    cnx.ok_or_else(|| anyhow!("Cannot connect to tcp endpoint {}:{} reason {:?}", host, port, last_err))
 }
 
 #[instrument(level = "info", name = "http_proxy", skip_all)]
@@ -264,10 +255,7 @@ mod tests {
         let mut buf = [0u8; 25];
         let ret = client_srv.read(&mut buf).await;
         assert!(matches!(ret, Ok(18)));
-        client_srv
-            .write_all("HTTP/1.1 200 OK\r\n\r\n".as_bytes())
-            .await
-            .unwrap();
+        client_srv.write_all(b"HTTP/1.1 200 OK\r\n\r\n").await.unwrap();
 
         client_srv.get_mut().shutdown().await.unwrap();
         let _ = client.read(&mut buf).await.unwrap();

src/tunnel/mod.rs

@@ -88,29 +88,24 @@ pub enum TransportScheme {
 }
 
 impl TransportScheme {
-    pub fn values() -> &'static [TransportScheme] {
-        &[
-            TransportScheme::Ws,
-            TransportScheme::Wss,
-            TransportScheme::Http,
-            TransportScheme::Https,
-        ]
+    pub const fn values() -> &'static [Self] {
+        &[Self::Ws, Self::Wss, Self::Http, Self::Https]
     }
-    pub fn to_str(self) -> &'static str {
+    pub const fn to_str(self) -> &'static str {
         match self {
-            TransportScheme::Ws => "ws",
-            TransportScheme::Wss => "wss",
-            TransportScheme::Http => "http",
-            TransportScheme::Https => "https",
+            Self::Ws => "ws",
+            Self::Wss => "wss",
+            Self::Http => "http",
+            Self::Https => "https",
         }
     }
 
     pub fn alpn_protocols(&self) -> Vec<Vec<u8>> {
         match self {
-            TransportScheme::Ws => vec![],
-            TransportScheme::Wss => vec![b"http/1.1".to_vec()],
-            TransportScheme::Http => vec![],
-            TransportScheme::Https => vec![b"h2".to_vec()],
+            Self::Ws => vec![],
+            Self::Wss => vec![b"http/1.1".to_vec()],
+            Self::Http => vec![],
+            Self::Https => vec![b"h2".to_vec()],
         }
     }
 }
@@ -119,10 +114,10 @@ impl FromStr for TransportScheme {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "https" => Ok(TransportScheme::Https),
-            "http" => Ok(TransportScheme::Http),
-            "wss" => Ok(TransportScheme::Wss),
-            "ws" => Ok(TransportScheme::Ws),
+            "https" => Ok(Self::Https),
+            "http" => Ok(Self::Http),
+            "wss" => Ok(Self::Wss),
+            "ws" => Ok(Self::Ws),
             _ => Err(()),
         }
     }
@@ -169,71 +164,71 @@ impl Debug for TransportAddr {
 impl TransportAddr {
     pub fn new(scheme: TransportScheme, host: Host, port: u16, tls: Option<TlsClientConfig>) -> Option<Self> {
         match scheme {
-            TransportScheme::Https => Some(TransportAddr::Https {
+            TransportScheme::Https => Some(Self::Https {
                 scheme: TransportScheme::Https,
                 tls: tls?,
                 host,
                 port,
             }),
-            TransportScheme::Http => Some(TransportAddr::Http {
+            TransportScheme::Http => Some(Self::Http {
                 scheme: TransportScheme::Http,
                 host,
                 port,
             }),
-            TransportScheme::Wss => Some(TransportAddr::Wss {
+            TransportScheme::Wss => Some(Self::Wss {
                 scheme: TransportScheme::Wss,
                 tls: tls?,
                 host,
                 port,
             }),
-            TransportScheme::Ws => Some(TransportAddr::Ws {
+            TransportScheme::Ws => Some(Self::Ws {
                 scheme: TransportScheme::Ws,
                 host,
                 port,
             }),
         }
     }
-    pub fn is_websocket(&self) -> bool {
-        matches!(self, TransportAddr::Ws { .. } | TransportAddr::Wss { .. })
+    pub const fn is_websocket(&self) -> bool {
+        matches!(self, Self::Ws { .. } | Self::Wss { .. })
     }
 
-    pub fn is_http2(&self) -> bool {
-        matches!(self, TransportAddr::Http { .. } | TransportAddr::Https { .. })
+    pub const fn is_http2(&self) -> bool {
+        matches!(self, Self::Http { .. } | Self::Https { .. })
     }
 
-    pub fn tls(&self) -> Option<&TlsClientConfig> {
+    pub const fn tls(&self) -> Option<&TlsClientConfig> {
         match self {
-            TransportAddr::Wss { tls, .. } => Some(tls),
-            TransportAddr::Https { tls, .. } => Some(tls),
-            TransportAddr::Ws { .. } => None,
-            TransportAddr::Http { .. } => None,
+            Self::Wss { tls, .. } => Some(tls),
+            Self::Https { tls, .. } => Some(tls),
+            Self::Ws { .. } => None,
+            Self::Http { .. } => None,
         }
     }
 
-    pub fn host(&self) -> &Host {
+    pub const fn host(&self) -> &Host {
         match self {
-            TransportAddr::Wss { host, .. } => host,
-            TransportAddr::Ws { host, .. } => host,
-            TransportAddr::Https { host, .. } => host,
-            TransportAddr::Http { host, .. } => host,
+            Self::Wss { host, .. } => host,
+            Self::Ws { host, .. } => host,
+            Self::Https { host, .. } => host,
+            Self::Http { host, .. } => host,
         }
     }
 
-    pub fn port(&self) -> u16 {
+    pub const fn port(&self) -> u16 {
         match self {
-            TransportAddr::Wss { port, .. } => *port,
-            TransportAddr::Ws { port, .. } => *port,
-            TransportAddr::Https { port, .. } => *port,
-            TransportAddr::Http { port, .. } => *port,
+            Self::Wss { port, .. } => *port,
+            Self::Ws { port, .. } => *port,
+            Self::Https { port, .. } => *port,
+            Self::Http { port, .. } => *port,
         }
     }
 
-    pub fn scheme(&self) -> &TransportScheme {
+    pub const fn scheme(&self) -> &TransportScheme {
         match self {
-            TransportAddr::Wss { scheme, .. } => scheme,
-            TransportAddr::Ws { scheme, .. } => scheme,
-            TransportAddr::Https { scheme, .. } => scheme,
-            TransportAddr::Http { scheme, .. } => scheme,
+            Self::Wss { scheme, .. } => scheme,
+            Self::Ws { scheme, .. } => scheme,
+            Self::Https { scheme, .. } => scheme,
+            Self::Http { scheme, .. } => scheme,
         }
     }
 }
@@ -257,8 +252,8 @@ pub enum TransportStream {
 impl AsyncRead for TransportStream {
     fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
         match self.get_mut() {
-            TransportStream::Plain(cnx) => Pin::new(cnx).poll_read(cx, buf),
-            TransportStream::Tls(cnx) => Pin::new(cnx).poll_read(cx, buf),
+            Self::Plain(cnx) => Pin::new(cnx).poll_read(cx, buf),
+            Self::Tls(cnx) => Pin::new(cnx).poll_read(cx, buf),
         }
     }
 }
@@ -266,22 +261,22 @@ impl AsyncRead for TransportStream {
 impl AsyncWrite for TransportStream {
     fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize, Error>> {
         match self.get_mut() {
-            TransportStream::Plain(cnx) => Pin::new(cnx).poll_write(cx, buf),
-            TransportStream::Tls(cnx) => Pin::new(cnx).poll_write(cx, buf),
+            Self::Plain(cnx) => Pin::new(cnx).poll_write(cx, buf),
+            Self::Tls(cnx) => Pin::new(cnx).poll_write(cx, buf),
         }
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
         match self.get_mut() {
-            TransportStream::Plain(cnx) => Pin::new(cnx).poll_flush(cx),
-            TransportStream::Tls(cnx) => Pin::new(cnx).poll_flush(cx),
+            Self::Plain(cnx) => Pin::new(cnx).poll_flush(cx),
+            Self::Tls(cnx) => Pin::new(cnx).poll_flush(cx),
         }
     }
 
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
         match self.get_mut() {
-            TransportStream::Plain(cnx) => Pin::new(cnx).poll_shutdown(cx),
-            TransportStream::Tls(cnx) => Pin::new(cnx).poll_shutdown(cx),
+            Self::Plain(cnx) => Pin::new(cnx).poll_shutdown(cx),
+            Self::Tls(cnx) => Pin::new(cnx).poll_shutdown(cx),
         }
     }
 
@@ -291,15 +286,15 @@ impl AsyncWrite for TransportStream {
         bufs: &[IoSlice<'_>],
     ) -> Poll<Result<usize, Error>> {
         match self.get_mut() {
-            TransportStream::Plain(cnx) => Pin::new(cnx).poll_write_vectored(cx, bufs),
-            TransportStream::Tls(cnx) => Pin::new(cnx).poll_write_vectored(cx, bufs),
+            Self::Plain(cnx) => Pin::new(cnx).poll_write_vectored(cx, bufs),
+            Self::Tls(cnx) => Pin::new(cnx).poll_write_vectored(cx, bufs),
         }
     }
 
     fn is_write_vectored(&self) -> bool {
         match &self {
-            TransportStream::Plain(cnx) => cnx.is_write_vectored(),
-            TransportStream::Tls(cnx) => cnx.is_write_vectored(),
+            Self::Plain(cnx) => cnx.is_write_vectored(),
+            Self::Tls(cnx) => cnx.is_write_vectored(),
         }
     }
 }

src/tunnel/tls_reloader.rs

@@ -37,7 +37,7 @@ enum TlsReloaderState {
 impl TlsReloaderState {
     fn fs_watcher(&self) -> &Mutex<RecommendedWatcher> {
         match self {
-            TlsReloaderState::Empty => unreachable!(),
+            Self::Empty => unreachable!(),
             Server(this) => &this.fs_watcher,
             Client(this) => &this.fs_watcher,
         }

src/tunnel/transport/http2.rs

@@ -24,7 +24,7 @@ pub struct Http2TunnelRead {
 }
 
 impl Http2TunnelRead {
-    pub fn new(inner: BodyStream<Incoming>) -> Self {
+    pub const fn new(inner: BodyStream<Incoming>) -> Self {
         Self { inner }
     }
 }
@@ -108,23 +108,24 @@ pub async fn connect(
     }?;
 
     // In http2 HOST header does not exist, it is explicitly set in the authority from the request uri
-    let (headers_file, authority) = if let Some(headers_file_path) = &client_cfg.http_headers_file {
-        let (host, headers) = headers_from_file(headers_file_path);
-        let host = if let Some((_, v)) = host {
-            match (client_cfg.remote_addr.scheme(), client_cfg.remote_addr.port()) {
-                (TransportScheme::Http, 80) | (TransportScheme::Https, 443) => {
-                    Some(v.to_str().unwrap_or("").to_string())
+    let (headers_file, authority) = client_cfg
+        .http_headers_file
+        .as_ref()
+        .map_or((None, None), |headers_file_path| {
+            let (host, headers) = headers_from_file(headers_file_path);
+            let host = if let Some((_, v)) = host {
+                match (client_cfg.remote_addr.scheme(), client_cfg.remote_addr.port()) {
+                    (TransportScheme::Http, 80) | (TransportScheme::Https, 443) => {
+                        Some(v.to_str().unwrap_or("").to_string())
+                    }
+                    (_, port) => Some(format!("{}:{}", v.to_str().unwrap_or(""), port)),
                 }
-                (_, port) => Some(format!("{}:{}", v.to_str().unwrap_or(""), port)),
-            }
-        } else {
-            None
-        };
+            } else {
+                None
+            };
 
-        (Some(headers), host)
-    } else {
-        (None, None)
-    };
+            (Some(headers), host)
+        });
 
     let mut req = Request::builder()
         .method("POST")
@@ -133,7 +134,7 @@ pub async fn connect(
             client_cfg.remote_addr.scheme(),
             authority
                 .as_deref()
-                .unwrap_or(client_cfg.http_header_host.to_str().unwrap_or("")),
+                .unwrap_or_else(|| client_cfg.http_header_host.to_str().unwrap_or("")),
             &client_cfg.http_upgrade_path_prefix
         ))
         .header(COOKIE, tunnel_to_jwt_token(request_id, dest_addr))

src/tunnel/transport/io.rs

@@ -24,7 +24,7 @@ pub async fn propagate_local_to_remote(
     // We do our own pin_mut! to avoid shadowing timeout and be able to reset it, on next loop iteration
     // We reuse the future to avoid creating a timer in the tight loop
     let frequency = ping_frequency.unwrap_or(Duration::from_secs(3600 * 24));
-    let start_at = Instant::now().checked_add(frequency).unwrap_or(Instant::now());
+    let start_at = Instant::now().checked_add(frequency).unwrap_or_else(Instant::now);
     let timeout = tokio::time::interval_at(start_at, frequency);
     let should_close = close_tx.closed().fuse();
 

src/tunnel/transport/mod.rs

@@ -38,8 +38,8 @@ pub enum TunnelReader {
 impl TunnelRead for TunnelReader {
     async fn copy(&mut self, writer: impl AsyncWrite + Unpin + Send) -> Result<(), std::io::Error> {
         match self {
-            TunnelReader::Websocket(s) => s.copy(writer).await,
-            TunnelReader::Http2(s) => s.copy(writer).await,
+            Self::Websocket(s) => s.copy(writer).await,
+            Self::Http2(s) => s.copy(writer).await,
         }
     }
 }
@@ -52,29 +52,29 @@ pub enum TunnelWriter {
 impl TunnelWrite for TunnelWriter {
     fn buf_mut(&mut self) -> &mut BytesMut {
         match self {
-            TunnelWriter::Websocket(s) => s.buf_mut(),
-            TunnelWriter::Http2(s) => s.buf_mut(),
+            Self::Websocket(s) => s.buf_mut(),
+            Self::Http2(s) => s.buf_mut(),
         }
     }
 
     async fn write(&mut self) -> Result<(), std::io::Error> {
         match self {
-            TunnelWriter::Websocket(s) => s.write().await,
-            TunnelWriter::Http2(s) => s.write().await,
+            Self::Websocket(s) => s.write().await,
+            Self::Http2(s) => s.write().await,
         }
     }
 
     async fn ping(&mut self) -> Result<(), std::io::Error> {
         match self {
-            TunnelWriter::Websocket(s) => s.ping().await,
-            TunnelWriter::Http2(s) => s.ping().await,
+            Self::Websocket(s) => s.ping().await,
+            Self::Http2(s) => s.ping().await,
         }
     }
 
     async fn close(&mut self) -> Result<(), std::io::Error> {
         match self {
-            TunnelWriter::Websocket(s) => s.close().await,
-            TunnelWriter::Http2(s) => s.close().await,
+            Self::Websocket(s) => s.close().await,
+            Self::Http2(s) => s.close().await,
         }
     }
 }

src/tunnel/transport/websocket.rs

@@ -97,7 +97,7 @@ pub struct WebsocketTunnelRead {
 }
 
 impl WebsocketTunnelRead {
-    pub fn new(ws: WebSocketRead<ReadHalf<TokioIo<Upgraded>>>) -> Self {
+    pub const fn new(ws: WebSocketRead<ReadHalf<TokioIo<Upgraded>>>) -> Self {
         Self { inner: ws }
     }
 }

src/unix_socket.rs

@@ -13,7 +13,7 @@ pub struct UnixListenerStream {
 }
 
 impl UnixListenerStream {
-    pub fn new(listener: UnixListener, path_to_delete: bool) -> Self {
+    pub const fn new(listener: UnixListener, path_to_delete: bool) -> Self {
         Self {
             inner: listener,
             path_to_delete,