feat: tun auto route

clash_lib/Cargo.toml

@@ -121,6 +121,8 @@ console-subscriber = { version = "0.2.0" }
 tracing-timing = { version = "0.6.0" }
 criterion = { version = "0.5", features = ["html_reports", "async_tokio"], optional = true }
 
+cmd_lib = "1"
+
 [dev-dependencies]
 tempfile = "3.10"
 ctor = "0.2"

clash_lib/src/app/dispatcher/dispatcher_impl.rs

@@ -317,7 +317,7 @@ impl Dispatcher {
                                 match remote_w.send(packet).await {
                                     Ok(_) => {}
                                     Err(err) => {
-                                        warn!("failed to send packet to remote: {}", err);
+                                        warn!("failed to send packet to remote: {:?}", err);
                                     }
                                 }
                             }

clash_lib/src/app/dns/dhcp.rs

@@ -177,7 +177,6 @@ async fn listen_dhcp_client(iface: &str) -> io::Result<UdpSocket> {
     new_udp_socket(
         Some(&listen_addr.parse().expect("must parse")),
         Some(&Interface::Name(iface.to_string())),
-        #[cfg(any(target_os = "linux", target_os = "android"))]
         None,
     )
     .await

clash_lib/src/common/http.rs

@@ -50,7 +50,6 @@ impl Service<Uri> for LocalConnector {
                     },
                 }),
                 None,
-                #[cfg(any(target_os = "linux", target_os = "android"))]
                 None,
             )
             .await

clash_lib/src/config/internal/config.rs

@@ -254,6 +254,7 @@ pub struct TunConfig {
     /// default: 198.18.0.0/16
     pub network: Option<String>,
     pub gateway: Option<IpAddr>,
+    pub auto_route: Option<bool>,
 }
 
 #[derive(Clone, Default)]

clash_lib/src/config/internal/proxy.rs

@@ -1,5 +1,6 @@
 use crate::common::utils::default_bool_true;
 use crate::config::utils;
+use crate::proxy::CommonOption;
 use crate::Error;
 use serde::de::value::MapDeserializer;
 use serde::Deserialize;
