feat(tun): windows auto-route

clash/tests/data/config/rules.yaml

@@ -4,8 +4,12 @@ socks-port: 8889
 mixed-port: 8899
 
 tun:
- enable: false
+ enable: true
  device-id: "dev://utun1989"
+ route-all: false
+ routes:
+ - 0.0.0.0/1
+ - 128.0.0.0/1
 
 ipv6: true
 
@@ -42,7 +46,7 @@ dns:
  nameserver:
  # - 114.114.114.114 # default value
  # - 1.1.1.1#auto # default value
- - tls://1.1.1.1:853#en0 # DNS over TLS
+ - tls://1.1.1.1:853#auto # DNS over TLS
 # - dhcp://en0 # dns from dhcp
 
 allow-lan: true

clash_lib/Cargo.toml

@@ -143,4 +143,5 @@ security-framework = "2.11.1"
 windows = { version = "0.58", features = [
  "Win32_Networking_WinSock",
  "Win32_Foundation",
+ "Win32_NetworkManagement_Rras",
 ]}

clash_lib/src/app/logging.rs

@@ -26,6 +26,7 @@ impl From<LogLevel> for filter::LevelFilter {
  LogLevel::Warning => filter::LevelFilter::WARN,
  LogLevel::Info => filter::LevelFilter::INFO,
  LogLevel::Debug => filter::LevelFilter::DEBUG,
+ LogLevel::Trace => filter::LevelFilter::TRACE,
  LogLevel::Silent => filter::LevelFilter::OFF,
  }
  }
@@ -65,7 +66,7 @@ where
  tracing::Level::WARN => LogLevel::Warning,
  tracing::Level::INFO => LogLevel::Info,
  tracing::Level::DEBUG => LogLevel::Debug,
- tracing::Level::TRACE => LogLevel::Debug,
+ tracing::Level::TRACE => LogLevel::Trace,
  },
  msg: strs.join(" "),
  };

clash_lib/src/common/defer.rs

@@ -0,0 +1,25 @@
+// https://stackoverflow.com/a/29963675/1109167
+pub struct ScopeCall<F: FnOnce()> {
+ pub c: Option<F>,
+}
+impl<F: FnOnce()> Drop for ScopeCall<F> {
+ fn drop(&mut self) {
+ self.c.take().unwrap()()
+ }
+}
+
+#[macro_export]
+macro_rules! expr {
+ ($e:expr) => {
+ $e
+ };
+} // tt hack
+
+#[macro_export]
+macro_rules! defer {
+ ($($data: tt)*) => (
+ let _scope_call = $crate::common::defer::ScopeCall {
+ c: Some(|| -> () { $crate::expr!({ $($data)* }) })
+ };
+ )
+}

clash_lib/src/common/mod.rs

@@ -1,5 +1,6 @@
 pub mod auth;
 pub mod crypto;
+pub mod defer;
 pub mod errors;
 pub mod geodata;
 pub mod http;

clash_lib/src/config/def.rs

@@ -4,6 +4,22 @@ use std::{collections::HashMap, fmt::Display, path::PathBuf, str::FromStr};
 use serde::{Deserialize, Serialize};
 use serde_yaml::Value;
 
+fn default_tun_address() -> String {
+ "198.18.0.1/32".to_string()
+}
+
+#[derive(Serialize, Deserialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub struct TunConfig {
+ pub enable: bool,
+ pub device_id: String,
+ /// tun interface address
+ #[serde(default = "default_tun_address")]
+ pub gateway: String,
+ pub routes: Option<Vec<String>>,
+ pub route_all: bool,
+}
+
 #[derive(Serialize, Deserialize, Default, Copy, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum RunMode {
