Merge remote-tracking branch 'origin/dns_fix' into dns_fix

MaurUppi · MaurUppi · commit 1b91f41bd860 · 2026-02-16T17:12:35.000+08:00
diff --git a/.plan/dns_improvement_plan_v2-dev.md b/.plan/dns_improvement_plan_v2-dev.md
@@ -0,0 +1,43 @@
+# dae DNS 改进计划 v2 - 开发执行文档
+
+> baseline: mosDNS（`.plan/dae_vs_mosdns_table.csv` / `.plan/dae_vs_mosDNS_findings.md`）
+
+## 执行原则
+1. 严格串行：Tn 完成实现并完成任务级测试记录后，才进入 Tn+1。
+2. 每个任务必须包含：代码变更、任务级测试、测试结论。
+3. 里程碑回归：阶段任务全部完成后进行一次回归测试。
+
+## 任务拆解与落地
+
+### T1（P0-1）：修复 UDP forwarder 连接回收
+- 变更点：
+  - `DoUDP.ForwardDNS` 拨号成功后保存 `d.conn`。
+  - `DoUDP.Close` 关闭后置 `d.conn=nil`，确保幂等回收。
+- 目标：降低 UDP 连接泄漏导致的 FD/端口压力。
+
+### T2（P1-1）：失败路径接入 timeout 健康反馈
+- 变更点：
+  - `dialSend` 在 forwarder 返回 timeout 错误时调用 `timeoutExceedCallback`。
+  - 新增 `isTimeoutError` 统一识别 `context deadline exceeded` / `net.Error.Timeout()`。
+- 目标：让健康度系统尽快降权不健康路径。
+
+### T3（P1-3）：tcp+udp 增加同查询 UDP→TCP fallback
+- 变更点：
+  - 新增 `tcpFallbackDialArgument`：仅在 upstream 为 `tcp+udp` 且首发 UDP timeout 时切换 TCP。
+  - `dialSend` 在一次查询内执行一次 fallback 重试，避免无限重试放大。
+- 目标：降低 UDP 瞬时抖动造成的直接失败。
+
+### T4（P1-4）：统一上下文/超时语义
+- 变更点：
+  - DoH 请求改为 `http.NewRequestWithContext`。
+  - `sendStreamDNS` 增加 `ctx` 入参，优先使用 `ctx.Deadline()` 设置 stream deadline，并在 I/O 前后检查 `ctx`。
+- 目标：提升取消及时性，降低尾延迟。
+
+### T5（P2-5）：ipversion_prefer 从固定并发双查改为“优先+条件补查”
+- 变更点：
+  - `Handle_` 对 A/AAAA 请求改为先查首选 qtype；仅当需要时再补查另一族。
+- 目标：降低上游请求放大与高压下 timeout 叠加。
+
+## 本轮范围说明
+- 本轮完成 T1~T5。
+- P2-6（DNS 维度指标与自适应）需要较大横切改造（指标面板+选择器反馈回路），建议下一迭代单独实施。
diff --git a/.plan/test-log.md b/.plan/test-log.md
@@ -0,0 +1,31 @@
+# DNS 改进测试记录
+
+## T1（UDP 连接回收）
+- 命令：`rg -n "d\.conn = conn|d\.conn = nil" control/dns.go`
+- 结果：命中 `DoUDP.ForwardDNS` 的 `d.conn = conn` 与 `DoUDP.Close` 的 `d.conn = nil`。
+- 结论：通过（实现与预期一致）。
+
+## T2（超时反馈闭环）
+- 命令：`rg -n "timeoutExceedCallback|isTimeoutError\(" control/dns_control.go`
+- 结果：命中 `dialSend` 失败路径回调上报，以及 `isTimeoutError` 超时识别函数。
+- 结论：通过（失败可反馈到健康度系统）。
+
+## T3（tcp+udp 同查询 fallback）
+- 命令：`rg -n "tcpFallbackDialArgument|fallbackForwarder" control/dns_control.go`
+- 结果：命中 UDP 失败后 TCP fallback 逻辑及一次性 fallback 执行路径。
+- 结论：通过（具备同查询协议兜底能力）。
+
+## T4（上下文/超时语义统一）
+- 命令：`rg -n "NewRequestWithContext|sendHttpDNS\(|sendStreamDNS\(ctx" control/dns.go`
+- 结果：DoH 使用 `http.NewRequestWithContext`；stream DNS 调用与实现均带 `ctx`。
+- 结论：通过（超时/取消语义已向协议层传递）。
+
+## T5（ipversion_prefer 条件补查）
+- 命令：`rg -n "Query preferred qtype first|handle_\(dnsMessage2|done := make\(chan" control/dns_control.go`
+- 结果：命中“先查首选再条件补查”路径；未再出现旧版并发双查 `done` channel 逻辑。
+- 结论：通过（请求放大被抑制）。
+
+## 里程碑回归（代码级）
+- 命令：`go test ./control -run 'Test(IsTimeoutError|TcpFallbackDialArgument|SendStreamDNSRespectsContextCancelBeforeIO)' -count=1`
+- 结果：失败，原因是环境无法从 `proxy.golang.org` 拉取依赖（`github.com/daeuniverse/outbound` 403 Forbidden）。
+- 结论：受环境限制，未完成自动化回归；本轮以静态实现校验作为替代。
diff --git a/control/dns.go b/control/dns.go
@@ -1,7 +1,7 @@
 /*
 *  SPDX-License-Identifier: AGPL-3.0-only
 *  Copyright (c) 2022-2025, daeuniverse Organization <dae@v2raya.org>
-*/
+ */
 
 package control
 
