Andriod

clash-dns/Cargo.toml

@@ -13,5 +13,6 @@ futures = "0.3"
 async-trait = "0.1"
 
 hickory-server = { version = "0.25", default-features = false }
+hickory-proto = "0.25"
 tokio = { version = "1", features = ["full"] }
 tracing = "0.1"

clash-dns/src/handler.rs

@@ -3,9 +3,11 @@
 use crate::utils::new_io_error;
 use crate::{DNSListenAddr, DnsMessageExchanger};
 use async_trait::async_trait;
+use hickory_proto::op::{Header, Message, ResponseCode};
 use hickory_server::server::Request;
 use hickory_server::{
     ServerFuture,
+    authority::MessageResponseBuilder,
     server::{RequestHandler, ResponseHandler, ResponseInfo},
 };
 use thiserror::Error;
@@ -24,10 +26,10 @@
 pub enum DNSError {
     #[error(transparent)]
     Io(#[from] std::io::Error),
-    /* #[error("invalid OP code: {0}")]
+    #[error("invalid OP query: {0}")]
     InvalidOpQuery(String),
     #[error("query failed: {0}")]
-    QueryFailed(String), */
+    QueryFailed(String),
 }
 
 #[async_trait]
@@ -38,9 +40,44 @@
     async fn handle_request<H: ResponseHandler>(
         &self,
         request: &Request,
-        response_handle: H,
+        mut response_handle: H,
     ) -> ResponseInfo {
-        todo!()
+        let req = match to_dns_message(request) {
+            Ok(req) => req,
+            Err(err) => {
+                error!("failed to parse dns request: {}", err);
+                return servfail_info();
+            }
+        };
+
+        let resp = match self.exchanger.exchange(&req).await {
+            Ok(resp) => resp,
+            Err(err) => {
+                warn!("dns exchange failed: {}", err);
+                build_servfail_message(&req)
+            }
+        };
+
+        let mut builder = MessageResponseBuilder::from_message_request(request);
+        if let Some(edns) = resp.extensions().clone() {
+            builder.edns(edns);
+        }
+
+        let response = builder.build(
+            resp.header().clone(),
+            resp.answers(),
+            resp.name_servers(),
+            std::iter::empty::<&hickory_proto::rr::Record>(),
+            resp.additionals(),
+        );
+
+        match response_handle.send_response(response).await {
+            Ok(info) => info,
+            Err(err) => {
+                error!("failed to send dns response: {}", err);
+                servfail_info()
+            }
+        }
     }
 }
 
@@ -49,7 +86,7 @@
 pub async fn get_dns_listener<X>(
     listen: DNSListenAddr,
     exchanger: X,
     cwd: &std::path::Path,
 ) -> Option<futures::future::BoxFuture<'static, Result<(), DNSError>>>
 where
     X: DnsMessageExchanger + Sync + Send + Unpin + 'static,
@@ -84,15 +121,18 @@
             .is_ok();
     }
     if let Some(c) = listen.doh {
-        todo!()
+        let _ = c;
+        warn!("DoH listener is not implemented yet");
     }
 
     if let Some(c) = listen.dot {
-        todo!()
+        let _ = c;
+        warn!("DoT listener is not implemented yet");
     }
 
     if let Some(c) = listen.doh3 {
-        todo!()
+        let _ = c;
+        warn!("DoH3 listener is not implemented yet");
     }
 
     if !has_server {
@@ -109,3 +149,53 @@
         })
     }))
 }