@@ -29,6 +45,7 @@ impl Display for RunMode {
 #[derive(PartialEq, Serialize, Deserialize, Default, Copy, Clone, Debug)]
 #[serde(rename_all = "lowercase")]
 pub enum LogLevel {
+ Trace,
  Debug,
  #[default]
  Info,
@@ -41,6 +58,7 @@ pub enum LogLevel {
 impl Display for LogLevel {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  match self {
+ LogLevel::Trace => write!(f, "trace"),
  LogLevel::Debug => write!(f, "debug"),
  LogLevel::Info => write!(f, "info"),
  LogLevel::Warning => write!(f, "warn"),
@@ -313,7 +331,7 @@ pub struct Config {
  /// enable: true
  /// device-id: "dev://utun1989"
  /// ```
- pub tun: Option<HashMap<String, Value>>,
+ pub tun: Option<TunConfig>,
 }
 
 impl TryFrom<PathBuf> for Config {

clash_lib/src/config/internal/config.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use std::{fmt::Display, net::IpAddr, str::FromStr};
 
+use ipnet::IpNet;
 use serde::{de::value::MapDeserializer, Deserialize, Serialize};
 use serde_yaml::Value;
 
@@ -97,15 +98,26 @@ impl TryFrom<def::Config> for Config {
  dns: (&c).try_into()?,
  experimental: c.experimental,
  tun: match c.tun {
- Some(mapping) => {
- TunConfig::deserialize(MapDeserializer::new(mapping.into_iter()))
- .map_err(|e| {
- Error::InvalidConfig(format!(
- "invalid tun config: {}",
- e
- ))
+ Some(t) => TunConfig {
+ enable: t.enable,
+ device_id: t.device_id,
+ route_all: t.route_all,
+ routes: t
+ .routes
+ .map(|r| {
+ r.into_iter()
+ .map(|x| x.parse())
+ .collect::<Result<Vec<_>, _>>()
+ })
+ .transpose()
+ .map_err(|x| {
+ Error::InvalidConfig(format!("parse tun routes: {}", x))
  })?
- }
+ .unwrap_or_default(),
+ gateway: t.gateway.parse().map_err(|x| {
+ Error::InvalidConfig(format!("parse tun gateway: {}", x))
+ })?,
+ },
  None => TunConfig::default(),
  },
  profile: Profile {
@@ -279,19 +291,13 @@ pub struct Profile {
  // store_fake_ip: bool,
 }
 
-#[derive(Deserialize, Default)]
-#[serde(rename_all = "kebab-case")]
+#[derive(Default)]
 pub struct TunConfig {
  pub enable: bool,
- /// tun device id, could be
- /// dev://utun886 # Linux
- /// fd://3 # file descriptor
- #[serde(alias = "device-url")]
  pub device_id: String,
- /// tun device address
- /// default: 198.18.0.0/16
- pub network: Option<String>,
- pub gateway: Option<IpAddr>,
+ pub route_all: bool,
+ pub routes: Vec<IpNet>,
+ pub gateway: IpNet,
 }
 
 #[derive(Clone, Default)]

clash_lib/src/proxy/tun/inbound.rs

@@ -1,7 +1,12 @@
 use super::{datagram::TunDatagram, netstack};
-use std::{net::SocketAddr, sync::Arc};
+use std::{
+ net::{Ipv4Addr, SocketAddr},
+ sync::Arc,
+};
 
 use futures::{SinkExt, StreamExt};
+use ipnet::IpNet;
+use network_interface::NetworkInterfaceConfig;
 use tracing::{debug, error, info, trace, warn};
 use tun::{Device, TunPacket};
 use url::Url;
@@ -10,7 +15,11 @@
  app::{dispatcher::Dispatcher, dns::ThreadSafeDNSResolver},
  common::errors::{map_io_error, new_io_error},
  config::internal::config::TunConfig,
- proxy::{datagram::UdpPacket, utils::get_outbound_interface},
+ proxy::{
+ datagram::UdpPacket,
+ tun::routes::add_route,
+ utils::{get_outbound_interface, OutboundInterface},
+ },
  session::{Network, Session, SocksAddr, Type},
  Error, Runner,
 };
@@ -177,14 +186,56 @@
  }
  }
 
- tun_cfg.up();
+ let gw = cfg.gateway;
+ tun_cfg.address(gw.addr()).netmask(gw.netmask()).up();
 
  let tun = tun::create_as_async(&tun_cfg)
  .map_err(|x| new_io_error(format!("failed to create tun device: {}", x)))?;
 
  let tun_name = tun.get_ref().name().map_err(map_io_error)?;
  info!("tun started at {}", tun_name);
 
+ #[cfg(target_os = "windows")]
+ if cfg.route_all || !cfg.routes.is_empty() {
+ let tun_iface = network_interface::NetworkInterface::show()
+ .map_err(map_io_error)?
+ .into_iter()
+ .find(|iface| iface.name == tun_name)
+ .map(|x| OutboundInterface {
+ name: x.name,
+ addr_v4: x.addr.iter().find_map(|addr| match addr {
+ network_interface::Addr::V4(addr) => Some(addr.ip),
+ _ => None,
+ }),
+ addr_v6: x.addr.iter().find_map(|addr| match addr {
+ network_interface::Addr::V6(addr) => Some(addr.ip),
+ _ => None,
+ }),
+ index: x.index,
+ })
+ .expect("tun interface not found");
+
+ if cfg.route_all {
+ warn!(
+ "route_all is enabled, all traffic will be routed through the tun \
+ interface"
+ );
+ let default_routes = vec![
+ IpNet::new(std::net::IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 1)
+ .unwrap(),
+ IpNet::new(std::net::IpAddr::V4(Ipv4Addr::new(128, 0, 0, 0)), 1)
+ .unwrap(),
+ ];
+ for r in default_routes {
+ add_route(&tun_iface, &r).map_err(map_io_error)?;
+ }
+ } else {
+ for r in cfg.routes {
+ add_route(&tun_iface, &r).map_err(map_io_error)?;
+ }
+ }
+ }
+
  let (stack, mut tcp_listener, udp_socket) =
  netstack::NetStack::with_buffer_size(512, 256).map_err(map_io_error)?;
 

clash_lib/src/proxy/tun/mod.rs

@@ -2,3 +2,4 @@ pub mod inbound;
 pub use netstack_lwip as netstack;
 mod datagram;
 pub use inbound::get_runner as get_tun_runner;
+mod routes;

clash_lib/src/proxy/tun/routes/mod.rs

@@ -0,0 +1,4 @@
+#[cfg(windows)]
+mod windows;
+#[cfg(windows)]
+pub(crate) use windows::add_route;