refactor: extract cache_and_parse, remove dead truncation log, restore TCP_TIMEOUT to 400ms

src/ctx.rs

@@ -229,29 +229,17 @@ pub async fn resolve_query(
                 )
                 .await
                 {
-                    Ok(resp_wire) => {
+                    Ok(resp_wire) => match cache_and_parse(ctx, &qname, qtype, &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!(
+                            error!("{} | {:?} {} | PARSE ERROR | {}", src_addr, qtype, qname, e);
-                                    "{} | {:?} {} | 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
+    cache_and_parse(ctx, qname, qtype, &resp_wire)
-        .write()
-        .unwrap()
-        .insert_wire(qname, qtype, &resp_wire, DnssecStatus::Indeterminate);
-    let mut buf = BytePacketBuffer::from_bytes(&resp_wire);
-    DnsPacket::from_buffer(&mut buf)
 }
 
 pub async fn handle_query(

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)
 }