Set trust-dns as default, optimized most of the context.clone()s

Author: zonyitoo

Cargo.lock

@@ -32,7 +32,7 @@ path = "src/bin/ssurl.rs"
 lto = true
 
 [features]
-default = ["sodium", "rc4", "aes-cfb", "aes-ctr"]
+default = ["sodium", "rc4", "aes-cfb", "aes-ctr", "trust-dns"]
 sodium = ["libsodium-ffi"]
 rc4 = ["openssl"]
 aes-cfb = ["openssl"]
@@ -64,11 +64,9 @@ serde_urlencoded = "0.6"
 serde = { version = "1.0", features = ["derive"] }
 url = "2.1"
 byte_string = "1.0"
-# libsodium-ffi = { version = "0.1", optional = true }
-libsodium-ffi = { git = "https://github.com/zonyitoo/libsodium-ffi", optional = true }
+libsodium-ffi = { version = "0.2", optional = true }
 miscreant = { version = "0.4", optional = true }
-# trust-dns-resolver = { version = "0.11", features = ["dns-over-rustls", "dns-over-https-rustls"] }
-trust-dns-resolver = { git = "https://github.com/bluejekyll/trust-dns", features = ["dns-over-rustls", "dns-over-https-rustls"], optional = true }
+trust-dns-resolver = { version = "0.18.0-alpha", features = ["dns-over-rustls", "dns-over-https-rustls"], optional = true }
 hkdf = "0.8"
 hmac = "0.7"
 sha-1 = "0.8"

Cargo.toml

@@ -11,5 +11,5 @@ RUN cd /home/rust/libs && \
     V=1 make && sudo make install && \
     cd .. && rm -rf libsodium-$SODIUM_VERS.tar.gz libsodium-$SODIUM_VERS
 
-ENV SODIUM_STATIC=yes
+#ENV SODIUM_STATIC=yes
 ENV SODIUM_LIB_DIR=/usr/local/musl/lib

build/Dockerfile

@@ -5,17 +5,17 @@ use std::sync::{
     Arc,
 };
 
-#[cfg(futures = "trust-dns")]
+#[cfg(feature = "trust-dns")]
 use trust_dns_resolver::AsyncResolver;
 
 use crate::config::Config;
 
-#[cfg(futures = "trust-dns")]
+#[cfg(feature = "trust-dns")]
 use crate::relay::dns_resolver::create_resolver;
 
 #[derive(Clone)]
 pub struct SharedServerState {
-    #[cfg(futures = "trust-dns")]
+    #[cfg(feature = "trust-dns")]
     dns_resolver: Arc<AsyncResolver>,
     server_running: Arc<AtomicBool>,
 }
