From 2dd99130fac102911a71eed6e0b52bf8e9d4a8b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3rebe=20-=20Romain=20GERARD?= Date: Wed, 29 May 2024 19:19:03 +0200 Subject: [PATCH] lint --- src/dns.rs | 4 +- src/main.rs | 44 +++++------ src/restrictions/config_reloader.rs | 2 +- src/restrictions/mod.rs | 11 +-- src/restrictions/types.rs | 16 ++-- src/socks5.rs | 30 ++++---- src/tcp.rs | 16 +--- src/tunnel/mod.rs | 115 +++++++++++++--------------- src/tunnel/tls_reloader.rs | 2 +- src/tunnel/transport/http2.rs | 35 +++++---- src/tunnel/transport/io.rs | 2 +- src/tunnel/transport/mod.rs | 20 ++--- src/tunnel/transport/websocket.rs | 2 +- src/unix_socket.rs | 2 +- 14 files changed, 140 insertions(+), 161 deletions(-) diff --git a/src/dns.rs b/src/dns.rs index bb1742b..28b9749 100644 --- a/src/dns.rs +++ b/src/dns.rs @@ -10,8 +10,8 @@ pub enum DnsResolver { impl DnsResolver { pub async fn lookup_host(&self, domain: &str, port: u16) -> anyhow::Result> { let addrs: Vec = 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() diff --git a/src/main.rs b/src/main.rs index 1e4852f..6a6ea2c 100644 --- a/src/main.rs +++ b/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 { + pub fn cnx_pool(&self) -> &bb8::Pool { 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 = 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()), + ) } } diff --git a/src/restrictions/config_reloader.rs b/src/restrictions/config_reloader.rs index beae0cb..e31f6ba 100644 --- a/src/restrictions/config_reloader.rs +++ b/src/restrictions/config_reloader.rs @@ -90,7 +90,7 @@ impl RestrictionsRulesReloader { self.restrictions = Arc::new(restrictions); } - pub fn restrictions_rules(&self) -> &Arc { + pub const fn restrictions_rules(&self) -> &Arc { &self.restrictions } diff --git a/src/restrictions/mod.rs b/src/restrictions/mod.rs index 87f7bd1..862d4af 100644 --- a/src/restrictions/mod.rs +++ b/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 { - let restrictions: RestrictionsRules = serde_yaml::from_reader(BufReader::new(File::open(config_path)?))?; + pub fn from_config_file(config_path: &Path) -> anyhow::Result { + 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 { + pub fn from_path_prefix(path_prefixes: &[String], restrict_to: &[(String, u16)]) -> anyhow::Result { let tunnels_restrictions = if restrict_to.is_empty() { let r = types::AllowConfig::Tunnel(types::AllowTunnelConfig { protocol: vec![], @@ -108,6 +105,6 @@ impl RestrictionsRules { .collect::, anyhow::Error>>()? }; - Ok(RestrictionsRules { restrictions }) + Ok(Self { restrictions }) } } diff --git a/src/restrictions/types.rs b/src/restrictions/types.rs index e0cd49c..ba01c45 100644 --- a/src/restrictions/types.rs +++ b/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, } } } diff --git a/src/socks5.rs b/src/socks5.rs index 341d840..8084548 100644 --- a/src/socks5.rs +++ b/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) -> Result, ) -> Poll> { 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> { 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> { 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> { 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> { 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(), } } } diff --git a/src/tcp.rs b/src/tcp.rs index 946f492..50ea138 100644 --- a/src/tcp.rs +++ b/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(); diff --git a/src/tunnel/mod.rs b/src/tunnel/mod.rs index 3192615..f72c97b 100644 --- a/src/tunnel/mod.rs +++ b/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> { 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 { 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) -> Option { 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> { 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> { 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> { 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> { 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> { 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(), } } } diff --git a/src/tunnel/tls_reloader.rs b/src/tunnel/tls_reloader.rs index ffc6c67..17cc761 100644 --- a/src/tunnel/tls_reloader.rs +++ b/src/tunnel/tls_reloader.rs @@ -37,7 +37,7 @@ enum TlsReloaderState { impl TlsReloaderState { fn fs_watcher(&self) -> &Mutex { match self { - TlsReloaderState::Empty => unreachable!(), + Self::Empty => unreachable!(), Server(this) => &this.fs_watcher, Client(this) => &this.fs_watcher, } diff --git a/src/tunnel/transport/http2.rs b/src/tunnel/transport/http2.rs index 9b6eadb..e0967ad 100644 --- a/src/tunnel/transport/http2.rs +++ b/src/tunnel/transport/http2.rs @@ -24,7 +24,7 @@ pub struct Http2TunnelRead { } impl Http2TunnelRead { - pub fn new(inner: BodyStream) -> Self { + pub const fn new(inner: BodyStream) -> 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)) diff --git a/src/tunnel/transport/io.rs b/src/tunnel/transport/io.rs index 6a782a0..a3706a3 100644 --- a/src/tunnel/transport/io.rs +++ b/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(); diff --git a/src/tunnel/transport/mod.rs b/src/tunnel/transport/mod.rs index f41301c..56b9788 100644 --- a/src/tunnel/transport/mod.rs +++ b/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, } } } diff --git a/src/tunnel/transport/websocket.rs b/src/tunnel/transport/websocket.rs index f433da5..8b1a335 100644 --- a/src/tunnel/transport/websocket.rs +++ b/src/tunnel/transport/websocket.rs @@ -97,7 +97,7 @@ pub struct WebsocketTunnelRead { } impl WebsocketTunnelRead { - pub fn new(ws: WebSocketRead>>) -> Self { + pub const fn new(ws: WebSocketRead>>) -> Self { Self { inner: ws } } } diff --git a/src/unix_socket.rs b/src/unix_socket.rs index 7dae343..0808290 100644 --- a/src/unix_socket.rs +++ b/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,