Refactor/mark

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/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

@@ -33,11 +33,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 {

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/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

clash_lib/src/proxy/direct/mod.rs

@@ -53,7 +53,6 @@ impl OutboundHandler for Handler {
             sess.destination.host().as_str(),
             sess.destination.port(),
             None,
-            #[cfg(any(target_os = "linux", target_os = "android"))]
             None,
         )
         .await?;
@@ -66,25 +65,20 @@ impl OutboundHandler for Handler {
     async fn proxy_stream(
         &self,
         s: AnyStream,
-        #[allow(unused_variables)] sess: &Session,
-        #[allow(unused_variables)] _resolver: ThreadSafeDNSResolver,
+        _sess: &Session,
+        _resolver: ThreadSafeDNSResolver,
     ) -> std::io::Result<AnyStream> {
         Ok(s)
     }
 
     async fn connect_datagram(
         &self,
-        sess: &Session,
+        _sess: &Session,
         resolver: ThreadSafeDNSResolver,
     ) -> std::io::Result<BoxedChainedDatagram> {
-        let d = new_udp_socket(
-            None,
-            sess.iface.as_ref(),
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            None,
-        )
-        .await
-        .map(|x| OutboundDatagramImpl::new(x, resolver))?;
+        let d = new_udp_socket(None, None, None)
+            .await
+            .map(|x| OutboundDatagramImpl::new(x, resolver))?;
 
         let d = ChainedDatagramWrapper::new(d);
         d.append_to_chain(self.name()).await;

clash_lib/src/proxy/http/inbound/connector.rs

@@ -51,7 +51,6 @@ impl tower::Service<Uri> for Connector {
                 typ: Type::Http,
                 source: src,
                 destination: destination.ok_or(ProxyError::InvalidUrl(url.to_string()))?,
-                ..Default::default()
             };
 
             tokio::spawn(async move {

clash_lib/src/proxy/http/inbound/proxy.rs

@@ -65,8 +65,6 @@ async fn proxy(
                             typ: Type::HttpConnect,
                             source: src,
                             destination: addr,
-
-                            ..Default::default()
                         };
 
                         dispatcher.dispatch_stream(sess, upgraded).await

clash_lib/src/proxy/mod.rs

@@ -85,10 +85,12 @@ impl<T, U> OutboundDatagram<U> for T where
 pub type AnyOutboundDatagram =
     Box<dyn OutboundDatagram<UdpPacket, Item = UdpPacket, Error = io::Error>>;
 
-#[derive(Default, Debug, Clone)]
+#[allow(dead_code)]
+#[derive(Default, Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct CommonOption {
-    #[allow(dead_code)]
+    #[serde(rename = "routing-mark")]
     so_mark: Option<u32>,
+    #[serde(rename = "interface-name")]
     iface: Option<Interface>,
 }
 

clash_lib/src/proxy/relay/mod.rs

@@ -92,7 +92,6 @@ impl OutboundHandler for Handler {
                     remote_addr.host().as_str(),
                     remote_addr.port(),
                     None,
-                    #[cfg(any(target_os = "linux", target_os = "android"))]
                     None,
                 )
                 .await?;

clash_lib/src/proxy/shadowsocks/mod.rs

@@ -218,8 +218,7 @@ impl OutboundHandler for Handler {
             self.opts.server.as_str(),
             self.opts.port,
             self.opts.common_opts.iface.as_ref(),
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            None,
+            self.opts.common_opts.so_mark,
         )
         .map_err(|x| {
             io::Error::new(
@@ -311,8 +310,7 @@ impl OutboundHandler for Handler {
         let socket = new_udp_socket(
             None,
             self.opts.common_opts.iface.as_ref(),
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            None,
+            self.opts.common_opts.so_mark,
         )
         .await?;
         let socket = ProxySocket::from_socket(UdpSocketType::Client, ctx, &cfg, socket);

clash_lib/src/proxy/socks/inbound/stream.rs

@@ -138,13 +138,7 @@ pub async fn handle_tcp<'a>(
         }
         socks_command::UDP_ASSOCIATE => {
             let udp_addr = SocketAddr::new(s.local_addr()?.ip(), 0);
-            let udp_inbound = new_udp_socket(
-                Some(&udp_addr),
-                None,
-                #[cfg(any(target_os = "linux", target_os = "android"))]
-                None,
-            )
-            .await?;
+            let udp_inbound = new_udp_socket(Some(&udp_addr), None, None).await?;
 
             trace!(
                 "Got a UDP_ASSOCIATE request from {}, UDP assigned at {}",
@@ -166,8 +160,6 @@ pub async fn handle_tcp<'a>(
             let sess = Session {
                 network: Network::Udp,
                 typ: Type::Socks5,
-                packet_mark: None,
-                iface: None,
                 ..Default::default()
             };
 

clash_lib/src/proxy/trojan/mod.rs

@@ -156,8 +156,7 @@ impl OutboundHandler for Handler {
             self.opts.server.as_str(),
             self.opts.port,
             self.opts.common_opts.iface.as_ref(),
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            None,
+            self.opts.common_opts.so_mark,
         )
         .map_err(|x| {
             io::Error::new(
@@ -196,8 +195,7 @@ impl OutboundHandler for Handler {
             self.opts.server.as_str(),
             self.opts.port,
             self.opts.common_opts.iface.as_ref(),
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            None,
+            self.opts.common_opts.so_mark,
         )
         .map_err(|x| {
             io::Error::new(

clash_lib/src/proxy/tun/inbound.rs

@@ -26,7 +26,6 @@ async fn handle_inbound_stream(
         typ: Type::Tun,
         source: local_addr,
         destination: remote_addr.into(),
-        ..Default::default()
     };
 
     dispatcher.dispatch_stream(sess, stream).await;

clash_lib/src/proxy/utils/socket_helpers.rs

@@ -67,12 +67,12 @@ fn must_bind_socket_on_interface(socket: &socket2::Socket, iface: &Interface) ->
     }
 }
 
-pub async fn new_tcp_stream<'a>(
+pub async fn new_tcp_stream(
     resolver: ThreadSafeDNSResolver,
-    address: &'a str,
+    address: &str,
     port: u16,
-    iface: Option<&'a Interface>,
-    #[cfg(any(target_os = "linux", target_os = "android"))] packet_mark: Option<u32>,
+    iface: Option<&Interface>,
+    #[allow(unused_variables)] packet_mark: Option<u32>,
 ) -> io::Result<AnyStream> {
     let dial_addr = resolver
         .resolve(address, false)
@@ -99,12 +99,13 @@ pub async fn new_tcp_stream<'a>(
         }
     };
 
-    if let Some(iface) = iface {
+    let global_iface = crate::get_iface();
+    if let Some(iface) = iface.or(global_iface.as_ref()) {
         must_bind_socket_on_interface(&socket, iface)?;
     }
 
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    if let Some(packet_mark) = packet_mark {
+    #[cfg(target_os = "linux")]
+    if let Some(packet_mark) = packet_mark.or_else(crate::get_somark) {
         socket.set_mark(packet_mark)?;
     }
 
@@ -124,7 +125,7 @@ pub async fn new_tcp_stream<'a>(
 pub async fn new_udp_socket(
     src: Option<&SocketAddr>,
     iface: Option<&Interface>,
-    #[cfg(any(target_os = "linux", target_os = "android"))] packet_mark: Option<u32>,
+    #[allow(unused_variables)] packet_mark: Option<u32>,
 ) -> io::Result<UdpSocket> {
     let socket = match src {
         Some(src) => {
@@ -141,12 +142,13 @@ pub async fn new_udp_socket(
         socket.bind(&(*src).into())?;
     }
 
-    if let Some(iface) = iface {
+    let global_iface = crate::get_iface();
+    if let Some(iface) = iface.or(global_iface.as_ref()) {
         must_bind_socket_on_interface(&socket, iface)?;
     }
 
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    if let Some(packet_mark) = packet_mark {
+    #[cfg(target_os = "linux")]
+    if let Some(packet_mark) = packet_mark.or_else(crate::get_somark) {
         socket.set_mark(packet_mark)?;
     }
 
@@ -155,6 +157,28 @@ pub async fn new_udp_socket(
 
     UdpSocket::from_std(socket.into())
 }
+/// An extension to std::net::{UdpSocket, TcpStream}
+pub trait StdSocketExt {
+    fn set_mark(&self, mark: u32) -> io::Result<()>;
+}
+impl StdSocketExt for std::net::UdpSocket {
+    fn set_mark(&self, mark: u32) -> io::Result<()> {
+        set_mark(socket2::SockRef::from(self), mark)
+    }
+}
+impl StdSocketExt for std::net::TcpStream {
+    fn set_mark(&self, mark: u32) -> io::Result<()> {
+        set_mark(socket2::SockRef::from(self), mark)
+    }
+}
+
+#[allow(unused_variables)]
+fn set_mark(socket: socket2::SockRef<'_>, mark: u32) -> io::Result<()> {
+    #[cfg(target_os = "linux")]
+    return socket.set_mark(mark);
+    #[cfg(not(target_os = "linux"))]
+    return Ok(());
+}
 
 #[cfg(test)]
 mod tests {