实现日志详情域名信息显示

dns/server.go

@@ -184,7 +184,6 @@ func NewServer(config *config.DNSConfig, shieldConfig *config.ShieldConfig, shie
 		shieldManager: shieldManager,
 		resolver: &dns.Client{
 			Net:     "udp",
-			Timeout: time.Duration(config.Timeout) * time.Millisecond,
 			UDPSize: 4096, // 增加UDP缓冲区大小，支持更大的DNSSEC响应
 		},
 		ctx:       ctx,
@@ -864,10 +863,6 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 		responses := make(chan serverResponse, len(selectedUpstreamDNS))
 		var wg sync.WaitGroup
 
-		// 超时上下文
-		timeoutCtx, cancel := context.WithTimeout(s.ctx, time.Duration(s.config.Timeout)*time.Millisecond)
-		defer cancel()
-
 		// 向所有上游服务器并行发送请求
 		for _, upstream := range selectedUpstreamDNS {
 			wg.Add(1)
@@ -876,15 +871,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 
 				// 发送请求并获取响应，确保服务器地址包含端口号
 				response, rtt, err := s.resolver.Exchange(r, normalizeDNSServerAddress(server))
-
-				select {
-				case responses <- serverResponse{response, rtt, server, err}:
-					// 成功发送响应
-				case <-timeoutCtx.Done():
-					// 超时，忽略此响应
-					logger.Debug("并行请求超时", "server", server, "domain", domain)
-					return
-				}
+				responses <- serverResponse{response, rtt, server, err}
 			}(upstream)
 		}
 
@@ -894,7 +881,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			close(responses)
 		}()
 