@@ -24,7 +24,7 @@ impl SharedServerState {
     #[allow(unused_variables)]
     pub fn new(config: &Config) -> SharedServerState {
         SharedServerState {
-            #[cfg(futures = "trust-dns")]
+            #[cfg(feature = "trust-dns")]
             dns_resolver: Arc::new(create_resolver(config.get_dns_config())),
             server_running: Arc::new(AtomicBool::new(true)),
         }
@@ -41,7 +41,7 @@ impl SharedServerState {
     }
 
     /// Get the global shared resolver
-    #[cfg(futures = "trust-dns")]
+    #[cfg(feature = "trust-dns")]
     pub fn dns_resolver(&self) -> &AsyncResolver {
         &*self.dns_resolver
     }
@@ -78,7 +78,7 @@ impl Context {
     }
 
     /// Get the global shared resolver
-    #[cfg(futures = "trust-dns")]
+    #[cfg(feature = "trust-dns")]
     pub fn dns_resolver(&self) -> &AsyncResolver {
         self.server_state.dns_resolver()
     }

src/context.rs

@@ -9,7 +9,7 @@ use log::{debug, error, trace};
 use tokio;
 use trust_dns_resolver::{config::ResolverConfig, AsyncResolver};
 
-use crate::context::SharedContext;
+use crate::context::Context;
 
 pub fn create_resolver(dns: Option<ResolverConfig>) -> AsyncResolver {
     let (resolver, bg) = {
@@ -69,12 +69,7 @@ pub fn create_resolver(dns: Option<ResolverConfig>) -> AsyncResolver {
     resolver
 }
 
-async fn inner_resolve(
-    context: SharedContext,
-    addr: &str,
-    port: u16,
-    check_forbidden: bool,
-) -> io::Result<Vec<SocketAddr>> {
+async fn inner_resolve(context: &Context, addr: &str, port: u16, check_forbidden: bool) -> io::Result<Vec<SocketAddr>> {
     match context.dns_resolver().lookup_ip(addr).await {
         Err(err) => {
             error!("Failed to resolve {}:{}, err: {}", addr, port, err);
@@ -109,11 +104,6 @@ async fn inner_resolve(
 }
 
 /// Resolve address to IP
-pub async fn resolve(
-    context: SharedContext,
-    addr: &str,
-    port: u16,
-    check_forbidden: bool,
-) -> io::Result<Vec<SocketAddr>> {
+pub async fn resolve(context: &Context, addr: &str, port: u16, check_forbidden: bool) -> io::Result<Vec<SocketAddr>> {
     inner_resolve(context, addr, port, check_forbidden).await
 }

src/relay/dns_resolver/trust_dns_resolver.rs

@@ -1,17 +1,15 @@
 use std::{
     collections::VecDeque,
-    fmt,
-    io,
+    fmt, io,
     sync::{
         atomic::{AtomicU64, AtomicUsize, Ordering},
-        Arc,
-        Mutex,
+        Arc, Mutex,
     },
 };
 
 use crate::{
     config::ServerConfig,
-    context::SharedContext,
+    context::{Context, SharedContext},
     relay::{loadbalancing::server::LoadBalancer, socks5::Address, tcprelay::client::ServerClient},
 };
 
@@ -144,7 +142,7 @@ impl Inner {
 
                     while context.server_running() {
                         interval.tick().await;
-                        let score = match Inner::check_delay(sc.clone(), context.clone()).await {
+                        let score = match Inner::check_delay(&*sc, &*context).await {
                             Ok(d) => latency.push(d),
                             Err(..) => latency.push(DEFAULT_CHECK_TIMEOUT_SEC * 2 * 1000), // Penalty
                         };
@@ -161,7 +159,7 @@ impl Inner {
         }
     }
 
-    async fn check_request(sc: Arc<ServerConfig>, context: SharedContext) -> io::Result<()> {
+    async fn check_request(sc: Arc<ServerConfig>, context: &Context) -> io::Result<()> {
         static GET_BODY: &[u8] =
             b"GET /generate_204 HTTP/1.1\r\nHost: dl.google.com\r\nConnection: close\r\nAccept: */*\r\n\r\n";
 
@@ -176,12 +174,12 @@ impl Inner {
         Ok(())
     }
 
-    async fn check_delay(sc: Arc<Server>, context: SharedContext) -> io::Result<u64> {
+    async fn check_delay(sc: &Server, context: &Context) -> io::Result<u64> {
         let start = Instant::now();
 
         // Send HTTP GET and read the first byte
         let timeout = Duration::from_secs(DEFAULT_CHECK_TIMEOUT_SEC);
-        let res = time::timeout(timeout, Inner::check_request(sc.config.clone(), context.clone())).await;
+        let res = time::timeout(timeout, Inner::check_request(sc.config.clone(), context)).await;
 
         let elapsed = Instant::now() - start;
         let elapsed = elapsed.as_secs() * 1000 + u64::from(elapsed.subsec_millis()); // Converted to ms

src/relay/loadbalancing/server/ping.rs

@@ -5,25 +5,18 @@ use std::{
     net::SocketAddr,
     pin::Pin,
     sync::Arc,
-    task::{Context, Poll},
+    task::{self, Poll},
 };
 
 use log::trace;
 use tokio::{net::TcpStream, prelude::*};
 
 use crate::relay::socks5::{
-    self,
-    Address,
-    Command,
-    HandshakeRequest,
-    HandshakeResponse,
-    Reply,
-    TcpRequestHeader,
-    TcpResponseHeader,
+    self, Address, Command, HandshakeRequest, HandshakeResponse, Reply, TcpRequestHeader, TcpResponseHeader,
 };
 
 use super::{CryptoStream, STcpStream};
-use crate::{config::ServerConfig, context::SharedContext};
+use crate::{config::ServerConfig, context::Context};
 
 /// Socks5 proxy client
 pub struct Socks5Client {
@@ -111,21 +104,21 @@ impl Socks5Client {
 }
 
 impl AsyncRead for Socks5Client {
-    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll<Result<usize, io::Error>> {
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut task::Context, buf: &mut [u8]) -> Poll<Result<usize, io::Error>> {
         Pin::new(&mut self.stream).poll_read(cx, buf)
     }
 }
 
 impl AsyncWrite for Socks5Client {
-    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<Result<usize, io::Error>> {
+    fn poll_write(mut self: Pin<&mut Self>, cx: &mut task::Context, buf: &[u8]) -> Poll<Result<usize, io::Error>> {
         Pin::new(&mut self.stream).poll_write(cx, buf)
     }
 
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<Result<(), io::Error>> {
         Pin::new(&mut self.stream).poll_flush(cx)
     }
 
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<Result<(), io::Error>> {
         Pin::new(&mut self.stream).poll_shutdown(cx)
     }
 }
@@ -136,11 +129,11 @@ pub(crate) struct ServerClient {
 
 impl ServerClient {
     pub(crate) async fn connect(
-        context: SharedContext,
+        context: &Context,
         addr: &Address,
         svr_cfg: Arc<ServerConfig>,
     ) -> io::Result<ServerClient> {
-        let stream = super::connect_proxy_server(context, svr_cfg.clone()).await?;
+        let stream = super::connect_proxy_server(context, &*svr_cfg).await?;
         Ok(ServerClient {
             stream: super::proxy_server_handshake(stream, svr_cfg, addr).await?,
         })

src/relay/tcprelay/client.rs

@@ -102,7 +102,7 @@ impl TcpServerContext {
             ServerAddr::DomainName(ref domain, ref port) => {
                 use crate::relay::dns_resolver::resolve;
 
-                let addrs = resolve(self.context.clone(), &domain[..], *port, false).await?;
+                let addrs = resolve(&*self.context, &domain[..], *port, false).await?;
                 socket.send_to(payload.as_ref(), addrs[0]).await?;
             }
             #[cfg(not(feature = "trust-dns"))]

src/relay/tcprelay/context.rs

@@ -10,23 +10,22 @@ use std::{
     ops::{Deref, DerefMut},
     pin::Pin,
     sync::Arc,
-    task::{Context, Poll},
+    task::{self, Poll},
     time::Duration,
 };
 
 use crate::{
     config::{ConfigType, ServerAddr, ServerConfig},
-    context::SharedContext,
+    context::Context,
     relay::{socks5::Address, utils::try_timeout},
 };
 
 use bytes::BytesMut;
 use futures::{future::FusedFuture, ready, select, Future};
 use log::trace;
 use tokio::{
-    io::{BufReader, ReadHalf, WriteHalf},
+    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, BufReader, ReadHalf, WriteHalf},
     net::TcpStream,
-    prelude::*,
     time::{self, Delay},
 };
 
@@ -78,7 +77,7 @@ impl<S> Connection<S> {
         ErrorKind::TimedOut.into()
     }
 
-    fn poll_timeout(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    fn poll_timeout(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
         loop {
             if let Some(ref mut timer) = self.timer {
                 ready!(Pin::new(timer).poll(cx));
@@ -135,7 +134,7 @@ impl<S> AsyncRead for Connection<S>
 where
     S: AsyncRead + Unpin,
 {
-    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
         match Pin::new(&mut self.stream).poll_read(cx, buf) {
             Poll::Ready(r) => {
                 self.cancel_timeout();
@@ -153,7 +152,7 @@ impl<S> AsyncWrite for Connection<S>
 where
     S: AsyncRead + AsyncWrite + Unpin,
 {
-    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
+    fn poll_write(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
         match Pin::new(&mut self.stream).poll_write(cx, buf) {
             Poll::Ready(r) => {
                 self.cancel_timeout();
@@ -166,7 +165,7 @@ where
         }
     }
 
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
         match Pin::new(&mut self.stream).poll_flush(cx) {
             Poll::Ready(r) => {
                 self.cancel_timeout();
@@ -179,15 +178,15 @@ where
         }
     }
 
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
         Pin::new(&mut self.stream).poll_shutdown(cx)
     }
 }
 
 pub type STcpStream = Connection<TcpStream>;
 
 /// Connect to proxy server with `ServerConfig`
-async fn connect_proxy_server(context: SharedContext, svr_cfg: Arc<ServerConfig>) -> io::Result<STcpStream> {
+async fn connect_proxy_server(context: &Context, svr_cfg: &ServerConfig) -> io::Result<STcpStream> {
     let timeout = svr_cfg.timeout();
 
     let svr_addr = match context.config().config_type {
@@ -213,7 +212,7 @@ async fn connect_proxy_server(context: SharedContext, svr_cfg: Arc<ServerConfig>
             let mut last_err: Option<io::Error> = None;
             for addr in &vec_ipaddr {
                 match try_timeout(TcpStream::connect(addr), timeout).await {
-                    Ok(s) => return Ok(STcpStream::new(BufReader::new(s), timeout)),
+                    Ok(s) => return Ok(STcpStream::new(s, timeout)),
                     Err(e) => {
                         error!(
                             "Failed to connect {}:{}, resolved address {}, try another (err: {})",

src/relay/tcprelay/mod.rs

@@ -17,8 +17,7 @@ use crate::{context::SharedContext, relay::socks5::Address};
 use super::{
     context::{SharedTcpServerContext, TcpServerContext},
     monitor::TcpMonStream,
-    CryptoStream,
-    STcpStream,
+    CryptoStream, STcpStream,
 };
 
 #[allow(clippy::cognitive_complexity)]
@@ -94,7 +93,7 @@ async fn handle_client(
         Address::DomainNameAddress(ref dname, port) => {
             use crate::relay::dns_resolver::resolve;
 
-            let addrs = match resolve(context.clone(), dname.as_str(), port, true).await {
+            let addrs = match resolve(&*context, dname.as_str(), port, true).await {
                 Ok(r) => r,
                 Err(err) => {
                     error!("Failed to resolve {}, {}", dname, err);