feat: allow empty chains in conn_selector

Banyc · Banyc · commit ff841ac3a00d · 2025-08-14T22:36:10.000+08:00
diff --git a/common/src/route/conn_selector.rs b/common/src/route/conn_selector.rs
@@ -83,13 +83,43 @@ pub trait BuildTracer {
 }
 
 #[derive(Debug, Clone)]
-pub struct ConnSelector<Addr> {
+pub enum ConnSelector<Addr> {
+    Empty,
+    Some(ConnSelector1<Addr>),
+}
+impl<Addr> ConnSelector<Addr>
+where
+    Addr: std::fmt::Debug + fmt::Display + Clone + Send + Sync + 'static,
+{
+    pub fn new<T>(
+        chains: Vec<WeightedConnChain<Addr>>,
+        tracer: Option<T>,
+        active_chains: Option<NonZeroUsize>,
+        cancellation: CancellationToken,
+    ) -> Result<Self, ConnSelectorError>
+    where
+        T: TraceRtt<Addr = Addr> + Send + Sync + 'static,
+    {
+        if chains.is_empty() {
+            return Ok(Self::Empty);
+        }
+        Ok(Self::Some(ConnSelector1::new(
+            chains,
+            tracer,
+            active_chains,
+            cancellation,
+        )?))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ConnSelector1<Addr> {
     chains: Arc<[GaugedConnChain<Addr>]>,
     cum_weight: NonZeroUsize,
     score_store: Arc<RwLock<ScoreStore>>,
     active_chains: NonZeroUsize,
 }
-impl<Addr> ConnSelector<Addr>
+impl<Addr> ConnSelector1<Addr>
 where
     Addr: std::fmt::Debug + fmt::Display + Clone + Send + Sync + 'static,
 {
diff --git a/common/src/route/route_table.rs b/common/src/route/route_table.rs
@@ -11,11 +11,12 @@ use crate::{
     addr::InternetAddr,
     config::SharableConfig,
     filter::{Matcher, MatcherBuilder},
+    route::ConnSelector,
 };
 
 use super::{
-    BuildTracer, ConnConfigBuildError, ConnSelector, ConnSelectorBuildContext,
-    ConnSelectorBuildError, ConnSelectorBuilder, IntoAddr, TraceRtt,
+    BuildTracer, ConnConfigBuildError, ConnSelectorBuildContext, ConnSelectorBuildError,
+    ConnSelectorBuilder, IntoAddr, TraceRtt,
 };
 
 #[derive(Debug)]
diff --git a/protocol/src/socks5/server/tcp.rs b/protocol/src/socks5/server/tcp.rs
@@ -518,17 +518,26 @@ impl Socks5ServerTcpAccessConnHandler {
         destination: InternetAddr,
     ) -> Result<(ConnAndAddr, Option<tokio_chacha20::config::Config>), EstablishProxyChainError>
     {
-        let proxy_chain = conn_selector.choose_chain();
+        let (chain, payload_crypto) = match &conn_selector {
+            common::route::ConnSelector::Empty => ([].into(), None),
+            common::route::ConnSelector::Some(conn_selector1) => {
+                let proxy_chain = conn_selector1.choose_chain();
+                (
+                    proxy_chain.chain.clone(),
+                    proxy_chain.payload_crypto.clone(),
+                )
+            }
+        };
         let res = client::stream::establish(
-            &proxy_chain.chain,
+            &chain,
             StreamAddr {
                 address: destination,
                 stream_type: ConcreteStreamType::Tcp.to_string().into(),
             },
             &self.stream_context,
         )
         .await?;
-        Ok((res, proxy_chain.payload_crypto.clone()))
+        Ok((res, payload_crypto))
     }
 }
 #[derive(Debug, Error)]
diff --git a/protocol/src/socks5/server/udp.rs b/protocol/src/socks5/server/udp.rs
@@ -118,10 +118,19 @@ impl Socks5ServerUdpAccessConnHandler {
 
     async fn proxy(&self, conn: Conn<UdpSocket, Flow, Packet>) -> Result<(), AccessProxyError> {
         // Connect to upstream
-        let proxy_chain = self.conn_selector.choose_chain();
+        let (chain, payload_crypto) = match &self.conn_selector {
+            common::route::ConnSelector::Empty => ([].into(), None),
+            common::route::ConnSelector::Some(conn_selector1) => {
+                let proxy_chain = conn_selector1.choose_chain();
+                (
+                    proxy_chain.chain.clone(),
+                    proxy_chain.payload_crypto.clone(),
+                )
+            }
+        };
         let flow = conn.conn_key().clone();
         let upstream = UdpProxyClient::establish(
-            proxy_chain.chain.clone(),
+            chain,
             flow.upstream.as_ref().unwrap().0.clone(),
             &self.udp_context,
         )
@@ -146,7 +155,6 @@ impl Socks5ServerUdpAccessConnHandler {
         };
 
         let speed_limiter = self.speed_limiter.clone();
-        let payload_crypto = proxy_chain.payload_crypto.clone();
         let session_table = self.udp_context.session_table.clone();
         let upstream_local = upstream_read.inner().local_addr().ok();
         let (dn_read, dn_write) = conn.split();
diff --git a/protocol/src/stream/streams/http_tunnel/mod.rs b/protocol/src/stream/streams/http_tunnel/mod.rs
@@ -215,8 +215,17 @@ impl HttpAccessConnHandler {
         };
 
         // Establish proxy chain
-        let proxy_chain = conn_selector.choose_chain();
-        let upstream = establish(&proxy_chain.chain, addr.clone(), &self.stream_context).await?;
+        let (chain, payload_crypto) = match conn_selector.as_ref() {
+            common::route::ConnSelector::Empty => ([].into(), None),
+            common::route::ConnSelector::Some(conn_selector1) => {
+                let proxy_chain = conn_selector1.choose_chain();
+                (
+                    proxy_chain.chain.clone(),
+                    proxy_chain.payload_crypto.clone(),
+                )
+            }
+        };
+        let upstream = establish(&chain, addr.clone(), &self.stream_context).await?;
 
         let session_guard = self.stream_context.session_table.as_ref().map(|s| {
             s.set_scope_owned(Session {
@@ -231,7 +240,7 @@ impl HttpAccessConnHandler {
                 dn_gauge: None,
             })
         });
-        let res = match &proxy_chain.payload_crypto {
+        let res = match &payload_crypto {
             Some(crypto) => {
                 // Establish encrypted stream
                 let (r, w) = tokio::io::split(upstream.stream);
@@ -502,13 +511,17 @@ impl HttpConnect {
             address: address.clone(),
             stream_type: ConcreteStreamType::Tcp.to_string().into(),
         };
-        let proxy_chain = self.conn_selector.choose_chain();
-        let upstream = establish(
-            &proxy_chain.chain,
-            destination.clone(),
-            &self.stream_context,
-        )
-        .await?;
+        let (chain, payload_crypto) = match &self.conn_selector.as_ref() {
+            common::route::ConnSelector::Empty => ([].into(), None),
+            common::route::ConnSelector::Some(conn_selector1) => {
+                let proxy_chain = conn_selector1.choose_chain();
+                (
+                    proxy_chain.chain.clone(),
+                    proxy_chain.payload_crypto.clone(),
+                )
+            }
+        };
+        let upstream = establish(&chain, destination.clone(), &self.stream_context).await?;
 
         let conn_context = ConnContext {
             start: (std::time::Instant::now(), std::time::SystemTime::now()),
@@ -523,7 +536,7 @@ impl HttpConnect {
         let io_copy = CopyBidirectional {
             downstream: TokioIo::new(upgraded),
             upstream: upstream.stream,
-            payload_crypto: proxy_chain.payload_crypto.clone(),
+            payload_crypto,
             speed_limiter: self.speed_limiter.clone(),
             conn_context,
         }
diff --git a/protocol/src/stream/streams/tcp/access_server.rs b/protocol/src/stream/streams/tcp/access_server.rs
@@ -125,13 +125,17 @@ impl TcpAccessConnHandler {
     where
         Downstream: OwnIoStream + HasIoAddr,
     {
-        let proxy_chain = self.conn_selector.choose_chain();
-        let upstream = establish(
-            &proxy_chain.chain,
-            self.destination.clone(),
-            &self.stream_context,
-        )
-        .await?;
+        let (chain, payload_crypto) = match &self.conn_selector {
+            common::route::ConnSelector::Empty => ([].into(), None),
+            common::route::ConnSelector::Some(conn_selector1) => {
+                let proxy_chain = conn_selector1.choose_chain();
+                (
+                    proxy_chain.chain.clone(),
+                    proxy_chain.payload_crypto.clone(),
+                )
+            }
+        };
+        let upstream = establish(&chain, self.destination.clone(), &self.stream_context).await?;
 
         let conn_context = ConnContext {
             start: (std::time::Instant::now(), std::time::SystemTime::now()),
@@ -146,7 +150,7 @@ impl TcpAccessConnHandler {
         let io_copy = CopyBidirectional {
             downstream,
             upstream: upstream.stream,
-            payload_crypto: proxy_chain.payload_crypto.clone(),
+            payload_crypto,
             speed_limiter: self.speed_limiter.clone(),
             conn_context,
         }
diff --git a/protocol/src/udp/access_server.rs b/protocol/src/udp/access_server.rs
@@ -128,19 +128,23 @@ impl UdpAccessConnHandler {
 
     async fn proxy(&self, conn: Conn<UdpSocket, Flow, Packet>) -> Result<(), AccessProxyError> {
         // Connect to upstream
-        let proxy_chain = self.conn_selector.choose_chain();
-        let upstream = UdpProxyClient::establish(
-            proxy_chain.chain.clone(),
-            self.destination.clone(),
-            &self.udp_context,
-        )
-        .await?;
+        let (chain, payload_crypto) = match &self.conn_selector {
+            common::route::ConnSelector::Empty => ([].into(), None),
+            common::route::ConnSelector::Some(conn_selector1) => {
+                let proxy_chain = conn_selector1.choose_chain();
+                (
+                    proxy_chain.chain.clone(),
+                    proxy_chain.payload_crypto.clone(),
+                )
+            }
+        };
+        let upstream =
+            UdpProxyClient::establish(chain, self.destination.clone(), &self.udp_context).await?;
         let upstream_remote = upstream.remote_addr().clone();
 
         let (upstream_read, upstream_write) = upstream.into_split();
 
         let speed_limiter = self.speed_limiter.clone();
-        let payload_crypto = proxy_chain.payload_crypto.clone();
         let session_table = self.udp_context.session_table.clone();
         let upstream_local = upstream_read.inner().local_addr().ok();
         let flow = conn.conn_key().clone();
diff --git a/server/config.toml b/server/config.toml
@@ -34,7 +34,7 @@ pool = ["tcp1", "mptcp1"]
     { matcher = "localhost", action = "direct" }, # Forward local traffic directly
                                                   # <- At this point, no more local traffic
     # { matcher = { }, action = "block" }, # Block all
-    { matcher = { }, action = "default" }, # Forward remaining traffic to the "default" proxy group above
+    { matcher = { }, action = "default" }, # Forward remaining traffic to the "default" conn_selector above
 ]
 
 [access_server.udp.conn_selector]

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ pool = ["tcp1", "mptcp1"]`
`34`	`34`	`{ matcher = "localhost", action = "direct" }, # Forward local traffic directly`
`35`	`35`	`# <- At this point, no more local traffic`
`36`	`36`	`# { matcher = { }, action = "block" }, # Block all`
`37`		`- { matcher = { }, action = "default" }, # Forward remaining traffic to the "default" proxy group above`
	`37`	`+ { matcher = { }, action = "default" }, # Forward remaining traffic to the "default" conn_selector above`
`38`	`38`	`]`
`39`	`39`
`40`	`40`	`[access_server.udp.conn_selector]`