+
+fn to_dns_message(request: &Request) -> Result<Message, DNSError> {
+    let mut message = Message::new();
+    message.set_id(request.id());
+    message.set_op_code(request.op_code());
+    message.set_message_type(request.message_type());
+    message.set_authoritative(request.authoritative());
+    message.set_truncated(request.truncated());
+    message.set_recursion_desired(request.recursion_desired());
+    message.set_recursion_available(request.recursion_available());
+    message.set_authentic_data(request.authentic_data());
+    message.set_checking_disabled(request.checking_disabled());
+    message.set_response_code(request.response_code());
+    message.add_queries(request.queries().iter().map(|q| q.original().clone()));
+    message.add_answers(request.answers().iter().cloned());
+    message.add_name_servers(request.name_servers().iter().cloned());
+    message.add_additionals(request.additionals().iter().cloned());
+    if let Some(edns) = request.edns().cloned() {
+        message.set_edns(edns);
+    }
+    Ok(message)
+}
+
+fn build_servfail_message(req: &Message) -> Message {
+    let mut header = Header::response_from_request(req.header());
+    header.set_response_code(ResponseCode::ServFail);
+
+    let mut message = Message::new();
+    message.set_id(header.id());
+    message.set_message_type(header.message_type());
+    message.set_op_code(header.op_code());
+    message.set_authoritative(header.authoritative());
+    message.set_truncated(header.truncated());
+    message.set_recursion_desired(header.recursion_desired());
+    message.set_recursion_available(header.recursion_available());
+    message.set_authentic_data(header.authentic_data());
+    message.set_checking_disabled(header.checking_disabled());
+    message.set_response_code(header.response_code());
+    message.add_queries(req.queries().iter().cloned());
+    if let Some(edns) = req.extensions().clone() {
+        message.set_edns(edns);
+    }
+    message
+}
+
+fn servfail_info() -> ResponseInfo {
+    let mut header = Header::new();
+    header.set_response_code(ResponseCode::ServFail);
+    header.into()
+}

clash-dns/src/lib.rs

@@ -1,5 +1,8 @@
 use std::{net::SocketAddr, path::Path};
 
+use async_trait::async_trait;
+use hickory_proto::op::Message;
+
 mod handler;
 
 mod utils;
@@ -26,7 +29,8 @@
     pub doh3: Option<DoH3Config>,
 }
 
+#[async_trait]
 pub trait DnsMessageExchanger: Send + Sync {
     fn ipv6(&self) -> bool;
-    // async fn exchange(&self, message: &Message) -> Result<Message, DNSError>;
+    async fn exchange(&self, message: &Message) -> Result<Message, DNSError>;
 }

clash-lib/Cargo.toml

@@ -37,8 +37,10 @@ h3-quinn = { version = "0.0.10", optional = true }
 quinn-proto = { version = "0.11.13", default-features = false, optional = true }
 maxminddb = "0.27"
 hickory-proto = "0.25"
-url = { version = "2", optional = true }
+hickory-resolver = { version = "0.25", features = ["tokio", "system-config", "webpki-roots", "tls-aws-lc-rs", "https-aws-lc-rs"] }
+url = { version = "2" }
 ipnet = { version = "2" }
+lru_time_cache = "0.11"
 network-interface = { version = "2", optional = true }
 
 serde = { version = "1", features = ["derive"] }
@@ -154,7 +156,7 @@ tun = [
     "dep:watfaq-netstack",
     "dep:smoltcp",
     "dep:network-interface",
-    "dep:url",
+    # "dep:url",
 ]
 tproxy = ["dep:etherparse"]
 redir = []

clash-lib/src/app/api/handlers/config.rs

@@ -17,8 +17,12 @@ use crate::{
         dispatcher::Dispatcher,
         dns::ThreadSafeDNSResolver,
         inbound::manager::{InboundManager, Ports},
+        logging,
+    },
+    config::{
+        def::{self},
+        internal::config::BindAddress,
     },
-    config::def::{self, LogLevel, RunMode},
 };
 
 #[derive(Clone)]
