From 628ed00074dd423b51c71e46211fecc1f17f1bfb Mon Sep 17 00:00:00 2001
From: Razvan Dimescu <ssaricu@gmail.com>
Date: Sun, 12 Apr 2026 13:08:37 +0300
Subject: [PATCH] refactor: extract cache_and_parse, remove dead truncation
 log, restore TCP_TIMEOUT to 400ms

---
 src/ctx.rs     | 53 ++++++++++++++++++++++++--------------------------
 src/forward.rs |  4 ----
 2 files changed, 25 insertions(+), 32 deletions(-)

diff --git a/src/ctx.rs b/src/ctx.rs
index 46316f2..e1d2d95 100644
--- a/src/ctx.rs
+++ b/src/ctx.rs
@@ -229,29 +229,17 @@ pub async fn resolve_query(
                 )
                 .await
                 {
-                    Ok(resp_wire) => {
-                        ctx.cache.write().unwrap().insert_wire(
-                            &qname,
-                            qtype,
-                            &resp_wire,
-                            DnssecStatus::Indeterminate,
-                        );
-                        let mut buf = BytePacketBuffer::from_bytes(&resp_wire);
-                        match DnsPacket::from_buffer(&mut buf) {
-                            Ok(resp) => (resp, QueryPath::Forwarded, DnssecStatus::Indeterminate),
-                            Err(e) => {
-                                error!(
-                                    "{} | {:?} {} | PARSE ERROR | {}",
-                                    src_addr, qtype, qname, e
-                                );
-                                (
-                                    DnsPacket::response_from(&query, ResultCode::SERVFAIL),
-                                    QueryPath::UpstreamError,
-                                    DnssecStatus::Indeterminate,
-                                )
-                            }
+                    Ok(resp_wire) => match cache_and_parse(ctx, &qname, qtype, &resp_wire) {
+                        Ok(resp) => (resp, QueryPath::Forwarded, DnssecStatus::Indeterminate),
+                        Err(e) => {
+                            error!("{} | {:?} {} | PARSE ERROR | {}", src_addr, qtype, qname, e);
+                            (
+                                DnsPacket::response_from(&query, ResultCode::SERVFAIL),
+                                QueryPath::UpstreamError,
+                                DnssecStatus::Indeterminate,
+                            )
                         }
-                    }
+                    },
                     Err(e) => {
                         error!(
                             "{} | {:?} {} | UPSTREAM ERROR | {}",
@@ -373,6 +361,20 @@ pub async fn resolve_query(
     Ok(resp_buffer)
 }
 
+fn cache_and_parse(
+    ctx: &ServerCtx,
+    qname: &str,
+    qtype: QueryType,
+    resp_wire: &[u8],
+) -> crate::Result<DnsPacket> {
+    ctx.cache
+        .write()
+        .unwrap()
+        .insert_wire(qname, qtype, resp_wire, DnssecStatus::Indeterminate);
+    let mut buf = BytePacketBuffer::from_bytes(resp_wire);
+    DnsPacket::from_buffer(&mut buf)
+}
+
 async fn forward_and_cache(
     wire: &[u8],
     upstream: &Upstream,
@@ -381,12 +383,7 @@ async fn forward_and_cache(
     qtype: QueryType,
 ) -> crate::Result<DnsPacket> {
     let resp_wire = forward_query_raw(wire, upstream, ctx.timeout).await?;
-    ctx.cache
-        .write()
-        .unwrap()
-        .insert_wire(qname, qtype, &resp_wire, DnssecStatus::Indeterminate);
-    let mut buf = BytePacketBuffer::from_bytes(&resp_wire);
-    DnsPacket::from_buffer(&mut buf)
+    cache_and_parse(ctx, qname, qtype, &resp_wire)
 }
 
 pub async fn handle_query(
diff --git a/src/forward.rs b/src/forward.rs
index ebbe777..839ac81 100644
--- a/src/forward.rs
+++ b/src/forward.rs
@@ -176,11 +176,7 @@ pub(crate) async fn forward_udp(
 ) -> Result<DnsPacket> {
     let mut send_buffer = BytePacketBuffer::new();
     query.write(&mut send_buffer)?;
-
     let data = forward_udp_raw(send_buffer.filled(), upstream, timeout_duration).await?;
-    if data.len() >= 4096 {
-        log::debug!("upstream response may be truncated ({} bytes)", data.len());
-    }
     let mut recv_buffer = BytePacketBuffer::from_bytes(&data);
     DnsPacket::from_buffer(&mut recv_buffer)
 }