utils: move ResponseHandle

easytier/src/dns/server.rs

@@ -3,6 +3,7 @@ use crate::common::global_ctx::ArcGlobalCtx;
 use crate::dns::node_mgr::DnsNodeMgr;
 use crate::dns::system;
 use crate::dns::utils::addr::NameServerAddr;
+use crate::dns::utils::response::ResponseHandle;
 use crate::instance::instance::{ArcNicCtx, NicCtx};
 use crate::peer_center::instance::PeerCenterPeerManagerTrait;
 use crate::peers::peer_manager::PeerManager;
@@ -37,7 +38,7 @@ use tokio_util::sync::CancellationToken;
 use tracing::{instrument, Instrument};
 
 #[derive(Clone)]
-pub struct DynamicCatalog {
+struct DynamicCatalog {
     inner: Arc<tokio::sync::RwLock<Catalog>>,
 }
 
@@ -68,56 +69,6 @@ impl RequestHandler for DynamicCatalog {
     }
 }
 
-// ResponseWrapper for serializing DNS responses into a byte buffer.
-// Used by the address hijacking NIC packet filter to produce DNS replies in-place.
-#[derive(Debug, Clone)]
-struct ResponseHandle {
-    inner: Arc<Mutex<Vec<u8>>>,
-}
-
-impl ResponseHandle {
-    pub fn new(capacity: usize) -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(Vec::with_capacity(capacity))),
-        }
-    }
-
-    pub fn into_inner(self) -> Option<Vec<u8>> {
-        Arc::into_inner(self.inner).map(Mutex::into_inner)
-    }
-}
-
-trait RecordIter<'r>: Iterator<Item = &'r Record> + Send + 'r {}
-impl<'r, T> RecordIter<'r> for T where T: Iterator<Item = &'r Record> + Send + 'r {}
-
-#[async_trait::async_trait]
-impl ResponseHandler for ResponseHandle {
-    async fn send_response<'r>(
-        &mut self,
-        response: MessageResponse<
-            '_,
-            'r,
-            impl RecordIter<'r>,
-            impl RecordIter<'r>,
-            impl RecordIter<'r>,
-            impl RecordIter<'r>,
-        >,
-    ) -> io::Result<ResponseInfo> {
-        let max_size = if let Some(edns) = response.get_edns() {
-            edns.max_payload()
-        } else {
-            hickory_proto::udp::MAX_RECEIVE_BUFFER_SIZE as u16
-        };
-
-        let mut inner = self.inner.lock();
-        let mut encoder = BinEncoder::new(inner.as_mut());
-        encoder.set_max_size(max_size);
-        response
-            .destructive_emit(&mut encoder)
-            .map_err(io::Error::other)
-    }
-}
-
 #[derive(Derivative)]
 #[derivative(Debug)]
 pub struct DnsServer {
@@ -437,8 +388,6 @@ impl DnsServer {
             return None;
         }
 
-        tracing::warn!("HIJACKING PACKET");
-
         let response_payload = {
             let response = ResponseHandle::new(512);
 

easytier/src/dns/utils/mod.rs

@@ -5,6 +5,7 @@ use itertools::Itertools;
 pub mod addr;
 pub mod authority;
 pub mod dirty;
+pub mod response;
 
 pub fn sanitize(name: &str) -> String {
     let dot = name.ends_with('.');

easytier/src/dns/utils/response.rs

@@ -0,0 +1,58 @@
+use std::io;
+use std::sync::Arc;
+use hickory_proto::rr::Record;
+use parking_lot::Mutex;
+use hickory_server::server::{ResponseHandler, ResponseInfo};
+use hickory_server::authority::MessageResponse;
+use hickory_proto::serialize::binary::BinEncoder;
+
+// ResponseWrapper for serializing DNS responses into a byte buffer.
+// Used by the address hijacking NIC packet filter to produce DNS replies in-place.
+#[derive(Debug, Clone)]
+pub struct ResponseHandle {
+    inner: Arc<Mutex<Vec<u8>>>,
+}
+
+impl ResponseHandle {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(Vec::with_capacity(capacity))),
+        }
+    }
+
+    pub fn into_inner(self) -> Option<Vec<u8>> {
+        Arc::into_inner(self.inner).map(Mutex::into_inner)
+    }
+}
+
+trait RecordIter<'r>: Iterator<Item = &'r Record> + Send + 'r {}
+
+impl<'r, T> RecordIter<'r> for T where T: Iterator<Item = &'r Record> + Send + 'r {}
+
+#[async_trait::async_trait]
+impl ResponseHandler for ResponseHandle {
+    async fn send_response<'r>(
+        &mut self,
+        response: MessageResponse<
+            '_,
+            'r,
+            impl RecordIter<'r>,
+            impl RecordIter<'r>,
+            impl RecordIter<'r>,
+            impl RecordIter<'r>,
+        >,
+    ) -> io::Result<ResponseInfo> {
+        let max_size = if let Some(edns) = response.get_edns() {
+            edns.max_payload()
+        } else {
+            hickory_proto::udp::MAX_RECEIVE_BUFFER_SIZE as u16
+        };
+
+        let mut inner = self.inner.lock();
+        let mut encoder = BinEncoder::new(inner.as_mut());
+        encoder.set_max_size(max_size);
+        response
+            .destructive_emit(&mut encoder)
+            .map_err(io::Error::other)
+    }
+}