-		// 处理所有响应
+		// 处理所有响应，实现快速响应返回
 		for resp := range responses {
 			if resp.error == nil && resp.response != nil {
 				// 更新服务器统计信息
@@ -958,6 +945,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 						hasDNSSECResponse = containsDNSSEC
 						usedDNSServer = resp.server
 						logger.Debug("使用用户配置的上游服务器响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+						// 快速返回：用户配置的主DNS服务器响应，立即返回
+						continue
 					} else if containsDNSSEC {
 						// 非用户配置服务器，但有DNSSEC记录
 						if !hasBestResponse || !isUserUpstream {
@@ -968,6 +957,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 							hasDNSSECResponse = true
 							usedDNSServer = resp.server
 							logger.Debug("找到带DNSSEC的最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+							// 快速返回：找到带DNSSEC的响应，立即返回
+							continue
 						}
 					} else {
 						// 非用户配置服务器，没有DNSSEC记录
@@ -978,6 +969,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 							hasBestResponse = true
 							usedDNSServer = resp.server
 							logger.Debug("找到最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+							// 快速返回：第一次找到成功响应，立即返回
+							continue
 						}
 					}
 				} else if resp.response.Rcode == dns.RcodeNameError {
@@ -991,6 +984,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 							hasBestResponse = true
 							usedDNSServer = resp.server
 							logger.Debug("使用用户配置的上游服务器NXDOMAIN响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+							// 快速返回：用户配置的服务器NXDOMAIN响应，立即返回
+							continue
 						} else if !hasBestResponse || resp.rtt < bestRtt {
 							// 非用户配置服务器，选择更快的响应
 							bestResponse = resp.response
@@ -998,6 +993,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 							hasBestResponse = true
 							usedDNSServer = resp.server
 							logger.Debug("找到NXDOMAIN最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+							// 快速返回：找到NXDOMAIN响应，立即返回
+							continue
 						}
 					}
 				}
@@ -1061,10 +1058,6 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			triedServers = append(triedServers, selectedServer)
 			logger.Debug("在负载均衡模式下选择服务器", "domain", domain, "server", selectedServer, "triedServers", triedServers)
 
-			// 设置超时上下文
-			timeoutCtx, cancel := context.WithTimeout(s.ctx, time.Duration(s.config.Timeout)*time.Millisecond)
-			defer cancel()
-
 			// 使用带超时的方式执行Exchange
 			resultChan := make(chan struct {
 				response *dns.Msg
@@ -1085,12 +1078,9 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			var rtt time.Duration
 			var err error
 
-			select {
-			case result := <-resultChan:
-				response, rtt, err = result.response, result.rtt, result.err
-			case <-timeoutCtx.Done():
-				err = timeoutCtx.Err()
-			}
+			// 直接获取结果，不使用上下文超时
+			result := <-resultChan
+			response, rtt, err = result.response, result.rtt, result.err
 
 			if err == nil && response != nil {
 				// 更新服务器统计信息
@@ -1187,10 +1177,6 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 		// 1. 选择最快的服务器
 		fastestServer := s.selectFastestServer(selectedUpstreamDNS)
 		if fastestServer != "" {
-			// 设置超时上下文
-			timeoutCtx, cancel := context.WithTimeout(s.ctx, time.Duration(s.config.Timeout)*time.Millisecond)
-			defer cancel()
-
 			// 使用带超时的方式执行Exchange
 			resultChan := make(chan struct {
 				response *dns.Msg
@@ -1211,12 +1197,9 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			var rtt time.Duration
 			var err error
 
-			select {
-			case result := <-resultChan:
-				response, rtt, err = result.response, result.rtt, result.err
-			case <-timeoutCtx.Done():
-				err = timeoutCtx.Err()
-			}
+			// 直接获取结果，不使用上下文超时
+			result := <-resultChan
+			response, rtt, err = result.response, result.rtt, result.err
 			if err == nil && response != nil {
 				// 更新服务器统计信息
 				s.updateServerStats(fastestServer, true, rtt)
@@ -1310,10 +1293,6 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 		responses := make(chan serverResponse, len(selectedUpstreamDNS))
 		var wg sync.WaitGroup
 
-		// 超时上下文
-		timeoutCtx, cancel := context.WithTimeout(s.ctx, time.Duration(s.config.Timeout)*time.Millisecond)
-		defer cancel()
-
 		// 向所有上游服务器并行发送请求
 		for _, upstream := range selectedUpstreamDNS {
 			wg.Add(1)
@@ -1322,30 +1301,17 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 
 				// 发送请求并获取响应
 				response, rtt, err := s.resolver.Exchange(r, normalizeDNSServerAddress(server))
-
-				select {
-				case responses <- serverResponse{response, rtt, server, err}:
-					// 成功发送响应
-				case <-timeoutCtx.Done():
-					// 超时，忽略此响应
-					logger.Debug("并行请求超时", "server", server, "domain", domain)
-					return
-				}
+				responses <- serverResponse{response, rtt, server, err}
 			}(upstream)
 		}
 
-		// 等待所有请求完成或超时
+		// 等待所有请求完成
 		go func() {
 			wg.Wait()
 			close(responses)
 		}()
 
-		// 等待上下文超时，防止泄漏
-		go func() {
-			<-timeoutCtx.Done()
-		}()
-
-		// 处理所有响应
+		// 处理所有响应，实现快速响应返回
 		for resp := range responses {
 			if resp.error == nil && resp.response != nil {
 
@@ -1397,6 +1363,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 								}
 							}
 							logger.Debug("找到带DNSSEC的最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+							// 快速返回：找到带DNSSEC的响应，立即返回
+							continue
 						} else if !hasBestResponse {
 							// 没有带DNSSEC的响应时，保存第一个成功响应
 							bestResponse = resp.response
@@ -1411,6 +1379,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 								}
 							}
 							logger.Debug("找到最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+							// 快速返回：第一次找到成功响应，立即返回
+							continue
 						}
 					} else if resp.response.Rcode == dns.RcodeNameError {
 						// 处理NXDOMAIN响应
@@ -1423,6 +1393,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 								hasBestResponse = true
 								usedDNSServer = resp.server
 								logger.Debug("找到NXDOMAIN最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+								// 快速返回：找到NXDOMAIN响应，立即返回
+								continue
 							}
 						}
 					}
@@ -1450,10 +1422,6 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 		// 无论查询模式是什么，DNSSEC验证都只使用加权随机选择一个服务器
 		selectedDnssecServer := s.selectWeightedRandomServer(dnssecServers)
 		if selectedDnssecServer != "" {
-			// 设置超时上下文
-			timeoutCtx, cancel := context.WithTimeout(s.ctx, time.Duration(s.config.Timeout)*time.Millisecond)
-			defer cancel()
-
 			// 使用带超时的方式执行Exchange
 			resultChan := make(chan struct {
 				response *dns.Msg
@@ -1474,12 +1442,9 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			var rtt time.Duration
 			var err error
 
-			select {
-			case result := <-resultChan:
-				response, rtt, err = result.response, result.rtt, result.err
-			case <-timeoutCtx.Done():
-				err = timeoutCtx.Err()
-			}
+			// 直接获取结果，不使用上下文超时
+			result := <-resultChan
+			response, rtt, err = result.response, result.rtt, result.err
 
 			if err == nil && response != nil {
 				// 更新服务器统计信息
@@ -1548,10 +1513,6 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			// 选择一个upstreamDNS服务器进行解析（使用加权随机算法）
 			localServer := s.selectWeightedRandomServer(s.config.UpstreamDNS)
 			if localServer != "" {
-				// 设置超时上下文
-				timeoutCtx, cancel := context.WithTimeout(s.ctx, time.Duration(s.config.Timeout)*time.Millisecond)
-				defer cancel()
-
 				// 使用带超时的方式执行Exchange
 				resultChan := make(chan struct {
 					response *dns.Msg
@@ -1572,12 +1533,10 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 				var rtt time.Duration
 				var err error
 
-				select {
-				case result := <-resultChan:
-					localResponse, rtt, err = result.response, result.rtt, result.err
-				case <-timeoutCtx.Done():
-					err = timeoutCtx.Err()
-				}
+				// 直接获取结果，不使用上下文超时
+				result := <-resultChan
+				localResponse, rtt, err = result.response, result.rtt, result.err
+
 				if err == nil && localResponse != nil {
 					// 更新服务器统计信息
 					s.updateServerStats(localServer, true, rtt)