@@ -36,7 +40,10 @@ pub fn routes(
     dns_resolver: ThreadSafeDNSResolver,
 ) -> Router<Arc<AppState>> {
     Router::new()
-        .route("/", get(get_configs).put(update_configs))
+        .route(
+            "/",
+            get(get_configs).put(update_configs).patch(patch_configs),
+        )
         .with_state(ConfigState {
             inbound_manager,
             dispatcher,
@@ -45,7 +52,7 @@ pub fn routes(
         })
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 struct PatchConfigRequest {
     port: Option<u16>,
@@ -60,6 +67,26 @@ struct PatchConfigRequest {
     allow_lan: Option<bool>,
 }
 
+impl PatchConfigRequest {
+    fn rebuild_listeners(&self) -> bool {
+        self.port.is_some()
+            || self.socks_port.is_some()
+            || self.redir_port.is_some()
+            || self.tproxy_port.is_some()
+            || self.mixed_port.is_some()
+            || self.bind_address.is_some()
+    }
+}
+
+fn parse_bind_address(value: &str) -> Result<BindAddress, ()> {
+    match value {
+        "*" => Ok(BindAddress::all_v4()),
+        "localhost" => Ok(BindAddress::local()),
+        "[::]" | "::" => Ok(BindAddress::dual_stack()),
+        _ => value.parse().map(BindAddress).map_err(|_| ()),
+    }
+}
+
 async fn get_configs(State(state): State<ConfigState>) -> impl IntoResponse {
     let run_mode = state.dispatcher.get_mode().await;
     let global_state = state.global_state.lock().await;
@@ -156,3 +183,73 @@ async fn update_configs(
         }
     }
 }
+
+async fn patch_configs(
+    State(state): State<ConfigState>,
+    Json(payload): Json<PatchConfigRequest>,
+) -> impl IntoResponse {
+    let inbound_manager = state.inbound_manager.clone();
+    let mut need_restart = false;
+
+    if let Some(bind_address) = payload.bind_address.clone() {
+        match parse_bind_address(&bind_address) {
+            Ok(bind_address) => {
+                inbound_manager.set_bind_address(bind_address).await;
+                need_restart = true;
+            }
+            Err(_) => {
+                return (
+                    StatusCode::BAD_REQUEST,
+                    format!("invalid bind address: {bind_address}"),
+                )
+                    .into_response();
+            }
+        }
+    }
+
+    let mut global_state = state.global_state.lock().await;
+
+    if payload.rebuild_listeners() {
+        let ports = Ports {
+            port: payload.port,
+            socks_port: payload.socks_port,
+            redir_port: payload.redir_port,
+            tproxy_port: payload.tproxy_port,
+            mixed_port: payload.mixed_port,
+        };
+        inbound_manager.change_ports(ports).await;
+        need_restart = true;
+    }
+
+    if let Some(allow_lan) = payload.allow_lan
+        && allow_lan != inbound_manager.get_allow_lan().await
+    {
+        inbound_manager.set_allow_lan(allow_lan).await;
+        need_restart = true;
+    }
+
+    if need_restart {
+        inbound_manager.restart().await;
+    }
+
+    if let Some(mode) = payload.mode {
+        state.dispatcher.set_mode(mode).await;
+    }
+
+    if let Some(log_level) = payload.log_level {
+        global_state.log_level = log_level;
+        if let Err(err) = logging::set_log_level(log_level) {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("failed to update log level: {err}"),
+            )
+                .into_response();
+        }
+    }
+
+    if let Some(ipv6) = payload.ipv6 {
+        state.dns_resolver.set_ipv6(ipv6);
+    }
+
+    StatusCode::ACCEPTED.into_response()
+}

clash-lib/src/app/api/handlers/traffic.rs

@@ -1,7 +1,9 @@
-use std::{net::SocketAddr, sync::Arc};
+use std::sync::Arc;
 
 use axum::{
-    extract::{ConnectInfo, State, WebSocketUpgrade, ws::Message},
+    body::Body,
+    extract::{FromRequest, Request, State, WebSocketUpgrade, ws::Message},
+    http::StatusCode,
     response::IntoResponse,
 };
 use serde::Serialize;
@@ -16,12 +18,22 @@ struct TrafficResponse {
 }
 
 pub async fn handle(
-    ws: WebSocketUpgrade,
-    ConnectInfo(addr): ConnectInfo<SocketAddr>,
     State(state): State<Arc<AppState>>,
+    req: Request<Body>,
 ) -> impl IntoResponse {
+    let ws = match WebSocketUpgrade::from_request(req, &state).await {
+        Ok(ws) => ws,
+        Err(_) => {
+            return (
+                StatusCode::BAD_REQUEST,
+                "the /traffic endpoint requires websocket upgrade",
+            )
+                .into_response();
+        }
+    };
+
     ws.on_failed_upgrade(move |e| {
-        warn!("ws upgrade error: {} with {}", e, addr);
+        warn!("ws upgrade error: {}", e);
     })
     .on_upgrade(move |mut socket| async move {
         let mgr = state.statistics_manager.clone();