@@ -116,6 +117,8 @@ impl Display for OutboundProxyProtocol {
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
 pub struct OutboundShadowsocks {
+    #[serde(flatten)]
+    pub common_opts: CommonOption,
     pub name: String,
     pub server: String,
     pub port: u16,
@@ -130,6 +133,8 @@ pub struct OutboundShadowsocks {
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
 pub struct OutboundSocks5 {
+    #[serde(flatten)]
+    pub common_opts: CommonOption,
     pub name: String,
     pub server: String,
     pub port: u16,
@@ -142,6 +147,8 @@ pub struct OutboundSocks5 {
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
 pub struct WsOpt {
+    #[serde(flatten)]
+    pub common_opts: CommonOption,
     pub path: Option<String>,
     pub headers: Option<HashMap<String, String>>,
     pub max_early_data: Option<i32>,
@@ -163,6 +170,8 @@ pub struct GrpcOpt {
 #[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
 #[serde(rename_all = "kebab-case")]
 pub struct OutboundTrojan {
+    #[serde(flatten)]
+    pub common_opts: CommonOption,
     pub name: String,
     pub server: String,
     pub port: u16,
@@ -179,6 +188,8 @@ pub struct OutboundTrojan {
 #[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
 #[serde(rename_all = "kebab-case")]
 pub struct OutboundVmess {
+    #[serde(flatten)]
+    pub common_opts: CommonOption,
     pub name: String,
     pub server: String,
     pub port: u16,
@@ -200,6 +211,8 @@ pub struct OutboundVmess {
 #[derive(serde::Serialize, serde::Deserialize, Debug, Default, Clone)]
 #[serde(rename_all = "kebab-case")]
 pub struct OutboundWireguard {
+    #[serde(flatten)]
+    pub common_opts: CommonOption,
     pub name: String,
     pub server: String,
     pub port: u16,

clash_lib/src/lib.rs

@@ -16,11 +16,12 @@ use common::auth;
 use common::http::new_http_client;
 use common::mmdb;
 use config::def::LogLevel;
+use once_cell::sync::OnceCell;
 use proxy::tun::get_tun_runner;
 
 use std::io;
 use std::path::PathBuf;
-use std::sync::{Arc, OnceLock};
+use std::sync::Arc;
 use thiserror::Error;
 use tokio::sync::{broadcast, mpsc, oneshot, Mutex};
 use tokio::task::JoinHandle;
@@ -33,11 +34,11 @@ mod common;
 mod config;
 mod proxy;
 mod session;
-
 pub use config::def::Config as ClashConfigDef;
 pub use config::def::DNS as ClashDNSConfigDef;
 pub use config::DNSListen as ClashDNSListen;
 pub use config::RuntimeConfig as ClashRuntimeConfig;
+pub use session::{get_iface, get_somark, set_iface, set_somark};
 
 #[derive(Error, Debug)]
 pub enum Error {
@@ -102,9 +103,10 @@ pub struct GlobalState {
 
 pub struct RuntimeController {
     shutdown_tx: mpsc::Sender<()>,
+    broadcast_shutdown: broadcast::Sender<()>,
 }
 
-static RUNTIME_CONTROLLER: OnceLock<std::sync::RwLock<RuntimeController>> = OnceLock::new();
+static RUNTIME_CONTROLLER: OnceCell<RuntimeController> = OnceCell::new();
 
 pub fn start(opts: Options) -> Result<(), Error> {
     let rt = match opts.rt.as_ref().unwrap_or(&TokioRuntime::MultiThread) {
@@ -127,17 +129,35 @@ pub fn start(opts: Options) -> Result<(), Error> {
     })
 }
 
-pub fn shutdown() -> bool {
-    match RUNTIME_CONTROLLER.get().unwrap().write() {
-        Ok(rt) => rt.shutdown_tx.blocking_send(()).is_ok(),
-        _ => false,
+pub fn shutdown() -> anyhow::Result<()> {
+    match RUNTIME_CONTROLLER.get() {
+        Some(rt) => {
+            _ = rt.broadcast_shutdown.send(()); // fail when there is no receiver
+            rt.shutdown_tx.blocking_send(())?;
+            Ok(())
+        }
+        _ => Err(anyhow::anyhow!("Empty RUNTIME_CONTROLLER")),
+    }
+}
+
+pub async fn listen_shutdown() -> anyhow::Result<()> {
+    match RUNTIME_CONTROLLER.get() {
+        Some(rt) => {
+            _ = rt.broadcast_shutdown.subscribe().recv().await; // fail when there is no sender or buffer is full
+            Ok(())
+        }
+        _ => Err(anyhow::anyhow!("Empty RUNTIME_CONTROLLER")),
     }
 }
 
 async fn start_async(opts: Options) -> Result<(), Error> {
     let (shutdown_tx, mut shutdown_rx) = mpsc::channel(1);
+    let (broadcast_shutdown, _) = broadcast::channel(1);
 
-    let _ = RUNTIME_CONTROLLER.set(std::sync::RwLock::new(RuntimeController { shutdown_tx }));
+    let _ = RUNTIME_CONTROLLER.set(RuntimeController {
+        shutdown_tx,
+        broadcast_shutdown,
+    });
 
     let config: InternalConfig = opts.config.try_parse()?;
 

clash_lib/src/proxy/converters/shadowsocks.rs

@@ -2,7 +2,7 @@ use crate::{
     config::internal::proxy::OutboundShadowsocks,
     proxy::{
         shadowsocks::{Handler, HandlerOptions, OBFSOption},
-        AnyOutboundHandler, CommonOption,
+        AnyOutboundHandler,
     },
     Error,
 };
@@ -21,7 +21,7 @@ impl TryFrom<&OutboundShadowsocks> for AnyOutboundHandler {
     fn try_from(s: &OutboundShadowsocks) -> Result<Self, Self::Error> {
         let h = Handler::new(HandlerOptions {
             name: s.name.to_owned(),
-            common_opts: CommonOption::default(),
+            common_opts: s.common_opts.clone(),
             server: s.server.to_owned(),
             port: s.port,
             password: s.password.to_owned(),

clash_lib/src/proxy/converters/trojan.rs

@@ -5,7 +5,7 @@ use crate::{
     proxy::{
         options::{GrpcOption, WsOption},
         trojan::{Handler, Opts, Transport},
-        AnyOutboundHandler, CommonOption,
+        AnyOutboundHandler,
     },
     Error,
 };
@@ -29,7 +29,7 @@ impl TryFrom<&OutboundTrojan> for AnyOutboundHandler {
 
         let h = Handler::new(Opts {
             name: s.name.to_owned(),
-            common_opts: CommonOption::default(),
+            common_opts: s.common_opts.clone(),
             server: s.server.to_owned(),
             port: s.port,
             password: s.password.clone(),

clash_lib/src/proxy/converters/tuic.rs

@@ -1,4 +1,7 @@
-use std::time::Duration;
+use std::{
+    sync::{atomic::AtomicU32, Arc},
+    time::Duration,
+};
 
 use quinn::VarInt;
 
@@ -28,16 +31,22 @@
             port: s.port,
             uuid: s.uuid.to_owned(),
             password: s.password.to_owned(),
-            udp_relay_mode: s.udp_relay_mode.to_owned().unwrap_or("native".to_string()),
+            udp_relay_mode: s
+                .udp_relay_mode
+                .to_owned()
+                .unwrap_or("native".to_string())
+                .as_str()
+                .into(),
             disable_sni: s.disable_sni.unwrap_or(false),
             alpn: s
                 .alpn
                 .clone()
                 .map(|v| v.into_iter().map(|alpn| alpn.into_bytes()).collect())
                 .unwrap_or_default(),
             heartbeat_interval: Duration::from_millis(s.heartbeat_interval.unwrap_or(3000)),
             reduce_rtt: s.reduce_rtt.unwrap_or(false) || s.fast_open.unwrap_or(false),
-            request_timeout: Duration::from_millis(s.request_timeout.unwrap_or(8000)),
+            request_timeout: Duration::from_millis(s.request_timeout.unwrap_or(4000)),
+            idle_timeout: VarInt::from_u64(s.request_timeout.unwrap_or(4000)).unwrap_or(VarInt::MAX),
             congestion_controller: s
                 .congestion_controller
                 .clone()
@@ -54,6 +63,7 @@
             send_window: s.send_window.unwrap_or(8 * 1024 * 1024 * 2),
             receive_window: VarInt::from_u64(s.receive_window.unwrap_or(8 * 1024 * 1024))
                 .unwrap_or(VarInt::MAX),
+            mark: Arc::new(AtomicU32::new(0)),
         })
     }
 }

clash_lib/src/proxy/converters/vmess.rs

@@ -6,7 +6,7 @@ use crate::{
         options::{GrpcOption, Http2Option, WsOption},
         transport::TLSOptions,
         vmess::{Handler, HandlerOptions, VmessTransport},
-        AnyOutboundHandler, CommonOption,
+        AnyOutboundHandler,
     },
     Error,
 };
@@ -30,7 +30,7 @@ impl TryFrom<&OutboundVmess> for AnyOutboundHandler {
 
         let h = Handler::new(HandlerOptions {
             name: s.name.to_owned(),
-            common_opts: CommonOption::default(),
+            common_opts: s.common_opts.clone(),
             server: s.server.to_owned(),
             port: s.port,
             uuid: s.uuid.clone(),

clash_lib/src/proxy/converters/wireguard.rs

@@ -23,7 +23,7 @@ impl TryFrom<&OutboundWireguard> for AnyOutboundHandler {
     fn try_from(s: &OutboundWireguard) -> Result<Self, Self::Error> {
         let h = Handler::new(HandlerOpts {
             name: s.name.to_owned(),
-            common_opts: Default::default(),
+            common_opts: s.common_opts.clone(),
             server: s.server.to_owned(),
             port: s.port,
             ip: s