🐛 Fix message_type error and adjust debug log output

FlyLoongZ · Nov 10, 2024 · e67b56b · e67b56b
1 parent 27eb918
commit e67b56b
Show file tree

Hide file tree

Showing 4 changed files with 76 additions and 49 deletions.
diff --git a/src/app.rs b/src/app.rs
@@ -1,6 +1,6 @@
 use std::{
     collections::HashMap,
-    ops::DerefMut,
+    ops::{Deref, DerefMut},
     path::PathBuf,
     sync::Arc,
     time::{Duration, Instant},
@@ -338,7 +338,7 @@ async fn process(
     server_opts: ServerOpts,
 ) -> SerialMessage {
     use crate::libdns::proto::error::ProtoError;
-    use crate::libdns::proto::op::{Edns, Header, Message, MessageType, OpCode, ResponseCode};
+    use crate::libdns::proto::op::{Header, Message, MessageType, OpCode, ResponseCode};
 
     let addr = message.addr();
     let protocol = message.protocol();
@@ -349,36 +349,6 @@ async fn process(
                 MessageType::Query => {
                     match request.op_code() {
                         OpCode::Query => {
-                            let id = request.id();
-                            let qflags = request.header().flags();
-                            let qop_code = request.op_code();
-                            let message_type = request.message_type();
-                            let is_dnssec =
-                                request.extensions().as_ref().map_or(false, Edns::dnssec_ok);
-
-                            {
-                                let src_addr = request.src();
-                                let protocol = request.protocol();
-                                let query = request.query();
-                                let query_name = query.name();
-                                let query_type = query.query_type();
-                                let query_class = query.query_class();
-                                log::debug!(
-                                    "request:{id} src:{proto}://{addr}#{port} type:{message_type} dnssec:{is_dnssec} {op}:{query}:{qtype}:{class} qflags:{qflags}",
-                                    id = id,
-                                    proto = protocol,
-                                    addr = src_addr.ip(),
-                                    port = src_addr.port(),
-                                    message_type= message_type,
-                                    is_dnssec = is_dnssec,
-                                    op = qop_code,
-                                    query = query_name,
-                                    qtype = query_type,
-                                    class = query_class,
-                                    qflags = qflags,
-                                );
-                            }
-
                             // start process
                             let request_header = request.header();
                             let mut response_header = Header::response_from_request(request_header);
@@ -387,18 +357,42 @@ async fn process(
                             response_header.set_authoritative(false);
 
                             let response = {
+                                let start = Instant::now();
                                 let res = handler.search(&request, &server_opts).await;
+
+                                log::debug!(
+                                    "{}Request: {:?}",
+                                    if server_opts.is_background {
+                                        "Background"
+                                    } else {
+                                        ""
+                                    },
+                                    request
+                                );
                                 match res {
-                                    Ok(lookup) => lookup,
+                                    Ok(lookup) => {
+                                        log::debug!(
+                                            "Response: {}, Duration: {:?}",
+                                            lookup.deref(),
+                                            start.elapsed()
+                                        );
+                                        lookup
+                                    }
                                     Err(e) => {
                                         if e.is_nx_domain() {
+                                            log::debug!("{}Response: error resolving: NXDomain, Duration: {:?}", if server_opts.is_background { "Background"} else { "" }, start.elapsed());
                                             response_header
                                                 .set_response_code(ResponseCode::NXDomain);
                                         }
                                         match e.as_soa() {
                                             Some(soa) => soa,
                                             None => {
-                                                log::debug!("error resolving: {}", e);
+                                                log::debug!(
+                                                    "{}Response: error resolving: {}, Duration: {:?}",
+                                                    if server_opts.is_background { "Background"} else { "" },
+                                                    e,
+                                                    start.elapsed()
+                                                );
                                                 DnsResponse::empty()
                                             }
                                         }

diff --git a/src/dns.rs b/src/dns.rs
@@ -210,7 +210,7 @@ mod serial_message {
 
 mod request {
 
-    use std::{net::SocketAddr, ops::Deref, sync::Arc};
+    use std::{fmt::Debug, net::SocketAddr, ops::Deref, sync::Arc};
 
     use crate::libdns::{
         proto::{
@@ -298,6 +298,38 @@ mod request {
         }
     }
 
+    impl Debug for DnsRequest {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let id = self.id();
+            let src_addr = self.src();
+            let protocol = self.protocol();
+            let query = self.query();
+            let query_name = query.name();
+            let query_type = query.query_type();
+            let query_class = query.query_class();
+
+            let message_type = self.message_type();
+            let is_dnssec = self.is_dnssec();
+            let qop_code = self.op_code();
+            let qflags = self.flags();
+
+            write!(f,
+                "{id} src:{proto}://{addr}#{port} type:{message_type} dnssec:{is_dnssec} {op}:{query}:{qtype}:{class} qflags:{qflags}",
+                id = id,
+                proto = protocol,
+                addr = src_addr.ip(),
+                port = src_addr.port(),
+                message_type= message_type,
+                is_dnssec = is_dnssec,
+                op = qop_code,
+                query = query_name,
+                qtype = query_type,
+                class = query_class,
+                qflags = qflags,
+            )
+        }
+    }
+
     impl std::ops::Deref for DnsRequest {
         type Target = Message;
 
@@ -346,7 +378,7 @@ mod response {
 
     use crate::dns_client::MAX_TTL;
     use crate::libdns::proto::{
-        op::{self, Header, Message, Query},
+        op::{self, Header, Message, MessageType, Query},
         rr::{RData, Record},
     };
     use crate::libdns::resolver::TtlClip as _;
@@ -384,6 +416,7 @@ mod response {
         {
             use op::message::{update_header_counts, HeaderCounts};
             let mut message = Message::new();
+            message.set_message_type(MessageType::Response);
             message.add_query(query.clone());
             message.add_answers(records);
 

diff --git a/src/dns_conf.rs b/src/dns_conf.rs
@@ -919,20 +919,19 @@ fn resolve_filepath<P: AsRef<Path>>(filepath: P, base_file: Option<&PathBuf>) ->
                 }
             }
         }
-    } else {
-        // try to resolve absolute path by extracting its file_name
-        if let Some(new_path) = filepath.file_name().map(|f| resolve_filepath(f, base_file)) {
-            if new_path.is_file() {
-                log::warn!(
-                    "File {} not found, but {} found",
-                    filepath.display(),
-                    new_path.display()
-                );
-                return new_path;
-            }
-        }
     }
 
+    // try to resolve absolute path by extracting its file_name
+    if let Some(new_path) = filepath.file_name().map(|f| resolve_filepath(f, base_file)) {
+        if new_path.is_file() {
+            log::warn!(
+                "File {} not found, but {} found",
+                filepath.display(),
+                new_path.display()
+            );
+            return new_path;
+        }
+    }
     filepath.to_path_buf()
 }
 

diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -8,7 +8,7 @@ mod tcp;
 mod tls;
 mod udp;
 
-use crate::libdns::proto::op::{Header, Message, ResponseCode};
+use crate::libdns::proto::op::{Header, Message, MessageType, ResponseCode};
 use std::{
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     path::Path,
@@ -218,6 +218,7 @@ impl DnsHandle {
             Err(_) => {
                 let mut response_header = Header::default();
                 response_header.set_response_code(ResponseCode::Refused);
+                response_header.set_message_type(MessageType::Response);
                 let mut response_message = Message::new();
                 response_message.set_header(response_header);
                 response_message.into()