@@ -80,11 +80,11 @@ func (d *DoH) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, err
 	if d.client == nil {
 		d.client = d.getClient()
 	}
-	msg, err := sendHttpDNS(d.client, d.dialArgument.bestTarget.String(), &d.Upstream, data)
+	msg, err := sendHttpDNS(ctx, d.client, d.dialArgument.bestTarget.String(), &d.Upstream, data)
 	if err != nil {
 		// If failed to send DNS request, we should try to create a new client.
 		d.client = d.getClient()
-		msg, err = sendHttpDNS(d.client, d.dialArgument.bestTarget.String(), &d.Upstream, data)
+		msg, err = sendHttpDNS(ctx, d.client, d.dialArgument.bestTarget.String(), &d.Upstream, data)
 		if err != nil {
 			return nil, err
 		}
@@ -196,7 +196,7 @@ func (d *DoQ) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, err
 	// thanks https://github.com/natesales/q/blob/1cb2639caf69bd0a9b46494a3c689130df8fb24a/transport/quic.go#L97
 	binary.BigEndian.PutUint16(data[0:2], 0)
 
-	msg, err := sendStreamDNS(stream, data)
+	msg, err := sendStreamDNS(ctx, stream, data)
 	if err != nil {
 		return nil, err
 	}
@@ -259,7 +259,7 @@ func (d *DoTLS) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, e
 	}
 	d.conn = tlsConn
 
-	return sendStreamDNS(tlsConn, data)
+	return sendStreamDNS(ctx, tlsConn, data)
 }
 
 func (d *DoTLS) Close() error {
@@ -287,7 +287,7 @@ func (d *DoTCP) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, e
 	}
 
 	d.conn = conn
