🐛 Fix domain-rules -c none not work

Author: mokeyish

src/config/parser/domain_rule.rs

@@ -92,6 +92,17 @@ mod tests {
             ))
         );
 
+        assert_eq!(
+            DomainRule::parse("-c none"),
+            Ok((
+                "",
+                DomainRule {
+                    speed_check_mode: Some(vec![SpeedCheckMode::None].into()),
+                    ..Default::default()
+                }
+            ))
+        );
+
         assert_eq!(
             DomainRule::parse("-a -"),
             Ok((

src/config/parser/speed_mode.rs

@@ -22,6 +22,7 @@ impl NomParser for SpeedCheckMode {
     fn parse(input: &str) -> IResult<&str, Self> {
         use SpeedCheckMode::*;
 
+        let none = value(None, tag_no_case("none"));
         let ping = value(Ping, tag_no_case("ping"));
         let tcp = map(preceded(tag_no_case("tcp"), preceded(char(':'), u16)), Tcp);
         let http = map(
@@ -39,7 +40,7 @@ impl NomParser for SpeedCheckMode {
             Https,
         );
 
-        alt((ping, tcp, https, http))(input)
+        alt((none, ping, tcp, https, http))(input)
     }
 }
 

src/config/speed_mode.rs

@@ -4,40 +4,52 @@ use crate::infra::ping::PingAddr;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub enum SpeedCheckMode {
+    None,
     Ping,
     Tcp(u16),
     Http(u16),
     Https(u16),
 }
 
 impl SpeedCheckMode {
-    pub fn to_ping_addr(self, ip_addr: IpAddr) -> PingAddr {
-        match self {
-            SpeedCheckMode::Ping => PingAddr::Icmp(ip_addr),
-            SpeedCheckMode::Tcp(port) => PingAddr::Tcp(SocketAddr::new(ip_addr, port)),
-            SpeedCheckMode::Http(port) => PingAddr::Http(SocketAddr::new(ip_addr, port)),
-            SpeedCheckMode::Https(port) => PingAddr::Https(SocketAddr::new(ip_addr, port)),
-        }
+    pub fn is_none(&self) -> bool {
+        matches!(self, SpeedCheckMode::None)
+    }
+
+    pub fn to_ping_addr(self, ip_addr: IpAddr) -> Option<PingAddr> {
+        use SpeedCheckMode::*;
+        Some(match self {
+            None => return Default::default(),
+            Ping => PingAddr::Icmp(ip_addr),
+            Tcp(port) => PingAddr::Tcp(SocketAddr::new(ip_addr, port)),
+            Http(port) => PingAddr::Http(SocketAddr::new(ip_addr, port)),
+            Https(port) => PingAddr::Https(SocketAddr::new(ip_addr, port)),
+        })
     }
 
     pub fn to_ping_addrs(self, ip_addrs: &[IpAddr]) -> Vec<PingAddr> {
-        ip_addrs.iter().map(|ip| self.to_ping_addr(*ip)).collect()
+        ip_addrs
+            .iter()
+            .flat_map(|ip| self.to_ping_addr(*ip))
+            .collect()
     }
 }
 
 impl std::fmt::Debug for SpeedCheckMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use SpeedCheckMode::*;
         match self {
-            SpeedCheckMode::Ping => write!(f, "ICMP"),
-            SpeedCheckMode::Tcp(port) => write!(f, "TCP:{port}"),
-            SpeedCheckMode::Http(port) => {
+            None => write!(f, "None"),
+            Ping => write!(f, "ICMP"),
+            Tcp(port) => write!(f, "TCP:{port}"),
+            Http(port) => {
                 if *port == 80 {
                     write!(f, "HTTP")
                 } else {
                     write!(f, "HTTP:{port}")
                 }
             }
-            SpeedCheckMode::Https(port) => {
+            Https(port) => {
                 if *port == 443 {
                     write!(f, "HTTPS")
                 } else {

src/dns_mw_ns.rs

@@ -197,19 +197,24 @@ async fn lookup_ip(
         return Err(ProtoErrorKind::NoConnections.into());
     }
 
-    // ignore
-    let response_strategy = if options.no_speed_check || options.speed_check_mode.is_none() {
+    // ignore speed check
+    let mut response_strategy = if options.no_speed_check || options.speed_check_mode.is_none() {
         FastestResponse
     } else {
         options.response_strategy
     };
 
-    let speed_check_mode = options
+    let mut speed_check_mode = options
         .speed_check_mode
         .as_ref()
         .map(|m| m.as_slice())
         .unwrap_or_default();
 
+    if speed_check_mode.iter().any(|m| m.is_none()) {
+        response_strategy = FastestResponse; // ignore speed check
+        speed_check_mode = &[];
+    }
+
     let mut ok_tasks = vec![];
     let mut err_tasks = vec![];
 
@@ -501,7 +506,10 @@ async fn multi_mode_ping(
     let ping_ops = PingOptions::default().with_timeout_secs(2);
 
     for mode in &modes {
-        let dest = mode.to_ping_addr(ip_addr);
+        let dest = match mode.to_ping_addr(ip_addr) {
+            Some(addr) => addr,
+            None => return Err(PingError::NoAddress),
+        };
 
         let ping_task = ping(dest, ping_ops).boxed();
         let timeout_task = sleep(duration).boxed();