-	return sendStreamDNS(conn, data)
+	return sendStreamDNS(ctx, conn, data)
 }
 
 func (d *DoTCP) Close() error {
@@ -313,6 +313,7 @@ func (d *DoUDP) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, e
 	if err != nil {
 		return nil, err
 	}
+	d.conn = conn
 
 	timeout := 5 * time.Second
 	_ = conn.SetDeadline(time.Now().Add(timeout))
@@ -362,12 +363,14 @@ func (d *DoUDP) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, e
 
 func (d *DoUDP) Close() error {
 	if d.conn != nil {
-		return d.conn.Close()
+		err := d.conn.Close()
+		d.conn = nil
+		return err
 	}
 	return nil
 }
 
-func sendHttpDNS(client *http.Client, target string, upstream *dns.Upstream, data []byte) (respMsg *dnsmessage.Msg, err error) {
+func sendHttpDNS(ctx context.Context, client *http.Client, target string, upstream *dns.Upstream, data []byte) (respMsg *dnsmessage.Msg, err error) {
 	// disable redirect https://github.com/daeuniverse/dae/pull/649#issuecomment-2379577896
 	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
 		return fmt.Errorf("do not use a server that will redirect, upstream: %v", upstream.String())
@@ -384,7 +387,7 @@ func sendHttpDNS(client *http.Client, target string, upstream *dns.Upstream, dat
 	q.Set("dns", base64.RawURLEncoding.EncodeToString(data))
 	serverURL.RawQuery = q.Encode()
 
-	req, err := http.NewRequest(http.MethodGet, serverURL.String(), nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, serverURL.String(), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -406,7 +409,19 @@ func sendHttpDNS(client *http.Client, target string, upstream *dns.Upstream, dat
 	return &msg, nil
 }
 
-func sendStreamDNS(stream io.ReadWriter, data []byte) (respMsg *dnsmessage.Msg, err error) {
+func sendStreamDNS(ctx context.Context, stream io.ReadWriter, data []byte) (respMsg *dnsmessage.Msg, err error) {
+	type streamDeadliner interface {
+		SetDeadline(t time.Time) error
+	}
+	if deadliner, ok := stream.(streamDeadliner); ok {
+		if deadline, ok := ctx.Deadline(); ok {
+			_ = deadliner.SetDeadline(deadline)
+		}
+	}
+	if err = ctx.Err(); err != nil {
+		return nil, err
+	}
+
 	// We should write two byte length in the front of stream DNS request.
 	bReq := pool.Get(2 + len(data))
 	defer pool.Put(bReq)
@@ -416,11 +431,17 @@ func sendStreamDNS(stream io.ReadWriter, data []byte) (respMsg *dnsmessage.Msg,
 	if err != nil {
 		return nil, fmt.Errorf("failed to write DNS req: %w", err)
 	}
+	if err = ctx.Err(); err != nil {
+		return nil, err
+	}
 
 	// Read two byte length.
 	if _, err = io.ReadFull(stream, bReq[:2]); err != nil {
 		return nil, fmt.Errorf("failed to read DNS resp payload length: %w", err)
 	}
+	if err = ctx.Err(); err != nil {
+		return nil, err
+	}
 	respLen := int(binary.BigEndian.Uint16(bReq))
 	// Try to reuse the buf.
 	var buf []byte
diff --git a/control/dns_control.go b/control/dns_control.go
@@ -7,6 +7,7 @@ package control
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math"
 	"net"
@@ -387,7 +388,7 @@ func (c *DnsController) Handle_(dnsMessage *dnsmessage.Msg, req *udpRequest) (er
 		return c.handle_(dnsMessage, req, true)
 	}
 
-	// Try to make both A and AAAA lookups.
+	// Query preferred qtype first, and only fallback to the opposite qtype when needed.
 	dnsMessage2 := deepcopy.Copy(dnsMessage).(*dnsmessage.Msg)
 	dnsMessage2.Id = uint16(fastrand.Intn(math.MaxUint16))
 	var qtype2 uint16
@@ -401,13 +402,7 @@ func (c *DnsController) Handle_(dnsMessage *dnsmessage.Msg, req *udpRequest) (er
 	}
 	dnsMessage2.Question[0].Qtype = qtype2
 
-	done := make(chan struct{})
-	go func() {
-		_ = c.handle_(dnsMessage2, req, false)
-		done <- struct{}{}
-	}()
 	err = c.handle_(dnsMessage, req, false)
-	<-done
 	if err != nil {
 		return err
 	}
@@ -422,12 +417,21 @@ func (c *DnsController) Handle_(dnsMessage *dnsmessage.Msg, req *udpRequest) (er
 		return c.sendReject_(dnsMessage, req)
 	}
 	// resp is valid.
-	cache2 := c.LookupDnsRespCache(c.cacheKey(qname, qtype2), true)
-	if c.qtypePrefer == qtype || cache2 == nil || !cache2.IncludeAnyIp() {
+	if c.qtypePrefer == qtype {
 		return sendPkt(c.log, resp, req.realDst, req.realSrc, req.src, req.lConn)
-	} else {
+	}
+
+	cache2 := c.LookupDnsRespCache(c.cacheKey(qname, qtype2), true)
+	if cache2 == nil || !cache2.IncludeAnyIp() {
+		if err = c.handle_(dnsMessage2, req, false); err != nil {
+			return err
+		}
+		cache2 = c.LookupDnsRespCache(c.cacheKey(qname, qtype2), true)
+	}
+	if cache2 != nil && cache2.IncludeAnyIp() {
 		return c.sendReject_(dnsMessage, req)
 	}
+	return sendPkt(c.log, resp, req.realDst, req.realSrc, req.src, req.lConn)
 }
 
 func (c *DnsController) handle_(
@@ -601,6 +605,31 @@ func (c *DnsController) dialSend(invokingDepth int, req *udpRequest, data []byte
 	}
 
 	respMsg, err = forwarder.ForwardDNS(ctxDial, data)
+	if err != nil {
+		if c.timeoutExceedCallback != nil && isTimeoutError(err) {
+			c.timeoutExceedCallback(dialArgument, err)
+		}
+		if fallbackDialArgument := tcpFallbackDialArgument(upstream, dialArgument, err); fallbackDialArgument != nil {
+			fallbackForwarder, fallbackErr := newDnsForwarder(upstream, *fallbackDialArgument)
+			if fallbackErr != nil {
+				return err
+			}
+			defer fallbackForwarder.Close()
+			respMsg, fallbackErr = fallbackForwarder.ForwardDNS(ctxDial, data)
+			if fallbackErr == nil {
+				dialArgument = fallbackDialArgument
+				err = nil
+			} else {
+				if c.timeoutExceedCallback != nil && isTimeoutError(fallbackErr) {
+					c.timeoutExceedCallback(fallbackDialArgument, fallbackErr)
+				}
+				return fallbackErr
+			}
+		} else {
+			return err
+		}
+	}
+
 	if err != nil {
 		return err
 	}
@@ -691,3 +720,32 @@ func (c *DnsController) dialSend(invokingDepth int, req *udpRequest, data []byte
 	}
 	return nil
 }
+
+func isTimeoutError(err error) bool {
+	if err == nil {
+		return false
+	}
+	if errors.Is(err, context.DeadlineExceeded) {
+		return true
+	}
+	var netErr net.Error
+	if errors.As(err, &netErr) {
+		return netErr.Timeout()
+	}
+	return false
+}
+
+func tcpFallbackDialArgument(upstream *dns.Upstream, dialArgument *dialArgument, err error) *dialArgument {
+	if upstream == nil || upstream.Scheme != dns.UpstreamScheme_TCP_UDP {
+		return nil
+	}
+	if dialArgument == nil || dialArgument.l4proto != consts.L4ProtoStr_UDP {
+		return nil
+	}
+	if !isTimeoutError(err) {
+		return nil
+	}
+	fallback := *dialArgument
+	fallback.l4proto = consts.L4ProtoStr_TCP
+	return &fallback
+}
diff --git a/control/dns_improvement_test.go b/control/dns_improvement_test.go
