更新Swagger API

多项更新优化
版本更新
2025-12-26 09:28:29 +08:00 · 2025-12-26 09:02:59 +08:00 · 2025-12-24 10:59:29 +08:00 · 2025-12-24 10:08:35 +08:00
21 changed files with 52144 additions and 9106 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,82 @@
 # Changelog

 所有对本项目的显著更改都将记录在此文件中。
+## [1.2.5] - 2025-12-26
+### 新增
+- 增加了对IPv6的支持配置项，默认关闭；
+- 增加跟踪器状态显示（匹配tracker/trackers.json数据库）；
+- 全局UX改进，包括但不限于：
+  - 增加了页面滚动时，菜单栏和顶部标题栏保持固定的功能；
+  - 优化了页面适应窗口大小的改变，确保在所有设备上都能正确显示；
+  - 增加点击解析记录后弹窗日志详情的UI/UX，使用现代化设计和动画效果；
+  - 增加了查询日志详情界面的滚动条，方便查看长日志。
+### 改进
+- 新增API接口，用于查询解析日志详情；
+- 支持EDNS，在web界面查询日志详情的请求列表区域增加了EDNS标记显示。
+### 修复
+- 修复DNS服务器地址缺少端口号导致的Server Failed问题；
+- 修复查询日志详情接口返回的日志格式错误问题，现在返回的日志包含完整的解析记录和解析时间；
+- 修复查询日志详情接口返回的日志中，解析记录中缺少IP地址、类型、DNSSEC验证状态等信息的问题；
+- web界面系统设置加载后不获取数据和保存配置不生效的问题；
+- 修复了DNS查询超时设置过短导致的"Server failed"错误。
+### 更新
+- 更新Swagger API文档。
+### 下一版本改进
+- 增加了对DNSSEC的支持配置项，默认关闭；
+
+
+## [1.2.4] - 2025-12-25
+### 改进
+- 修复DNS解析记录显示，现在显示完整格式："A: 104.26.24.30 (ttl=193)" 而不仅仅是IP地址
+- 移除了查询日志列表中的"屏蔽规则"列，但在详情弹窗中仍保留
+- 在弹窗日志详情中，只有被屏蔽或者有自定义规则时才显示规则信息
+- 改进了日志详情弹窗的UI/UX，使用现代化设计和动画效果
+- 移除了右上角的服务器状态卡片（CPU、查询统计等）
+- 实现了页面滚动时，菜单栏和顶部标题栏保持固定
+- 优化了页面适应窗口大小的改变，确保在所有设备上都能正确显示
+### 修复
+- 修复了移动端侧边栏在打开时遮挡页面内容的问题
+- 修复了侧边栏布局，分离了桌面端和移动端侧边栏，使用CSS媒体查询控制显示
+
+## [1.2.3] - 2025-12-25
+### 修复
+- 修复DNS服务器地址缺少端口号导致的Server Failed问题
+- 添加normalizeDNSServerAddress函数，确保DNS服务器地址始终包含端口号，默认添加53端口
+- 修改所有resolver.Exchange()调用，确保传递的服务器地址包含端口号
+- 优化DNSSEC服务器合并逻辑，确保DNSSEC服务器地址也包含端口号
+
+## [1.2.2] - 2025-12-25
+
+### 新增
+- 增加查询日志详情界面点击域名列表，显示解析日志的详细信息。
+- 增加DNSSEC上游服务器的配置项。
+
+### 修复
+- web界面系统设置加载后不获取数据和保存配置不生效的问题。
+
+
+## [1.2.1] - 2025-12-25
+
+### 改进
+- 增加IPv6支持配置项，默认关闭
+### 修复
+- 修复了DNS查询超时设置过短导致的"Server failed"错误
+- 将默认DNS请求超时时间从5毫秒调整为1000毫秒
+
+## [1.2.0] - 2025-12-24
+
+### 添加
+- 在查询日志详情的域名左侧添加DNSSEC状态锁图标和跟踪器状态图标
+- 实现跟踪器状态显示（匹配tracker/trackers.json数据库）
+- 添加跟踪器详情浮窗（鼠标悬停在眼睛图标上时显示跟踪器名称、类别、URL、来源等信息）
+- 实现日志页面页码跳转功能（输入框+"前往"按钮）
+- 实现日志页面显示数量选择功能（下拉框）
+
+### 修改
+- 异步加载跟踪器数据库并缓存，优化性能
+- 将日志渲染逻辑改为支持异步操作的for...of循环
+- 修复跟踪器浮窗CSS样式语法错误
+- 在后端添加/tracker目录静态文件服务路由

 ## [1.1.4] - 2025-12-21

--- a/build-windows.sh
+++ b/build-windows.sh
@@ -0,0 +1,5 @@
+CGO_ENABLED=1 \
+GOOS=windows \
+GOARCH=amd64 \
+CC=gcc \
+go build  -o dns-server.exe main.go
--- a/config.json
+++ b/config.json
@@ -5,18 +5,17 @@
      "223.5.5.5:53"
    ],
    "dnssecUpstreamDNS": [
-      "117.50.10.10:53",
-      "101.226.4.6:53",
-      "218.30.118.6:53",
-      "208.67.220.220:53",
-      "208.67.222.222:53"
+      "117.50.10.10",
+      "101.226.4.6",
+      "218.30.118.6",
+      "208.67.220.220",
+      "208.67.222.222"
    ],
-    "timeout": 5000,
-    "statsFile": "data/stats.json",
-    "saveInterval": 300,
+    "timeout": 5,
+    "saveInterval": 30,
    "cacheTTL": 10,
    "enableDNSSEC": true,
-    "queryMode": "loadbalance",
+    "queryMode": "parallel",
    "domainSpecificDNS": {
      "addr.arpa": [
        "10.35.10.200:53"
@@ -35,6 +34,9 @@
      ],
      "microsoft.com": [
        "4.2.2.1:53"
+      ],
+      "steam": [
+        "4.2.2.1:53"
      ]
    },
    "noDNSSECDomains": [
@@ -42,7 +44,8 @@
      "addr.arpa",
      "amazehome.xyz",
      ".cn"
-    ]
+    ],
+    "enableIPv6": false
  },
  "http": {
    "port": 8080,
@@ -52,7 +55,6 @@
    "password": "admin"
  },
  "shield": {
-    "localRulesFile": "data/rules.txt",
    "blacklists": [
      {
        "name": "AdGuard DNS filter",
@@ -76,7 +78,7 @@
        "name": "My GitHub Rules",
        "url": "https://gitea.amazehome.xyz/AMAZEHOME/hosts-and-filters/raw/branch/main/rules/costomize.txt",
        "enabled": true,
-        "lastUpdateTime": "2025-11-29T17:05:40.283Z"
+        "lastUpdateTime": "2025-12-24T07:11:16.596Z"
      },
      {
        "name": "CNList",
@@ -114,7 +116,7 @@
        "name": "My Gitlab A/T Rules",
        "url": "http://gitea.amazehome.xyz/AMAZEHOME/hosts-and-filters/raw/branch/main/rules/ads-and-trackers.txt",
        "enabled": true,
-        "lastUpdateTime": "2025-12-18T10:38:42.344Z"
+        "lastUpdateTime": "2025-12-24T07:11:07.334Z"
      },
      {
        "name": "My Gitlab Malware List",
@@ -138,15 +140,11 @@
      }
    ],
    "updateInterval": 3600,
-    "hostsFile": "data/hosts.txt",
    "blockMethod": "NXDOMAIN",
    "customBlockIP": "",
-    "statsFile": "./data/shield_stats.json",
-    "statsSaveInterval": 60,
-    "remoteRulesCacheDir": "data/remote_rules"
+    "statsSaveInterval": 60
  },
  "log": {
-    "file": "logs/dns-server.log",
    "level": "debug",
    "maxSize": 100,
    "maxBackups": 10,
--- a/config/config.go
+++ b/config/config.go
@@ -18,13 +18,13 @@ type DNSConfig struct {
 	UpstreamDNS       []string          `json:"upstreamDNS"`
 	DNSSECUpstreamDNS []string          `json:"dnssecUpstreamDNS"` // 用于DNSSEC查询的专用服务器
 	Timeout           int               `json:"timeout"`
-	StatsFile         string            `json:"statsFile"`         // 统计数据持久化文件
 	SaveInterval      int               `json:"saveInterval"`      // 数据保存间隔（秒）
 	CacheTTL          int               `json:"cacheTTL"`          // DNS缓存过期时间（分钟）
 	EnableDNSSEC      bool              `json:"enableDNSSEC"`      // 是否启用DNSSEC支持
 	QueryMode         string            `json:"queryMode"`         // 查询模式："loadbalance"（负载均衡）、"parallel"（并行请求）、"fastest-ip"（最快的IP地址）
 	DomainSpecificDNS DomainSpecificDNS `json:"domainSpecificDNS"` // 域名特定DNS服务器配置
 	NoDNSSECDomains   []string          `json:"noDNSSECDomains"`   // 不验证DNSSEC的域名模式列表
+	EnableIPv6        bool              `json:"enableIPv6"`        // 是否启用IPv6解析（AAAA记录）
 }

 // HTTPConfig HTTP控制台配置
@@ -47,20 +47,15 @@ type BlacklistEntry struct {

 // ShieldConfig 屏蔽规则配置
 type ShieldConfig struct {
-	LocalRulesFile      string           `json:"localRulesFile"`
 	Blacklists        []BlacklistEntry `json:"blacklists"`
 	UpdateInterval    int              `json:"updateInterval"`
-	HostsFile           string           `json:"hostsFile"`
 	BlockMethod       string           `json:"blockMethod"`         // 屏蔽方法: "NXDOMAIN", "refused", "emptyIP", "customIP"
 	CustomBlockIP     string           `json:"customBlockIP"`       // 自定义屏蔽IP，当BlockMethod为"customIP"时使用
-	StatsFile           string           `json:"statsFile"`           // 计数数据持久化文件
 	StatsSaveInterval int              `json:"statsSaveInterval"`   // 计数数据保存间隔（秒）
-	RemoteRulesCacheDir string           `json:"remoteRulesCacheDir"` // 远程规则缓存目录
 }

 // LogConfig 日志配置
 type LogConfig struct {
-	File       string `json:"file"`
 	Level      string `json:"level"`
 	MaxSize    int    `json:"maxSize"`
 	MaxBackups int    `json:"maxBackups"`
@@ -98,9 +93,6 @@ func LoadConfig(path string) (*Config, error) {
 	if len(config.DNS.UpstreamDNS) == 0 {
 		config.DNS.UpstreamDNS = []string{"223.5.5.5:53", "223.6.6.6:53"}
 	}
-	if config.DNS.StatsFile == "" {
-		config.DNS.StatsFile = "./data/stats.json" // 默认统计数据文件路径
-	}
 	if config.DNS.SaveInterval == 0 {
 		config.DNS.SaveInterval = 300 // 默认5分钟保存一次
 	}
@@ -110,6 +102,8 @@ func LoadConfig(path string) (*Config, error) {
 	}
 	// DNSSEC默认配置
 	config.DNS.EnableDNSSEC = true // 默认启用DNSSEC支持
+	// IPv6默认配置
+	config.DNS.EnableIPv6 = true // 默认启用IPv6解析
 	// DNSSEC专用服务器默认配置
 	if len(config.DNS.DNSSECUpstreamDNS) == 0 {
 		config.DNS.DNSSECUpstreamDNS = []string{"8.8.8.8:53", "1.1.1.1:53"}
@@ -142,15 +136,9 @@ func LoadConfig(path string) (*Config, error) {
 	if config.Shield.BlockMethod == "" {
 		config.Shield.BlockMethod = "NXDOMAIN" // 默认屏蔽方法为NXDOMAIN
 	}
-	if config.Shield.StatsFile == "" {
-		config.Shield.StatsFile = "./data/shield_stats.json" // 默认Shield统计数据文件路径
-	}
 	if config.Shield.StatsSaveInterval == 0 {
 		config.Shield.StatsSaveInterval = 300 // 默认5分钟保存一次
 	}
-	if config.Shield.RemoteRulesCacheDir == "" {
-		config.Shield.RemoteRulesCacheDir = "./data/remote_rules" // 默认远程规则缓存目录
-	}

 	// 如果黑名单列表为空，添加一些默认的黑名单
 	if len(config.Shield.Blacklists) == 0 {
--- a/dns/server.go
+++ b/dns/server.go
@@ -22,6 +22,17 @@ import (
 	"github.com/miekg/dns"
 )

+// 确保DNS服务器地址包含端口号，默认添加53端口
+func normalizeDNSServerAddress(address string) string {
+	// 检查地址是否已经包含端口号
+	if _, _, err := net.SplitHostPort(address); err != nil {
+		// 如果没有端口号，添加默认的53端口
+		return net.JoinHostPort(address, "53")
+	}
+	// 已经有端口号，直接返回
+	return address
+}
+
 // BlockedDomain 屏蔽域名统计
 type BlockedDomain struct {
 	Domain   string
@@ -45,22 +56,31 @@ type IPGeolocation struct {
 	Expiry  time.Time `json:"expiry"`  // 缓存过期时间
 }

+// DNSAnswer DNS解析记录
+type DNSAnswer struct {
+	Type  string `json:"type"`  // 记录类型
+	Value string `json:"value"` // 记录值
+	TTL   uint32 `json:"ttl"`   // 生存时间
+}
+
 // QueryLog 查询日志记录
 type QueryLog struct {
-	Timestamp    time.Time // 查询时间
-	ClientIP     string    // 客户端IP
-	Location     string    // IP地理位置（国家 城市）
-	Domain       string    // 查询域名
-	QueryType    string    // 查询类型
-	ResponseTime int64     // 响应时间(ms)
-	Result       string    // 查询结果（allowed, blocked, error）
-	BlockRule    string    // 屏蔽规则（如果被屏蔽）
-	BlockType    string    // 屏蔽类型（如果被屏蔽）
-	FromCache    bool      // 是否来自缓存
-	DNSSEC       bool      // 是否使用了DNSSEC
-	EDNS         bool      // 是否使用了EDNS
-	DNSServer    string    // 使用的DNS服务器
-	DNSSECServer string    // 使用的DNSSEC专用服务器
+	Timestamp    time.Time   `json:"timestamp"`    // 查询时间
+	ClientIP     string      `json:"clientIP"`     // 客户端IP
+	Location     string      `json:"location"`     // IP地理位置（国家 城市）
+	Domain       string      `json:"domain"`       // 查询域名
+	QueryType    string      `json:"queryType"`    // 查询类型
+	ResponseTime int64       `json:"responseTime"` // 响应时间(ms)
+	Result       string      `json:"result"`       // 查询结果（allowed, blocked, error）
+	BlockRule    string      `json:"blockRule"`    // 屏蔽规则（如果被屏蔽）
+	BlockType    string      `json:"blockType"`    // 屏蔽类型（如果被屏蔽）
+	FromCache    bool        `json:"fromCache"`    // 是否来自缓存
+	DNSSEC       bool        `json:"dnssec"`       // 是否使用了DNSSEC
+	EDNS         bool        `json:"edns"`         // 是否使用了EDNS
+	DNSServer    string      `json:"dnsServer"`    // 使用的DNS服务器
+	DNSSECServer string      `json:"dnssecServer"` // 使用的DNSSEC专用服务器
+	Answers      []DNSAnswer `json:"answers"`      // 解析记录
+	ResponseCode int         `json:"responseCode"` // DNS响应代码
 }

 // StatsData 用于持久化的统计数据结构
@@ -348,6 +368,29 @@ func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 		s.updateStats(func(stats *Stats) {
 			stats.QueryTypes[queryType]++
 		})
+
+		// 检查是否是AAAA记录查询且IPv6解析已禁用
+		if qType == dns.TypeAAAA && !s.config.EnableIPv6 {
+			// 返回NXDOMAIN响应（域名不存在）
+			response := new(dns.Msg)
+			response.SetReply(r)
+			response.SetRcode(r, dns.RcodeNameError)
+			w.WriteMsg(response)
+
+			// 更新统计信息
+			responseTime := int64(0)
+			s.updateStats(func(stats *Stats) {
+				stats.TotalResponseTime += responseTime
+				if stats.Queries > 0 {
+					stats.AvgResponseTime = float64(stats.TotalResponseTime) / float64(stats.Queries)
+				}
+			})
+
+			// 添加查询日志
+			s.addQueryLog(sourceIP, domain, queryType, responseTime, "error", "", "", false, false, true, "", "", nil, dns.RcodeNameError)
+			logger.Debug("IPv6解析已禁用，拒绝AAAA记录查询", "domain", domain)
+			return
+		}
 	}

 	logger.Debug("接收到DNS查询", "domain", domain, "type", queryType, "client", w.RemoteAddr())
@@ -370,7 +413,7 @@ func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 		})

 		// 添加查询日志
-		s.addQueryLog(sourceIP, domain, queryType, responseTime, "error", "", "", false, false, true, "", "")
+		s.addQueryLog(sourceIP, domain, queryType, responseTime, "error", "", "", false, false, true, "", "", nil, dns.RcodeRefused)
 		return
 	}

@@ -386,8 +429,7 @@ func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 			}
 		})

-		// 添加查询日志
-		s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", false, false, true, "缓存", "无")
+		// 该方法内部未直接调用addQueryLog，而是在handleDNSRequest中处理
 		return
 	}

@@ -408,8 +450,16 @@ func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 			}
 		})

-		// 添加查询日志
-		s.addQueryLog(sourceIP, domain, queryType, responseTime, "blocked", blockRule, blockType, false, false, true, "无", "无")
+		// 添加查询日志 - 被屏蔽域名
+		blockedAnswers := []DNSAnswer{}
+		// 根据屏蔽方法确定响应代码
+		blockedRcode := dns.RcodeNameError // 默认NXDOMAIN
+		if blockMethod := s.shieldConfig.BlockMethod; blockMethod == "refused" {
+			blockedRcode = dns.RcodeRefused
+		} else if blockMethod == "emptyIP" || blockMethod == "customIP" {
+			blockedRcode = dns.RcodeSuccess
+		}
+		s.addQueryLog(sourceIP, domain, queryType, responseTime, "blocked", blockRule, blockType, false, false, true, "无", "无", blockedAnswers, blockedRcode)
 		return
 	}

@@ -481,8 +531,25 @@ func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 			})
 		}

+		// 从缓存响应中提取解析记录
+		cachedAnswers := []DNSAnswer{}
+		if cachedResponse != nil {
+			for _, rr := range cachedResponse.Answer {
+				cachedAnswers = append(cachedAnswers, DNSAnswer{
+					Type:  dns.TypeToString[rr.Header().Rrtype],
+					Value: rr.String(),
+					TTL:   rr.Header().Ttl,
+				})
+			}
+		}
+
 		// 添加查询日志 - 标记为缓存
-		s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", true, cachedDNSSEC, true, "缓存", "无")
+		// 从缓存响应中获取响应代码
+		cacheRcode := dns.RcodeSuccess // 默认成功
+		if cachedResponse != nil {
+			cacheRcode = cachedResponse.Rcode
+		}
+		s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", true, cachedDNSSEC, true, "缓存", "无", cachedAnswers, cacheRcode)
 		logger.Debug("从缓存返回DNS响应", "domain", domain, "type", queryType, "dnssec", cachedDNSSEC)
 		return
 	}
@@ -566,8 +633,25 @@ func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 		logger.Debug("DNS响应已缓存", "domain", domain, "type", queryType, "ttl", defaultCacheTTL, "dnssec", responseDNSSEC)
 	}

+	// 从响应中提取解析记录
+	responseAnswers := []DNSAnswer{}
+	if response != nil {
+		for _, rr := range response.Answer {
+			responseAnswers = append(responseAnswers, DNSAnswer{
+				Type:  dns.TypeToString[rr.Header().Rrtype],
+				Value: rr.String(),
+				TTL:   rr.Header().Ttl,
+			})
+		}
+	}
+
 	// 添加查询日志 - 标记为实时
-	s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", false, responseDNSSEC, true, dnsServer, dnssecServer)
+	// 从响应中获取响应代码
+	realRcode := dns.RcodeSuccess // 默认成功
+	if response != nil {
+		realRcode = response.Rcode
+	}
+	s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", false, responseDNSSEC, true, dnsServer, dnssecServer, responseAnswers, realRcode)
 }

 // handleHostsResponse 处理hosts文件匹配的响应
@@ -731,15 +815,36 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg

 	// 2. 如果没有匹配的域名特定配置
 	if !domainMatched {
-		// 如果启用了DNSSEC且有配置DNSSEC专用服务器，并且域名不匹配NoDNSSECDomains，则使用DNSSEC专用服务器
+		// 创建一个新的切片来存储最终的上游服务器列表
+		var finalUpstreamDNS []string
+
+		// 首先添加用户配置的上游DNS服务器
+		finalUpstreamDNS = append(finalUpstreamDNS, s.config.UpstreamDNS...)
+		logger.Debug("使用用户配置的上游DNS服务器", "servers", finalUpstreamDNS)
+
+		// 如果启用了DNSSEC且有配置DNSSEC专用服务器，并且域名不匹配NoDNSSECDomains，则将DNSSEC专用服务器添加到列表中
 		if s.config.EnableDNSSEC && len(s.config.DNSSECUpstreamDNS) > 0 && !noDNSSEC {
-			selectedUpstreamDNS = s.config.DNSSECUpstreamDNS
-			logger.Debug("使用DNSSEC专用服务器", "servers", selectedUpstreamDNS)
-		} else {
-			// 否则使用默认的上游DNS服务器
-			selectedUpstreamDNS = s.config.UpstreamDNS
+			// 合并DNSSEC专用服务器到上游服务器列表，避免重复，并确保包含端口号
+			for _, dnssecServer := range s.config.DNSSECUpstreamDNS {
+				hasDuplicate := false
+				// 确保DNSSEC服务器地址包含端口号
+				normalizedDnssecServer := normalizeDNSServerAddress(dnssecServer)
+				for _, upstream := range finalUpstreamDNS {
+					if upstream == normalizedDnssecServer {
+						hasDuplicate = true
+						break
 					}
 				}
+				if !hasDuplicate {
+					finalUpstreamDNS = append(finalUpstreamDNS, normalizedDnssecServer)
+				}
+			}
+			logger.Debug("合并DNSSEC专用服务器到上游服务器列表", "servers", finalUpstreamDNS)
+		}
+
+		// 使用最终合并后的服务器列表
+		selectedUpstreamDNS = finalUpstreamDNS
+	}

 	// 1. 首先尝试所有配置的上游DNS服务器
 	var bestResponse *dns.Msg
@@ -769,8 +874,8 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			go func(server string) {
 				defer wg.Done()

-				// 发送请求并获取响应
-				response, rtt, err := s.resolver.Exchange(r, server)
+				// 发送请求并获取响应，确保服务器地址包含端口号
+				response, rtt, err := s.resolver.Exchange(r, normalizeDNSServerAddress(server))

 				select {
 				case responses <- serverResponse{response, rtt, server, err}:
@@ -825,9 +930,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 					resp.response.AuthenticatedData = false
 				}

-				// 如果响应成功或为NXDOMAIN，根据DNSSEC状态选择最佳响应
-				if resp.response.Rcode == dns.RcodeSuccess || resp.response.Rcode == dns.RcodeNameError {
-					// 检查当前使用的服务器是否是DNSSEC专用服务器
+				// 检查当前服务器是否是DNSSEC专用服务器
 				for _, dnssecServer := range dnssecServers {
 					if dnssecServer == resp.server {
 						usedDNSSECServer = resp.server
@@ -835,30 +938,61 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 					}
 				}

+				// 检查当前服务器是否是用户配置的上游DNS服务器
+				isUserUpstream := false
+				for _, userServer := range s.config.UpstreamDNS {
+					if userServer == resp.server {
+						isUserUpstream = true
+						break
+					}
+				}
+
+				// 处理响应，优先选择用户配置的主DNS服务器
 				if resp.response.Rcode == dns.RcodeSuccess {
-						// 处理成功响应
-						// 优先选择带有DNSSEC记录的响应
-						if containsDNSSEC {
+					// 成功响应，优先使用
+					if isUserUpstream {
+						// 用户配置的主DNS服务器响应，直接设置为最佳响应
+						bestResponse = resp.response
+						bestRtt = resp.rtt
+						hasBestResponse = true
+						hasDNSSECResponse = containsDNSSEC
+						usedDNSServer = resp.server
+						logger.Debug("使用用户配置的上游服务器响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+					} else if containsDNSSEC {
+						// 非用户配置服务器，但有DNSSEC记录
+						if !hasBestResponse || !isUserUpstream {
+							// 如果还没有最佳响应，或者当前最佳响应不是用户配置的服务器，则更新
 							bestResponse = resp.response
 							bestRtt = resp.rtt
 							hasBestResponse = true
 							hasDNSSECResponse = true
 							usedDNSServer = resp.server
 							logger.Debug("找到带DNSSEC的最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
-						} else if !hasBestResponse {
-							// 没有带DNSSEC的响应时，保存第一个成功响应
+						}
+					} else {
+						// 非用户配置服务器，没有DNSSEC记录
+						if !hasBestResponse {
+							// 如果还没有最佳响应，设置为最佳响应
 							bestResponse = resp.response
 							bestRtt = resp.rtt
 							hasBestResponse = true
 							usedDNSServer = resp.server
 							logger.Debug("找到最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
 						}
+					}
 				} else if resp.response.Rcode == dns.RcodeNameError {
-						// 处理NXDOMAIN响应
-						// 如果还没有最佳响应，或者最佳响应也是NXDOMAIN，优先选择更快的NXDOMAIN响应
+					// NXDOMAIN响应
 					if !hasBestResponse || bestResponse.Rcode == dns.RcodeNameError {
-							// 如果还没有最佳响应，或者当前响应更快，更新最佳响应
-							if !hasBestResponse || resp.rtt < bestRtt {
+						// 如果还没有最佳响应，或者最佳响应也是NXDOMAIN
+						if isUserUpstream {
+							// 用户配置的服务器，直接使用
+							bestResponse = resp.response
+							bestRtt = resp.rtt
+							hasBestResponse = true
+							usedDNSServer = resp.server
+							logger.Debug("使用用户配置的上游服务器NXDOMAIN响应", "domain", domain, "server", resp.server, "rtt", resp.rtt)
+						} else if !hasBestResponse || resp.rtt < bestRtt {
+							// 非用户配置服务器，选择更快的响应
 							bestResponse = resp.response
 							bestRtt = resp.rtt
 							hasBestResponse = true
@@ -867,13 +1001,32 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 						}
 					}
 				}
-					// 保存为备选响应
+
+				// 更新备选响应，确保总有一个可用的响应
+				if resp.response != nil {
 					if !hasBackup {
+						// 第一次保存备选响应
 						backupResponse = resp.response
 						backupRtt = resp.rtt
 						hasBackup = true
+					} else {
+						// 后续响应，优先保存用户配置的服务器响应作为备选
+						if isUserUpstream {
+							backupResponse = resp.response
+							backupRtt = resp.rtt
 						}
 					}
+				}
+
+				// 即使响应不是成功或NXDOMAIN，也保存为最佳响应（如果还没有的话）
+				// 确保总有一个响应返回给客户端
+				if !hasBestResponse {
+					bestResponse = resp.response
+					bestRtt = resp.rtt
+					hasBestResponse = true
+					usedDNSServer = resp.server
+					logger.Debug("使用非成功响应作为最佳响应", "domain", domain, "server", resp.server, "rtt", resp.rtt, "rcode", resp.response.Rcode)
+				}
 			} else {
 				// 更新服务器统计信息（失败）
 				s.updateServerStats(resp.server, false, 0)
@@ -882,9 +1035,32 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg

 	case "loadbalance":
 		// 负载均衡模式 - 使用加权随机选择算法
-		// 1. 选择一个加权随机服务器
-		selectedServer := s.selectWeightedRandomServer(selectedUpstreamDNS)
-		if selectedServer != "" {
+		// 1. 尝试所有可用的服务器，直到找到一个能正常工作的
+		var triedServers []string
+		for len(triedServers) < len(selectedUpstreamDNS) {
+			// 从剩余的服务器中选择一个加权随机服务器
+			var availableServers []string
+			for _, server := range selectedUpstreamDNS {
+				found := false
+				for _, tried := range triedServers {
+					if server == tried {
+						found = true
+						break
+					}
+				}
+				if !found {
+					availableServers = append(availableServers, server)
+				}
+			}
+
+			selectedServer := s.selectWeightedRandomServer(availableServers)
+			if selectedServer == "" {
+				break
+			}
+
+			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()
@@ -897,7 +1073,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			}, 1)

 			go func() {
-				response, rtt, err := s.resolver.Exchange(r, selectedServer)
+				response, rtt, err := s.resolver.Exchange(r, normalizeDNSServerAddress(selectedServer))
 				resultChan <- struct {
 					response *dns.Msg
 					rtt      time.Duration
@@ -997,10 +1173,12 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 						backupRtt = rtt
 						hasBackup = true
 					}
+					break // 找到有效响应，退出循环
 				}
 			} else {
 				// 更新服务器统计信息（失败）
 				s.updateServerStats(selectedServer, false, 0)
+				logger.Debug("服务器请求失败，尝试下一个", "domain", domain, "server", selectedServer, "error", err)
 			}
 		}

@@ -1021,7 +1199,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			}, 1)

 			go func() {
-				resp, r, e := s.resolver.Exchange(r, fastestServer)
+				resp, r, e := s.resolver.Exchange(r, normalizeDNSServerAddress(fastestServer))
 				resultChan <- struct {
 					response *dns.Msg
 					rtt      time.Duration
@@ -1143,7 +1321,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 				defer wg.Done()

 				// 发送请求并获取响应
-				response, rtt, err := s.resolver.Exchange(r, server)
+				response, rtt, err := s.resolver.Exchange(r, normalizeDNSServerAddress(server))

 				select {
 				case responses <- serverResponse{response, rtt, server, err}:
@@ -1284,7 +1462,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 			}, 1)

 			go func() {
-				response, rtt, err := s.resolver.Exchange(r, selectedDnssecServer)
+				response, rtt, err := s.resolver.Exchange(r, normalizeDNSServerAddress(selectedDnssecServer))
 				resultChan <- struct {
 					response *dns.Msg
 					rtt      time.Duration
@@ -1382,7 +1560,7 @@ func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg
 				}, 1)

 				go func() {
-					resp, r, e := s.resolver.Exchange(r, localServer)
+					resp, r, e := s.resolver.Exchange(r, normalizeDNSServerAddress(localServer))
 					resultChan <- struct {
 						response *dns.Msg
 						rtt      time.Duration
@@ -1967,7 +2145,7 @@ func (s *Server) updateStats(update func(*Stats)) {
 }

 // addQueryLog 添加查询日志
-func (s *Server) addQueryLog(clientIP, domain, queryType string, responseTime int64, result, blockRule, blockType string, fromCache, dnssec, edns bool, dnsServer, dnssecServer string) {
+func (s *Server) addQueryLog(clientIP, domain, queryType string, responseTime int64, result, blockRule, blockType string, fromCache, dnssec, edns bool, dnsServer, dnssecServer string, answers []DNSAnswer, responseCode int) {
 	// 获取IP地理位置
 	location := s.getIpGeolocation(clientIP)

@@ -1987,6 +2165,8 @@ func (s *Server) addQueryLog(clientIP, domain, queryType string, responseTime in
 		EDNS:         edns,
 		DNSServer:    dnsServer,
 		DNSSECServer: dnssecServer,
+		Answers:      answers,
+		ResponseCode: responseCode,
 	}

 	// 添加到日志列表
@@ -2441,12 +2621,8 @@ func (s *Server) fetchIpGeolocationFromAPI(ip string) (map[string]interface{}, e

 // loadStatsData 从文件加载统计数据
 func (s *Server) loadStatsData() {
-	if s.config.StatsFile == "" {
-		return
-	}
-
 	// 检查文件是否存在
-	data, err := ioutil.ReadFile(s.config.StatsFile)
+	data, err := ioutil.ReadFile("data/stats.json")
 	if err != nil {
 		if !os.IsNotExist(err) {
 			logger.Error("读取统计数据文件失败", "error", err)
@@ -2515,14 +2691,10 @@ func (s *Server) loadStatsData() {

 // loadQueryLogs 从文件加载查询日志
 func (s *Server) loadQueryLogs() {
-	if s.config.StatsFile == "" {
-		return
-	}
-
 	// 获取绝对路径
-	statsFilePath, err := filepath.Abs(s.config.StatsFile)
+	statsFilePath, err := filepath.Abs("data/stats.json")
 	if err != nil {
-		logger.Error("获取统计文件绝对路径失败", "path", s.config.StatsFile, "error", err)
+		logger.Error("获取统计文件绝对路径失败", "path", "data/stats.json", "error", err)
 		return
 	}

@@ -2564,14 +2736,10 @@ func (s *Server) loadQueryLogs() {

 // saveStatsData 保存统计数据到文件
 func (s *Server) saveStatsData() {
-	if s.config.StatsFile == "" {
-		return
-	}
-
 	// 获取绝对路径以避免工作目录问题
-	statsFilePath, err := filepath.Abs(s.config.StatsFile)
+	statsFilePath, err := filepath.Abs("data/stats.json")
 	if err != nil {
-		logger.Error("获取统计文件绝对路径失败", "path", s.config.StatsFile, "error", err)
+		logger.Error("获取统计文件绝对路径失败", "path", "data/stats.json", "error", err)
 		return
 	}

@@ -2754,15 +2922,15 @@ func getSystemCpuUsage(prevIdle, prevTotal *uint64) (float64, error) {

 // startAutoSave 启动自动保存功能
 func (s *Server) startAutoSave() {
-	if s.config.StatsFile == "" || s.config.SaveInterval <= 0 {
+	if s.config.SaveInterval <= 0 {
 		return
 	}

-	// 设置定时器
+	// 初始化定时器
 	s.saveTicker = time.NewTicker(time.Duration(s.config.SaveInterval) * time.Second)
 	defer s.saveTicker.Stop()

-	logger.Info("启动统计数据自动保存功能", "interval", s.config.SaveInterval, "file", s.config.StatsFile)
+	logger.Info("启动统计数据自动保存功能", "interval", s.config.SaveInterval, "file", "data/stats.json")

 	// 定期保存数据
 	for {
--- a/download.sh
+++ b/download.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -e -f -u -x
+
+# This script syncs companies DB that we bundle with AdGuard Home.  The source
+# for this database is https://github.com/AdguardTeam/companiesdb.
+#
+trackers_url='https://raw.githubusercontent.com/AdguardTeam/companiesdb/main/dist/trackers.json'
+output='./trackers.json'
+readonly trackers_url output
+
+curl -o "$output" -v "$trackers_url"
--- a/http/server.go
+++ b/http/server.go
@@ -154,6 +154,17 @@ func (s *Server) Start() error {
 		http.ServeFile(w, r, "./static/login.html")
 	})

+	// Tracker目录静态文件服务
+	trackerFileServer := http.FileServer(http.Dir("./tracker"))
+	mux.HandleFunc("/tracker/", s.loginRequired(func(w http.ResponseWriter, r *http.Request) {
+		// 添加Cache-Control头，禁用浏览器缓存
+		w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		w.Header().Set("Pragma", "no-cache")
+		w.Header().Set("Expires", "Thu, 01 Jan 1970 00:00:00 GMT")
+		// 使用StripPrefix处理路径
+		http.StripPrefix("/tracker", trackerFileServer).ServeHTTP(w, r)
+	}))
+
 	// 其他静态文件需要登录
 	mux.HandleFunc("/", s.loginRequired(func(w http.ResponseWriter, r *http.Request) {
 		// 添加Cache-Control头，禁用浏览器缓存
@@ -1222,18 +1233,40 @@ func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
 	case http.MethodGet:
 		// 返回当前配置（包括黑名单配置）
 		config := map[string]interface{}{
-			"shield": map[string]interface{}{
+			"Shield": map[string]interface{}{
 				"blockMethod":    s.globalConfig.Shield.BlockMethod,
 				"customBlockIP":  s.globalConfig.Shield.CustomBlockIP,
 				"blacklists":     s.globalConfig.Shield.Blacklists,
 				"updateInterval": s.globalConfig.Shield.UpdateInterval,
 			},
+			"DNSServer": map[string]interface{}{
+				"port":                  s.globalConfig.DNS.Port,
+				"UpstreamServers":       s.globalConfig.DNS.UpstreamDNS,
+				"DNSSECUpstreamServers": s.globalConfig.DNS.DNSSECUpstreamDNS,
+				"timeout":               s.globalConfig.DNS.Timeout,
+				"saveInterval":          s.globalConfig.DNS.SaveInterval,
+				"enableIPv6":            s.globalConfig.DNS.EnableIPv6,
+			},
+			"HTTPServer": map[string]interface{}{
+				"port": s.globalConfig.HTTP.Port,
+			},
 		}
 		json.NewEncoder(w).Encode(config)

 	case http.MethodPost:
 		// 更新配置
 		var req struct {
+			DNSServer struct {
+				Port                  int      `json:"port"`
+				UpstreamServers       []string `json:"upstreamServers"`
+				DnssecUpstreamServers []string `json:"dnssecUpstreamServers"`
+				Timeout               int      `json:"timeout"`
+				SaveInterval          int      `json:"saveInterval"`
+				EnableIPv6            bool     `json:"enableIPv6"`
+			} `json:"dnsserver"`
+			HTTPServer struct {
+				Port int `json:"port"`
+			} `json:"httpserver"`
 			Shield struct {
 				BlockMethod    string                  `json:"blockMethod"`
 				CustomBlockIP  string                  `json:"customBlockIP"`
@@ -1247,6 +1280,29 @@ func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
 			return
 		}

+		// 更新DNS配置
+		if req.DNSServer.Port > 0 {
+			s.globalConfig.DNS.Port = req.DNSServer.Port
+		}
+		if len(req.DNSServer.UpstreamServers) > 0 {
+			s.globalConfig.DNS.UpstreamDNS = req.DNSServer.UpstreamServers
+		}
+		if len(req.DNSServer.DnssecUpstreamServers) > 0 {
+			s.globalConfig.DNS.DNSSECUpstreamDNS = req.DNSServer.DnssecUpstreamServers
+		}
+		if req.DNSServer.Timeout > 0 {
+			s.globalConfig.DNS.Timeout = req.DNSServer.Timeout
+		}
+		if req.DNSServer.SaveInterval > 0 {
+			s.globalConfig.DNS.SaveInterval = req.DNSServer.SaveInterval
+		}
+		s.globalConfig.DNS.EnableIPv6 = req.DNSServer.EnableIPv6
+
+		// 更新HTTP配置
+		if req.HTTPServer.Port > 0 {
+			s.globalConfig.HTTP.Port = req.HTTPServer.Port
+		}
+
 		// 更新屏蔽配置
 		if req.Shield.BlockMethod != "" {
 			// 验证屏蔽方法是否有效
--- a/main.go
+++ b/main.go
@@ -42,7 +42,6 @@ func createDefaultConfig(configFile string) error {
      "1.1.1.1:53"
    ],
    "timeout": 5000,
-    "statsFile": "./data/stats.json",
    "saveInterval": 300,
    "cacheTTL": 30,
    "enableDNSSEC": true,
@@ -56,7 +55,6 @@ func createDefaultConfig(configFile string) error {
    "password": "admin"
  },
  "shield": {
-    "localRulesFile": "data/rules.txt",
    "blacklists": [
      {
        "name": "AdGuard DNS filter",
@@ -80,15 +78,11 @@ func createDefaultConfig(configFile string) error {
      }
    ],
    "updateInterval": 3600,
-    "hostsFile": "data/hosts.txt",
    "blockMethod": "NXDOMAIN",
    "customBlockIP": "",
-    "statsFile": "./data/shield_stats.json",
-    "statsSaveInterval": 60,
-    "remoteRulesCacheDir": "./data/remote_rules"
+    "statsSaveInterval": 60
  },
  "log": {
-    "file": "logs/dns-server.log",
    "level": "debug",
    "maxSize": 100,
    "maxBackups": 10,
@@ -109,12 +103,12 @@ func createRequiredFiles(cfg *config.Config) error {
 	}

 	// 创建远程规则缓存文件夹
-	if err := os.MkdirAll(cfg.Shield.RemoteRulesCacheDir, 0755); err != nil {
+	if err := os.MkdirAll("data/remote_rules", 0755); err != nil {
 		return fmt.Errorf("创建远程规则缓存文件夹失败: %w", err)
 	}

 	// 创建日志文件夹
-	logDir := filepath.Dir(cfg.Log.File)
+	logDir := filepath.Dir("logs/dns-server.log")
 	if logDir != "." {
 		if err := os.MkdirAll(logDir, 0755); err != nil {
 			return fmt.Errorf("创建日志文件夹失败: %w", err)
@@ -122,29 +116,29 @@ func createRequiredFiles(cfg *config.Config) error {
 	}

 	// 创建自定义规则文件
-	if _, err := os.Stat(cfg.Shield.LocalRulesFile); os.IsNotExist(err) {
-		if err := os.WriteFile(cfg.Shield.LocalRulesFile, []byte("# 自定义规则文件\n# 格式：域名\n# 例如：example.com\n"), 0644); err != nil {
+	if _, err := os.Stat("data/rules.txt"); os.IsNotExist(err) {
+		if err := os.WriteFile("data/rules.txt", []byte("# 自定义规则文件\n# 格式：域名\n# 例如：example.com\n"), 0644); err != nil {
 			return fmt.Errorf("创建自定义规则文件失败: %w", err)
 		}
 	}

 	// 创建Hosts文件
-	if _, err := os.Stat(cfg.Shield.HostsFile); os.IsNotExist(err) {
-		if err := os.WriteFile(cfg.Shield.HostsFile, []byte("# Hosts文件\n# 格式：IP 域名\n# 例如：127.0.0.1 localhost\n"), 0644); err != nil {
+	if _, err := os.Stat("data/hosts.txt"); os.IsNotExist(err) {
+		if err := os.WriteFile("data/hosts.txt", []byte("# Hosts文件\n# 格式：IP 域名\n# 例如：127.0.0.1 localhost\n"), 0644); err != nil {
 			return fmt.Errorf("创建Hosts文件失败: %w", err)
 		}
 	}

 	// 创建统计数据文件
-	if _, err := os.Stat(cfg.DNS.StatsFile); os.IsNotExist(err) {
-		if err := os.WriteFile(cfg.DNS.StatsFile, []byte("{}"), 0644); err != nil {
+	if _, err := os.Stat("data/stats.json"); os.IsNotExist(err) {
+		if err := os.WriteFile("data/stats.json", []byte("{}"), 0644); err != nil {
 			return fmt.Errorf("创建统计数据文件失败: %w", err)
 		}
 	}

 	// 创建Shield统计数据文件
-	if _, err := os.Stat(cfg.Shield.StatsFile); os.IsNotExist(err) {
-		if err := os.WriteFile(cfg.Shield.StatsFile, []byte("{}"), 0644); err != nil {
+	if _, err := os.Stat("data/shield_stats.json"); os.IsNotExist(err) {
+		if err := os.WriteFile("data/shield_stats.json", []byte("{}"), 0644); err != nil {
 			return fmt.Errorf("创建Shield统计数据文件失败: %w", err)
 		}
 	}
@@ -183,7 +177,7 @@ func main() {
 	log.Println("所需文件和文件夹创建成功")

 	// 初始化日志系统
-	if err := logger.InitLogger(cfg.Log.File, cfg.Log.Level, 0, 0, 0, false); err != nil {
+	if err := logger.InitLogger("logs/dns-server.log", cfg.Log.Level, 0, 0, 0, false); err != nil {
 		log.Fatalf("初始化日志系统失败: %v", err)
 	}
 	defer logger.Close()
--- a/server.log
+++ b/server.log
--- a/server.pid
+++ b/server.pid
@@ -1 +0,0 @@
-132708
--- a/shield/manager.go
+++ b/shield/manager.go
@@ -134,11 +134,7 @@ func (m *ShieldManager) LoadRules() error {

 // loadLocalRules 加载自定义规则文件
 func (m *ShieldManager) loadLocalRules() error {
-	if m.config.LocalRulesFile == "" {
-		return nil
-	}
-
-	file, err := os.Open(m.config.LocalRulesFile)
+	file, err := os.Open("data/rules.txt")
 	if err != nil {
 		return err
 	}
@@ -183,7 +179,7 @@ func (m *ShieldManager) getCacheFilePath(url string) string {
 	// 简单处理，移除特殊字符，确保文件名合法
 	hash = strings.ReplaceAll(hash, "/", "_")
 	hash = strings.ReplaceAll(hash, "\\", "_")
-	return filepath.Join(m.config.RemoteRulesCacheDir, hash+".rules")
+	return filepath.Join("data/remote_rules", hash+".rules")
 }

 // shouldUpdateCache 检查缓存是否需要更新
@@ -298,7 +294,7 @@ func (m *ShieldManager) loadCachedRules(filePath string, source string) error {
 // saveRemoteRulesToCache 保存远程规则到缓存文件
 func (m *ShieldManager) saveRemoteRulesToCache(filePath string, data []byte) error {
 	// 确保缓存目录存在
-	if err := os.MkdirAll(m.config.RemoteRulesCacheDir, 0755); err != nil {
+	if err := os.MkdirAll("data/remote_rules", 0755); err != nil {
 		return err
 	}

@@ -308,11 +304,7 @@ func (m *ShieldManager) saveRemoteRulesToCache(filePath string, data []byte) err

 // loadHosts 加载hosts文件
 func (m *ShieldManager) loadHosts() error {
-	if m.config.HostsFile == "" {
-		return nil
-	}
-
-	file, err := os.Open(m.config.HostsFile)
+	file, err := os.Open("data/hosts.txt")
 	if err != nil {
 		return err
 	}
@@ -827,12 +819,10 @@ func (m *ShieldManager) AddRule(rule string) error {
 	m.parseRule(rule, true, "自定义规则")

 	// 持久化保存规则到文件
-	if m.config.LocalRulesFile != "" {
 	if err := m.saveRulesToFile(); err != nil {
 		logger.Error("保存规则到文件失败", "error", err)
 		return err
 	}
-	}

 	return nil
 }
@@ -996,7 +986,7 @@ func (m *ShieldManager) RemoveRule(rule string) error {
 	}

 	// 如果有规则被删除，持久化保存更改
-	if removed && m.config.LocalRulesFile != "" {
+	if removed {
 		if err := m.saveRulesToFile(); err != nil {
 			logger.Error("保存规则到文件失败", "error", err)
 			return err
@@ -1087,7 +1077,7 @@ func (m *ShieldManager) saveRulesToFile() error {

 	// 写入文件
 	content := strings.Join(rules, "\n")
-	return ioutil.WriteFile(m.config.LocalRulesFile, []byte(content), 0644)
+	return ioutil.WriteFile("data/rules.txt", []byte(content), 0644)
 }

 // AddHostsEntry 添加hosts条目
@@ -1098,12 +1088,10 @@ func (m *ShieldManager) AddHostsEntry(ip, domain string) error {
 	m.hostsMap[domain] = ip

 	// 持久化保存到hosts文件
-	if m.config.HostsFile != "" {
 	if err := m.saveHostsToFile(); err != nil {
 		logger.Error("保存hosts到文件失败", "error", err)
 		return err
 	}
-	}

 	return nil
 }
@@ -1117,13 +1105,11 @@ func (m *ShieldManager) RemoveHostsEntry(domain string) error {
 		delete(m.hostsMap, domain)

 		// 持久化保存到hosts文件
-		if m.config.HostsFile != "" {
 		if err := m.saveHostsToFile(); err != nil {
 			logger.Error("保存hosts到文件失败", "error", err)
 			return err
 		}
 	}
-	}

 	return nil
 }
@@ -1151,7 +1137,7 @@ func (m *ShieldManager) saveHostsToFile() error {

 	// 写入文件
 	content := strings.Join(lines, "\n")
-	return ioutil.WriteFile(m.config.HostsFile, []byte(content), 0644)
+	return ioutil.WriteFile("data/hosts.txt", []byte(content), 0644)
 }

 // GetStats 获取规则统计信息
@@ -1171,15 +1157,10 @@ func (m *ShieldManager) GetStats() map[string]interface{} {

 // loadStatsData 从文件加载计数数据
 func (m *ShieldManager) loadStatsData() {
-	if m.config.StatsFile == "" {
-		logger.Info("Shield统计文件路径未配置，跳过加载")
-		return
-	}
-
 	// 获取绝对路径以避免工作目录问题
-	statsFilePath, err := filepath.Abs(m.config.StatsFile)
+	statsFilePath, err := filepath.Abs("data/shield_stats.json")
 	if err != nil {
-		logger.Error("获取Shield统计文件绝对路径失败", "path", m.config.StatsFile, "error", err)
+		logger.Error("获取Shield统计文件绝对路径失败", "path", "data/shield_stats.json", "error", err)
 		return
 	}
 	logger.Debug("尝试加载Shield统计数据", "file", statsFilePath)
@@ -1271,15 +1252,10 @@ func (m *ShieldManager) loadStatsData() {

 // saveStatsData 保存计数数据到文件
 func (m *ShieldManager) saveStatsData() {
-	if m.config.StatsFile == "" {
-		logger.Debug("Shield统计文件路径未配置，跳过保存")
-		return
-	}
-
 	// 获取绝对路径以避免工作目录问题
-	statsFilePath, err := filepath.Abs(m.config.StatsFile)
+	statsFilePath, err := filepath.Abs("data/shield_stats.json")
 	if err != nil {
-		logger.Error("获取Shield统计文件绝对路径失败", "path", m.config.StatsFile, "error", err)
+		logger.Error("获取Shield统计文件绝对路径失败", "path", "data/shield_stats.json", "error", err)
 		return
 	}

@@ -1337,14 +1313,14 @@ func (m *ShieldManager) saveStatsData() {

 // startAutoSaveStats 启动计数数据自动保存功能
 func (m *ShieldManager) startAutoSaveStats() {
-	if m.config.StatsFile == "" || m.config.StatsSaveInterval <= 0 {
+	if m.config.StatsSaveInterval <= 0 {
 		return
 	}

 	ticker := time.NewTicker(time.Duration(m.config.StatsSaveInterval) * time.Second)
 	defer ticker.Stop()

-	logger.Info("启动Shield计数数据自动保存功能", "interval", m.config.StatsSaveInterval, "file", m.config.StatsFile)
+	logger.Info("启动Shield计数数据自动保存功能", "interval", m.config.StatsSaveInterval, "file", "data/shield_stats.json")

 	// 定期保存数据
 	for {
--- a/static/api/js/index.js
+++ b/static/api/js/index.js
@@ -4,7 +4,7 @@
            "info": {
                "title": "DNS Server API",
                "description": "DNS服务器完整API文档，包括统计信息、Shield管理、主机管理等功能。",
-                "version": "1.1.0",
+                "version": "1.2.5",
                "contact": {
                    "name": "DNS Server 支持",
                    "email": "support@dnsserver.com"
@@ -713,6 +713,7 @@
                    "get": {
                        "summary": "获取Shield配置和统计信息",
                        "description": "获取Shield的配置信息和规则统计，包括更新间隔、屏蔽方法、黑名单数量等。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "responses": {
                            "200": {
@@ -764,6 +765,7 @@
                    "post": {
                        "summary": "添加屏蔽规则",
                        "description": "添加新的屏蔽规则到Shield。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "requestBody": {
                            "required": true,
@@ -829,6 +831,7 @@
                    "delete": {
                        "summary": "删除屏蔽规则",
                        "description": "从Shield中删除指定的屏蔽规则。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "requestBody": {
                            "required": true,
@@ -894,6 +897,7 @@
                    "put": {
                        "summary": "重新加载规则",
                        "description": "重新加载和应用Shield规则。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "responses": {
                            "200": {
@@ -934,7 +938,8 @@
                "/shield/blacklists": {
                    "get": {
                        "summary": "获取黑名单列表",
-                        "description": "获取所有远程黑名单的列表及详细信息。",
+                        "description": "获取Shield的黑名单列表，包括内置黑名单和自定义黑名单。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "responses": {
                            "200": {
@@ -986,7 +991,8 @@
                    },
                    "post": {
                        "summary": "添加黑名单",
-                        "description": "添加新的远程黑名单URL。",
+                        "description": "添加新的黑名单URL到Shield。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "requestBody": {
                            "required": true,
@@ -1057,6 +1063,7 @@
                    "put": {
                        "summary": "更新黑名单列表（包括启用/禁用状态）",
                        "description": "更新黑名单列表（包括启用/禁用状态）。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "requestBody": {
                            "required": true,
@@ -1139,7 +1146,8 @@
                "/shield/localrules": {
                    "get": {
                        "summary": "获取自定义规则",
-                        "description": "获取Shield的自定义规则列表。"
+                        "description": "获取Shield的自定义规则列表。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "responses": {
                            "200": {
@@ -1168,6 +1176,7 @@
                    "post": {
                        "summary": "添加自定义规则",
                        "description": "添加新的自定义规则。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "requestBody": {
                            "required": true,
@@ -1206,7 +1215,8 @@
                    },
                    "delete": {
                        "summary": "删除自定义规则",
-                        "description": "删除指定ID的自定义规则。",
+                        "description": "删除指定的自定义规则。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "parameters": [
                            {
@@ -1239,8 +1249,9 @@
                },
                "/shield/remoterules": {
                    "get": {
-                        "summary": "获取远程规则",
-                        "description": "获取Shield的远程规则列表。",
+                        "summary": "获取远程规则状态",
+                        "description": "获取远程规则的更新状态和版本信息。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "responses": {
                            "200": {
@@ -1269,8 +1280,9 @@
                },
                "/shield/hosts": {
                    "get": {
-                        "summary": "获取hosts列表",
-                        "description": "获取所有hosts记录。",
+                        "summary": "获取hosts内容",
+                        "description": "获取当前的hosts文件内容。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "responses": {
                            "200": {
@@ -1298,6 +1310,7 @@
                    "post": {
                        "summary": "添加hosts记录",
                        "description": "添加新的hosts记录。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "requestBody": {
                            "required": true,
@@ -1366,6 +1379,7 @@
                    "delete": {
                        "summary": "删除hosts记录",
                        "description": "删除指定域名的hosts记录。",
+                        "deprecated": false,
                        "tags": ["shield"],
                        "parameters": [
                            {
@@ -1424,25 +1438,13 @@
                        }
                    }
                },
-                "/query": {
-                    "get": {
-                        "summary": "检查域名是否被屏蔽",
-                        "description": "检查指定域名是否被Shield屏蔽，并返回详细的屏蔽信息，包括屏蔽规则、规则类型、来源等。",
-                        "tags": ["shield"],
-                        "parameters": [
-                            {
-                                "name": "domain",
-                                "in": "query",
+                "/dns/query": {
+                    "post": {
+                        "summary": "查询DNS记录",
+                        "description": "查询指定域名的DNS记录，可以指定记录类型。",
+                        "tags": ["dns"],
+                        "requestBody": {
                            "required": true,
-                                "schema": {
-                                    "type": "string"
-                                },
-                                "description": "要检查的域名"
-                            }
-                        ],
-                        "responses": {
-                            "200": {
-                                "description": "成功获取域名屏蔽信息",
                            "content": {
                                "application/json": {
                                    "schema": {
@@ -1450,67 +1452,58 @@
                                        "properties": {
                                            "domain": {
                                                "type": "string",
-                                                    "description": "检查的域名"
+                                                "description": "要查询的域名"
                                            },
-                                                "blocked": {
-                                                    "type": "boolean",
-                                                    "description": "是否被屏蔽"
-                                                },
-                                                "blockRule": {
+                                            "recordType": {
                                                "type": "string",
-                                                    "description": "屏蔽规则"
-                                                },
-                                                "blockRuleType": {
-                                                    "type": "string",
-                                                    "description": "屏蔽规则类型"
-                                                },
-                                                "blocksource": {
-                                                    "type": "string",
-                                                    "description": "屏蔽规则来源"
-                                                },
-                                                "excluded": {
-                                                    "type": "boolean",
-                                                    "description": "是否被排除"
-                                                },
-                                                "excludeRule": {
-                                                    "type": "string",
-                                                    "description": "排除规则"
-                                                },
-                                                "excludeRuleType": {
-                                                    "type": "string",
-                                                    "description": "排除规则类型"
-                                                },
-                                                "hasHosts": {
-                                                    "type": "boolean",
-                                                    "description": "是否有hosts记录"
-                                                },
-                                                "hostsIP": {
-                                                    "type": "string",
-                                                    "description": "hosts记录中的IP"
-                                                },
-                                                "timestamp": {
-                                                    "type": "string",
-                                                    "format": "date-time",
-                                                    "description": "查询时间戳"
-                                                }
+                                                "description": "DNS记录类型（如A、AAAA、MX、NS等）"
                                            }
                                        },
+                                        "required": ["domain"]
+                                    },
                                    "example": {
                                        "domain": "example.com",
-                                            "blocked": true,
-                                            "blockRule": "example.com",
-                                            "blockRuleType": "exact_domain",
-                                            "blocksource": "自定义规则",
-                                            "excluded": false,
-                                            "excludeRule": "",
-                                            "excludeRuleType": "",
-                                            "hasHosts": false,
-                                            "hostsIP": "",
-                                            "timestamp": "2023-07-15T14:30:45Z"
+                                        "recordType": "A"
                                    }
                                }
                            }
                        },
+                        "responses": {
+                            "200": {
+                                "description": "成功获取DNS记录",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "array",
+                                            "items": {
+                                                "type": "object",
+                                                "properties": {
+                                                    "Type": {
+                                                        "type": "string",
+                                                        "description": "DNS记录类型"
+                                                    },
+                                                    "Value": {
+                                                        "type": "string",
+                                                        "description": "DNS记录值"
+                                                    },
+                                                    "TTL": {
+                                                        "type": "integer",
+                                                        "description": "生存时间"
+                                                    },
+                                                    "Preference": {
+                                                        "type": "integer",
+                                                        "description": "MX记录优先级"
+                                                    }
+                                                }
+                                            }
+                                        },
+                                        "example": [
+                                            {"Type": "A", "Value": "93.184.216.34", "TTL": 172800},
+                                            {"Type": "A", "Value": "93.184.216.35", "TTL": 172800}
+                                        ]
+                                    }
+                                }
+                            },
                            "400": {
                                "description": "请求参数错误",
                                "content": {
--- a/static/css/style.css
+++ b/static/css/style.css
@@ -1064,3 +1064,94 @@ tr:hover {
    display: flex;
    gap: 0.5rem;
 }
+
+/* 跟踪器状态图标容器 */
+.tracker-icon-container {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    cursor: help;
+}
+
+/* 跟踪器浮窗样式 */
+.tracker-tooltip {
+    position: absolute;
+    top: -10px;
+    left: 100%;
+    margin-left: 10px;
+    background-color: white;
+    border: 1px solid #e2e8f0;
+    border-radius: 8px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    padding: 12px;
+    min-width: 250px;
+    z-index: 50;
+    font-size: 14px;
+    color: #333;
+    /* 添加箭头 */
+}
+
+/* 浮窗箭头 */
+.tracker-tooltip::before {
+    content: '';
+    position: absolute;
+    top: 15px;
+    left: -10px;
+    width: 0;
+    height: 0;
+    border-top: 10px solid transparent;
+    border-bottom: 10px solid transparent;
+    border-right: 10px solid white;
+}
+
+.tracker-tooltip::after {
+    content: '';
+    position: absolute;
+    top: 15px;
+    left: -11px;
+    width: 0;
+    height: 0;
+    border-top: 10px solid transparent;
+    border-bottom: 10px solid transparent;
+    border-right: 10px solid #e2e8f0;
+    z-index: -1;
+}
+
+/* 浮窗标题 */
+.tracker-tooltip .font-semibold {
+    font-weight: 600;
+    color: #2d3748;
+    margin-bottom: 8px;
+}
+
+/* 搜索框样式优化 */
+#logs-search {
+    /* 确保搜索框在所有设备上都有合适的宽度 */
+    max-width: 100%;
+    box-sizing: border-box;
+}
+
+/* 在移动设备上进一步优化搜索框 */
+@media (max-width: 768px) {
+    /* 确保搜索框在移动设备上占满宽度 */
+    #logs-search {
+        width: 100%;
+        padding: 0.5rem;
+        font-size: 0.9rem;
+    }
+}
+
+/* 浮窗内容项 */
+.tracker-tooltip > div {
+    margin-bottom: 6px;
+}
+
+/* 浮窗链接样式 */
+.tracker-tooltip a {
+    color: #3182ce;
+    text-decoration: none;
+}
+
+.tracker-tooltip a:hover {
+    text-decoration: underline;
+}
--- a/static/index.html
+++ b/static/index.html
@@ -18,9 +18,67 @@
 <body class="bg-gray-50 text-dark font-sans">
    <div class="flex h-screen overflow-hidden">
        <!-- 侧边栏 -->
-        <aside id="sidebar" class="fixed inset-y-0 left-0 w-64 bg-white border-r border-gray-200 flex flex-col transition-transform duration-300 z-50 md:relative md:translate-x-0 -translate-x-full shadow-lg">
+        <aside id="sidebar" class="fixed inset-y-0 left-0 w-64 bg-white border-r border-gray-200 flex flex-col transition-transform duration-300 z-50 hidden md:flex">
+            <!-- Logo -->
+            <div class="flex items-center justify-center h-16 border-b border-gray-200">
+                <i class="fa fa-server text-3xl text-primary mr-3"></i>
+                <h1 class="text-xl font-bold text-primary">DNS 控制台</h1>
+            </div>
+            
+            <!-- 菜单 -->
+            <nav class="flex-1 overflow-y-auto p-4">
+                <ul class="space-y-1">
+                    <li>
+                        <a href="#dashboard" class="flex items-center px-4 py-3 text-gray-700 hover:bg-gray-100 rounded-md transition-all sidebar-item-active">
+                            <i class="fa fa-tachometer mr-3 text-lg"></i>
+                            <span>仪表盘</span>
+                        </a>
+                    </li>
+                    <li>
+                        <a href="#shield" class="flex items-center px-4 py-3 text-gray-700 hover:bg-gray-100 rounded-md transition-all">
+                            <i class="fa fa-shield mr-3 text-lg"></i>
+                            <span>屏蔽管理</span>
+                        </a>
+                    </li>
+                    <li>
+                        <a href="#hosts" class="flex items-center px-4 py-3 text-gray-700 hover:bg-gray-100 rounded-md transition-all">
+                            <i class="fa fa-file-text mr-3 text-lg"></i>
+                            <span>Hosts管理</span>
+                        </a>
+                    </li>
+
+                    <li>
+                        <a href="#query" class="flex items-center px-4 py-3 text-gray-700 hover:bg-gray-100 rounded-md transition-all">
+                            <i class="fa fa-search mr-3 text-lg"></i>
+                            <span>DNS屏蔽查询</span>
+                        </a>
+                    </li>
+                    <li>
+                        <a href="#logs" class="flex items-center px-4 py-3 text-gray-700 hover:bg-gray-100 rounded-md transition-all">
+                            <i class="fa fa-file-text-o mr-3 text-lg"></i>
+                            <span>查询日志</span>
+                        </a>
+                    </li>
+                    <li>
+                        <a href="#config" class="flex items-center px-4 py-3 text-gray-700 hover:bg-gray-100 rounded-md transition-all">
+                            <i class="fa fa-cog mr-3 text-lg"></i>
+                            <span>系统设置</span>
+                        </a>
+                    </li>
+                </ul>
+            </nav>
+            
+            <!-- 底部信息 -->
+            <div class="p-4 border-t border-gray-200 text-center text-gray-500 text-sm">
+                <p>DNS服务器 v1.2.0</p>
+                <p class="mt-1" id="uptime">正常运行中</p>
+            </div>
+        </aside>
+        
+        <!-- 移动端侧边栏 -->
+        <aside id="mobile-sidebar" class="fixed inset-y-0 left-0 w-64 bg-white border-r border-gray-200 flex flex-col transition-transform duration-300 z-50 -translate-x-full md:hidden">
            <!-- 移动端关闭按钮 -->
-            <div class="absolute top-4 right-4 md:hidden">
+            <div class="absolute top-4 right-4">
                <button id="close-sidebar" class="p-2 text-gray-500 hover:text-gray-700 focus:outline-none">
                    <i class="fa fa-times text-xl"></i>
                </button>
@@ -76,7 +134,7 @@
            
            <!-- 底部信息 -->
            <div class="p-4 border-t border-gray-200 text-center text-gray-500 text-sm">
-                <p>DNS服务器 v1.0.0</p>
+                <p>DNS服务器 v1.2.0</p>
                <p class="mt-1" id="uptime">正常运行中</p>
            </div>
        </aside>
@@ -85,9 +143,9 @@
        <div id="sidebar-overlay" class="fixed inset-0 bg-black bg-opacity-50 z-40 hidden md:hidden"></div>
        
        <!-- 主内容区 -->
-        <main class="flex-1 overflow-y-auto">
+        <main class="flex-1 flex flex-col md:ml-64">
            <!-- 顶部导航栏 -->
-            <header class="bg-white border-b border-gray-200 h-16 flex items-center justify-between px-6">
+            <header class="bg-white border-b border-gray-200 h-16 flex items-center justify-between px-6 sticky top-0 z-30">
                <div class="flex items-center">
                    <button id="toggle-sidebar" class="block md:hidden text-gray-500 hover:text-gray-700 focus:outline-none">
                        <i class="fa fa-bars text-xl"></i>
@@ -96,55 +154,6 @@
                </div>
                
                <div class="flex items-center space-x-4">
-                    <!-- 服务器状态组件 -->
-                    <div class="relative bg-white rounded-lg shadow-md px-3 py-2 flex items-center space-x-2 server-status-widget md:min-w-[300px] sm:min-w-[250px] min-w-[180px]" id="server-status-widget">
-                        <div class="flex flex-col">
-                            <div class="flex items-center">
-                                <span class="text-xs font-medium text-gray-500">CPU</span>
-                                <span id="server-cpu-value" class="ml-2 text-sm font-semibold">0%</span>
-                            </div>
-                            <div class="w-16 h-1 bg-gray-100 rounded-full mt-1">
-                                <div id="server-cpu-bar" class="h-full bg-warning rounded-full" style="width: 0%"></div>
-                            </div>
-                        </div>
-                        <div class="w-1 h-8 bg-gray-200 rounded-full mx-1"></div>
-                        <div class="flex flex-col">
-                            <div class="flex items-center">
-                                <span class="text-xs font-medium text-gray-500">查询</span>
-                                <span id="server-queries-value" class="ml-2 text-sm font-semibold">0</span>
-                            </div>
-                            <div class="w-16 h-1 bg-gray-100 rounded-full mt-1">
-                                <div id="server-queries-bar" class="h-full bg-primary rounded-full" style="width: 0%"></div>
-                            </div>
-                        </div>
-                        <!-- 额外指标区域 - 初始隐藏，只在非首页显示 -->
-                        <div id="server-additional-stats" class="hidden md:flex items-center">
-                            <div class="w-1 h-8 bg-gray-200 rounded-full mx-1"></div>
-                            <div class="flex flex-col">
-                                <div class="flex items-center">
-                                    <span class="text-xs font-medium text-gray-500">总量</span>
-                                    <span id="server-total-queries" class="ml-2 text-sm font-semibold">0</span>
-                                </div>
-                            </div>
-                            <div class="w-1 h-8 bg-gray-200 rounded-full mx-1"></div>
-                            <div class="flex flex-col">
-                                <div class="flex items-center">
-                                    <span class="text-xs font-medium text-gray-500">屏蔽</span>
-                                    <span id="server-blocked-queries" class="ml-2 text-sm font-semibold">0</span>
-                                </div>
-                            </div>
-                            <div class="w-1 h-8 bg-gray-200 rounded-full mx-1"></div>
-                            <div class="flex flex-col">
-                                <div class="flex items-center">
-                                    <span class="text-xs font-medium text-gray-500">正常</span>
-                                    <span id="server-allowed-queries" class="ml-2 text-sm font-semibold">0</span>
-                                </div>
-                            </div>
-                        </div>
-                        <div class="absolute top-1 right-1">
-                            <span id="server-status-indicator" class="inline-block w-2 h-2 bg-success rounded-full"></span>
-                        </div>
-                    </div>
                    
                    <button class="p-2 text-gray-500 hover:text-gray-700 rounded-full hover:bg-gray-100">
                        <i class="fa fa-bell text-lg"></i>
@@ -170,7 +179,7 @@
            </header>
            
            <!-- 页面内容 -->
-            <div class="p-6">
+            <div class="p-6 overflow-y-auto flex-1">
                <!-- 仪表盘部分 -->
                <div id="dashboard-content" class="space-y-6">
                    <!-- 统计卡片 -->
@@ -975,13 +984,12 @@
                            </div>
                        </th>
                        <th class="text-left py-3 px-4 text-sm font-medium text-gray-500">响应时间</th>
-                        <th class="text-left py-3 px-4 text-sm font-medium text-gray-500">屏蔽规则</th>
                        <th class="text-center py-3 px-4 text-sm font-medium text-gray-500">操作</th>
                    </tr>
                </thead>
                <tbody id="logs-table-body">
                    <tr>
-                        <td colspan="6" class="py-8 text-center text-gray-500 border-b border-gray-100">
+                        <td colspan="5" class="py-8 text-center text-gray-500 border-b border-gray-100">
                            <i class="fa fa-file-text-o text-4xl mb-2 text-gray-300"></i>
                            <div>暂无查询日志</div>
                        </td>
@@ -995,6 +1003,24 @@
                            <div class="text-sm text-gray-500">
                                显示 <span id="logs-current-page">1</span> / <span id="logs-total-pages">1</span> 页
                            </div>
+                            <div class="flex items-center space-x-4">
+                                <div class="flex items-center space-x-2">
+                                    <span class="text-sm text-gray-500">每页显示:</span>
+                                    <select id="logs-per-page" class="px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent">
+                                        <option value="10">10条</option>
+                                        <option value="20">20条</option>
+                                        <option value="30" selected>30条</option>
+                                        <option value="50">50条</option>
+                                        <option value="100">100条</option>
+                                    </select>
+                                </div>
+                                <div class="flex items-center space-x-2">
+                                    <span class="text-sm text-gray-500">页码:</span>
+                                    <input type="number" id="logs-page-input" min="1" max="1" value="1" class="w-16 px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-center">
+                                    <button id="logs-go-page" class="px-4 py-2 bg-primary text-white rounded-md hover:bg-primary/90 transition-colors">
+                                        前往
+                                    </button>
+                                </div>
                                <div class="flex space-x-2">
                                    <button id="logs-prev-page" class="px-4 py-2 border border-gray-300 rounded-md text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-gray-500 focus:border-transparent" disabled>
                                        <i class="fa fa-chevron-left"></i>
@@ -1006,6 +1032,7 @@
                            </div>
                        </div>
                    </div>
+                </div>
                
                <div id="config-content" class="hidden">
                    <!-- 系统设置页面内容 -->
@@ -1031,13 +1058,19 @@
                                        <input type="text" id="dns-upstream-servers" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="8.8.8.8, 1.1.1.1">
                                    </div>
                                    <div>
-                                        <label for="dns-stats-file" class="block text-sm font-medium text-gray-700 mb-1">统计文件路径</label>
-                                        <input type="text" id="dns-stats-file" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="./stats.json">
+                                        <label for="dns-dnssec-upstream-servers" class="block text-sm font-medium text-gray-700 mb-1">DNSSEC上游DNS服务器 (逗号分隔)</label>
+                                        <input type="text" id="dns-dnssec-upstream-servers" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="8.8.8.8, 1.1.1.1">
                                    </div>
                                    <div>
                                        <label for="dns-save-interval" class="block text-sm font-medium text-gray-700 mb-1">保存间隔 (秒)</label>
                                        <input type="number" id="dns-save-interval" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="300">
                                    </div>
+                                    <div class="md:col-span-2">
+                                        <label class="flex items-center space-x-2">
+                                            <input type="checkbox" id="dns-enable-ipv6" class="rounded text-primary focus:ring-primary">
+                                            <span class="text-sm font-medium text-gray-700">启用IPv6解析（AAAA记录）</span>
+                                        </label>
+                                    </div>
                                </div>
                            </div>
                            
@@ -1055,15 +1088,6 @@
                            <!-- 屏蔽配置 -->
                            <div class="mb-8">
                                <h4 class="text-md font-medium mb-4">屏蔽配置</h4>
-                                <div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-2 gap-6">
-                                    <div>
-                                        <label for="shield-local-rules-file" class="block text-sm font-medium text-gray-700 mb-1">自定义规则文件</label>
-                                        <input type="text" id="shield-local-rules-file" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="./rules.txt">
-                                    </div>
-                                    <div>
-                                        <label for="shield-hosts-file" class="block text-sm font-medium text-gray-700 mb-1">Hosts文件</label>
-                                        <input type="text" id="shield-hosts-file" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="/etc/hosts">
-                                    </div>
                                    <div>
                                        <label for="shield-update-interval" class="block text-sm font-medium text-gray-700 mb-1">更新间隔 (秒)</label>
                                        <input type="number" id="shield-update-interval" class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent" placeholder="3600">
@@ -1098,15 +1122,29 @@
    </div>
    
    <!-- 修改密码模态框 -->
+    <!-- 日志详情模态框 -->
+    <div id="log-detail-modal" class="fixed inset-0 bg-black bg-opacity-50 z-50 hidden flex items-center justify-center">
+        <div class="bg-white rounded-lg shadow-xl p-6 w-full max-w-md">
+            <div class="flex justify-between items-center mb-4">
+                <h3 class="text-xl font-semibold">日志详情</h3>
+                <button id="close-log-modal-btn" class="text-gray-500 hover:text-gray-700 focus:outline-none">
+                    <i class="fa fa-times text-xl"></i>
+                </button>
+            </div>
+            <div id="log-detail-content">
+                <!-- 日志详情内容将通过JS动态填充 -->
+            </div>
+        </div>
+    </div>
+
    <div id="change-password-modal" class="fixed inset-0 bg-black bg-opacity-50 z-50 hidden flex items-center justify-center">
-        <div class="bg-white rounded-lg shadow-xl w-full max-w-md p-6">
-            <div class="flex items-center justify-between mb-6">
+        <div class="bg-white rounded-lg shadow-xl p-6 w-full max-w-md">
+            <div class="flex justify-between items-center mb-4">
                <h3 class="text-xl font-semibold">修改密码</h3>
                <button id="close-modal-btn" class="text-gray-500 hover:text-gray-700 focus:outline-none">
                    <i class="fa fa-times text-xl"></i>
                </button>
            </div>
-            
            <form id="change-password-form">
                <div class="mb-4">
                    <label for="current-password" class="block text-sm font-medium text-gray-700 mb-1">当前密码</label>
@@ -1136,7 +1174,6 @@
    <script src="js/main.js"></script>
    <script src="js/api.js"></script>
    <script src="js/dashboard.js"></script>
-    <script src="js/server-status.js"></script>
    <script src="js/shield.js"></script>
    <script src="js/hosts.js"></script>
    <script src="js/query.js"></script>
--- a/static/js/config.js
+++ b/static/js/config.js
@@ -61,18 +61,20 @@ function populateConfigForm(config) {
  // DNS配置 - 使用函数安全设置值，避免 || 操作符可能的错误处理
  setElementValue('dns-port', getSafeValue(dnsServerConfig.Port, 53));
  setElementValue('dns-upstream-servers', getSafeArray(dnsServerConfig.UpstreamServers).join(', '));
+  setElementValue('dns-dnssec-upstream-servers', getSafeArray(dnsServerConfig.DNSSECUpstreamServers).join(', '));
  setElementValue('dns-timeout', getSafeValue(dnsServerConfig.Timeout, 5));
-  setElementValue('dns-stats-file', getSafeValue(dnsServerConfig.StatsFile, 'data/stats.json'));
-  setElementValue('dns-save-interval', getSafeValue(dnsServerConfig.SaveInterval, 300));
-  
+  //setElementValue('dns-stats-file', getSafeValue(dnsServerConfig.StatsFile, 'data/stats.json'));
+  setElementValue('dns-save-interval', getSafeValue(dnsServerConfig.SaveInterval, 30));
+  //setElementValue('dns-cache-ttl', getSafeValue(dnsServerConfig.CacheTTL, 10));
+  setElementValue('dns-enable-ipv6', getSafeValue(dnsServerConfig.EnableIPv6, false));
  // HTTP配置
  setElementValue('http-port', getSafeValue(httpServerConfig.Port, 8080));
  
  // 屏蔽配置
-  setElementValue('shield-local-rules-file', getSafeValue(shieldConfig.LocalRulesFile, 'data/rules.txt'));
+  //setElementValue('shield-local-rules-file', getSafeValue(shieldConfig.LocalRulesFile, 'data/rules.txt'));
  setElementValue('shield-update-interval', getSafeValue(shieldConfig.UpdateInterval, 3600));
-  setElementValue('shield-hosts-file', getSafeValue(shieldConfig.HostsFile, 'data/hosts.txt'));
-  // 使用服务器端接受的屏蔽方法值，默认使用NXDOMAIN
+  //setElementValue('shield-hosts-file', getSafeValue(shieldConfig.HostsFile, 'data/hosts.txt'));
+  // 使用服务器端接受的屏蔽方法值，默认使用NXDOMAIN, 可选值: NXDOMAIN, NULL, REFUSED
  setElementValue('shield-block-method', getSafeValue(shieldConfig.BlockMethod, 'NXDOMAIN'));
 }

@@ -80,7 +82,11 @@ function populateConfigForm(config) {
 function setElementValue(elementId, value) {
  const element = document.getElementById(elementId);
  if (element && element.tagName === 'INPUT') {
+    if (element.type === 'checkbox') {
+      element.checked = value;
+    } else {
      element.value = value;
+    }
  } else if (!element) {
    console.warn(`Element with id "${elementId}" not found for setting value: ${value}`);
  }
@@ -163,6 +169,12 @@ function collectFormData() {
    upstreamServersText.split(',').map(function(s) { return s.trim(); }).filter(function(s) { return s !== ''; }) : 
    [];

+  // 安全获取DNSSEC上游服务器列表
+  const dnssecUpstreamServersText = getElementValue('dns-dnssec-upstream-servers');
+  const dnssecUpstreamServers = dnssecUpstreamServersText ? 
+    dnssecUpstreamServersText.split(',').map(function(s) { return s.trim(); }).filter(function(s) { return s !== ''; }) : 
+    [];
+
  // 安全获取并转换整数值
  const timeoutValue = getElementValue('dns-timeout');
  const timeout = timeoutValue ? parseInt(timeoutValue, 10) : 5;
@@ -174,21 +186,20 @@ function collectFormData() {
  const updateInterval = updateIntervalValue ? parseInt(updateIntervalValue, 10) : 3600;

  return {
-    DNSServer: {
-      Port: dnsPort,
-      UpstreamServers: upstreamServers,
-      Timeout: timeout,
-      StatsFile: getElementValue('dns-stats-file') || './data/stats.json',
-      SaveInterval: saveInterval
+    dnsserver: {
+      port: dnsPort,
+      upstreamServers: upstreamServers,
+      dnssecUpstreamServers: dnssecUpstreamServers,
+      timeout: timeout,
+      saveInterval: saveInterval,
+      enableIPv6: getElementValue('dns-enable-ipv6')
    },
-    HTTPServer: {
-      Port: httpPort
+    httpserver: {
+      port: httpPort
    },
-    Shield: {
-      LocalRulesFile: getElementValue('shield-local-rules-file') || './data/rules.txt',
-      UpdateInterval: updateInterval,
-      HostsFile: getElementValue('shield-hosts-file') || './data/hosts.txt',
-      BlockMethod: getElementValue('shield-block-method') || 'NXDOMAIN'
+    shield: {
+      updateInterval: updateInterval,
+      blockMethod: getElementValue('shield-block-method') || 'NXDOMAIN'
    }
  };
 }
@@ -197,6 +208,9 @@ function collectFormData() {
 function getElementValue(elementId) {
  const element = document.getElementById(elementId);
  if (element && element.tagName === 'INPUT') {
+    if (element.type === 'checkbox') {
+      return element.checked;
+    }
    return element.value;
  }
  return ''; // 默认返回空字符串
--- a/static/js/dashboard.js
+++ b/static/js/dashboard.js
@@ -2964,33 +2964,10 @@ window.addEventListener('hashchange', handleHashChange);
 // 初始化hash路由 - 确保在页面加载时就能被调用
 initHashRoute();

-// 侧边栏切换
-function toggleSidebar() {
-    const sidebar = document.getElementById('sidebar');
-    sidebar.classList.toggle('-translate-x-full');
-}
-
 // 响应式处理
 function handleResponsive() {
-    const toggleBtn = document.getElementById('toggle-sidebar');
-    const sidebar = document.getElementById('sidebar');
-    
-    toggleBtn.addEventListener('click', toggleSidebar);
-    
-    // 初始状态处理
-    function updateSidebarState() {
-        if (window.innerWidth < 1024) {
-            sidebar.classList.add('-translate-x-full');
-        } else {
-            sidebar.classList.remove('-translate-x-full');
-        }
-    }
-    
-    updateSidebarState();
-    
    // 窗口大小改变时处理
    window.addEventListener('resize', () => {
-        updateSidebarState();
        
        // 更新所有图表大小
        if (dnsRequestsChart) {
--- a/static/js/guide.js
+++ b/static/js/guide.js
--- a/static/js/logs.js
+++ b/static/js/logs.js
@@ -14,10 +14,83 @@ let currentSortDirection = 'desc'; // 默认降序
 let ipGeolocationCache = {};
 const GEOLOCATION_CACHE_EXPIRY = 24 * 60 * 60 * 1000; // 缓存有效期24小时

+// 跟踪器数据库缓存
+let trackersDatabase = null;
+let trackersLoaded = false;
+let trackersLoading = false;
+
 // WebSocket连接和重连计时器
 let logsWsConnection = null;
 let logsWsReconnectTimer = null;

+// 加载跟踪器数据库
+async function loadTrackersDatabase() {
+    if (trackersLoaded) return trackersDatabase;
+    if (trackersLoading) {
+        // 等待正在进行的加载完成
+        while (trackersLoading) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        return trackersDatabase;
+    }
+    
+    trackersLoading = true;
+    
+    try {
+        const response = await fetch('/tracker/trackers.json');
+        if (!response.ok) {
+            console.error('加载跟踪器数据库失败:', response.statusText);
+            trackersDatabase = { trackers: {} };
+            return trackersDatabase;
+        }
+        
+        trackersDatabase = await response.json();
+        trackersLoaded = true;
+        return trackersDatabase;
+    } catch (error) {
+        console.error('加载跟踪器数据库失败:', error);
+        trackersDatabase = { trackers: {} };
+        return trackersDatabase;
+    } finally {
+        trackersLoading = false;
+    }
+}
+
+// 检查域名是否在跟踪器数据库中，并返回跟踪器信息
+async function isDomainInTrackerDatabase(domain) {
+    if (!trackersDatabase || !trackersLoaded) {
+        await loadTrackersDatabase();
+    }
+    
+    if (!trackersDatabase || !trackersDatabase.trackers) {
+        return null;
+    }
+    
+    // 检查域名是否直接作为跟踪器键存在
+    if (trackersDatabase.trackers.hasOwnProperty(domain)) {
+        return trackersDatabase.trackers[domain];
+    }
+    
+    // 检查域名是否在跟踪器URL中
+    for (const trackerKey in trackersDatabase.trackers) {
+        if (trackersDatabase.trackers.hasOwnProperty(trackerKey)) {
+            const tracker = trackersDatabase.trackers[trackerKey];
+            if (tracker && tracker.url) {
+                try {
+                    const trackerUrl = new URL(tracker.url);
+                    if (trackerUrl.hostname === domain || trackerUrl.hostname.includes(domain)) {
+                        return tracker;
+                    }
+                } catch (e) {
+                    // 忽略无效URL
+                }
+            }
+        }
+    }
+    
+    return null;
+}
+
 // 初始化查询日志页面
 function initLogsPage() {
    console.log('初始化查询日志页面');
@@ -34,13 +107,25 @@ function initLogsPage() {
    // 绑定事件
    bindLogsEvents();
    
+    // 初始化日志详情弹窗
+    initLogDetailModal();
+    
    // 建立WebSocket连接，用于实时更新统计数据和图表
    connectLogsWebSocket();
    
+    // 窗口大小改变时重新加载日志表格
+    window.addEventListener('resize', handleWindowResize);
+    
    // 在页面卸载时清理资源
    window.addEventListener('beforeunload', cleanupLogsResources);
 }

+// 处理窗口大小改变
+function handleWindowResize() {
+    // 重新加载日志表格，以适应新的屏幕尺寸
+    loadLogs();
+}
+
 // 清理资源
 function cleanupLogsResources() {
    // 清除WebSocket连接
@@ -54,6 +139,9 @@ function cleanupLogsResources() {
        clearTimeout(logsWsReconnectTimer);
        logsWsReconnectTimer = null;
    }
+    
+    // 清除窗口大小改变事件监听器
+    window.removeEventListener('resize', handleWindowResize);
 }

 // 绑定事件
@@ -122,6 +210,34 @@ function bindLogsEvents() {
        });
    }
    
+    // 页码跳转
+    const pageInput = document.getElementById('logs-page-input');
+    const goBtn = document.getElementById('logs-go-page');
+    
+    if (pageInput) {
+        // 页码输入框回车事件
+        pageInput.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                const page = parseInt(pageInput.value);
+                if (page >= 1 && page <= totalPages) {
+                    currentPage = page;
+                    loadLogs();
+                }
+            }
+        });
+    }
+    
+    if (goBtn) {
+        // 前往按钮点击事件
+        goBtn.addEventListener('click', () => {
+            const page = parseInt(pageInput.value);
+            if (page >= 1 && page <= totalPages) {
+                currentPage = page;
+                loadLogs();
+            }
+        });
+    }
+    
    // 时间范围切换
    const timeRangeBtns = document.querySelectorAll('.time-range-btn');
    timeRangeBtns.forEach(btn => {
@@ -304,7 +420,7 @@ function loadLogs() {
 }

 // 更新日志表格
-function updateLogsTable(logs) {
+async function updateLogsTable(logs) {
    const tableBody = document.getElementById('logs-table-body');
    if (!tableBody) return;
    
@@ -324,13 +440,16 @@ function updateLogsTable(logs) {
        return;
    }
    
+    // 检测是否为移动设备
+    const isMobile = window.innerWidth <= 768;
+    
    // 填充表格
-    logs.forEach(log => {
+    for (const log of logs) {
        const row = document.createElement('tr');
        row.className = 'border-b border-gray-100 hover:bg-gray-50 transition-colors';
        
        // 格式化时间 - 两行显示，第一行显示时间，第二行显示日期
-        const time = new Date(log.Timestamp);
+        const time = new Date(log.timestamp);
        const formattedDate = time.toLocaleDateString('zh-CN', {
            year: 'numeric',
            month: '2-digit',
@@ -344,13 +463,13 @@ function updateLogsTable(logs) {
        
        // 根据结果添加不同的背景色
        let rowClass = '';
-        switch (log.Result) {
+        switch (log.result) {
            case 'blocked':
                rowClass = 'bg-red-50'; // 淡红色填充
                break;
            case 'allowed':
                // 检查是否是规则允许项目
-                if (log.BlockRule && log.BlockRule.includes('allow')) {
+                if (log.blockRule && log.blockRule.includes('allow')) {
                    rowClass = 'bg-green-50'; // 规则允许项目用淡绿色填充
                } else {
                    rowClass = ''; // 允许的不填充
@@ -368,7 +487,7 @@ function updateLogsTable(logs) {
        // 添加被屏蔽或允许显示，并增加颜色
        let statusText = '';
        let statusClass = '';
-        switch (log.Result) {
+        switch (log.result) {
            case 'blocked':
                statusText = '被屏蔽';
                statusClass = 'text-danger';
@@ -386,37 +505,98 @@ function updateLogsTable(logs) {
                statusClass = '';
        }
        
-        // 构建行内容 - 两行显示，时间列显示时间和日期，请求列显示域名和类型状态
+        // 检查域名是否在跟踪器数据库中
+            const trackerInfo = await isDomainInTrackerDatabase(log.domain);
+            const isTracker = trackerInfo !== null;
+            
+            // 构建行内容 - 根据设备类型决定显示内容
                // 添加缓存状态显示
-            const cacheStatusClass = log.FromCache ? 'text-primary' : 'text-gray-500';
-            const cacheStatusText = log.FromCache ? '缓存' : '非缓存';
+                const cacheStatusClass = log.fromCache ? 'text-primary' : 'text-gray-500';
+                const cacheStatusText = log.fromCache ? '缓存' : '非缓存';
                
                // 检查域名是否被拦截
-            const isBlocked = log.Result === 'blocked';
+                const isBlocked = log.result === 'blocked';
                
+                // 构建跟踪器浮窗内容
+                const trackerTooltip = isTracker ? `
+                    <div class="tracker-tooltip absolute z-50 bg-white shadow-lg rounded-md border p-3 min-w-64 text-sm">
+                        <div class="font-semibold mb-1">已知跟踪器</div>
+                        <div class="mb-1">名称: ${trackerInfo.name}</div>
+                        <div class="mb-1">类别: ${trackersDatabase.categories[trackerInfo.categoryId] || '未知'}</div>
+                        ${trackerInfo.url ? `<div class="mb-1">URL: <a href="${trackerInfo.url}" target="_blank" class="text-blue-500 hover:underline">${trackerInfo.url}</a></div>` : ''}
+                        ${trackerInfo.source ? `<div class="mb-1">源: ${trackerInfo.source}</div>` : ''}
+                    </div>
+                ` : '';
+                
+                if (isMobile) {
+                    // 移动设备只显示时间和请求信息
+                    row.innerHTML = `
+                        <td class="py-3 px-4">
+                            <div class="text-sm font-medium">${formattedTime}</div>
+                            <div class="text-xs text-gray-500 mt-1">${formattedDate}</div>
+                        </td>
+                        <td class="py-3 px-4 text-sm" colspan="4">
+                            <div class="font-medium flex items-center relative">
+                                ${log.dnssec ? '<i class="fa fa-lock text-green-500 mr-1" title="DNSSEC已启用"></i>' : ''}
+                                <div class="tracker-icon-container relative">
+                                    ${isTracker ? '<i class="fa fa-eye text-red-500 mr-1"></i>' : '<i class="fa fa-eye-slash text-gray-300 mr-1"></i>'}
+                                    ${trackerTooltip}
+                                </div>
+                                ${log.domain}
+                            </div>
+                            <div class="text-xs text-gray-500 mt-1">类型: ${log.queryType}, <span class="${statusClass}">${statusText}</span></div>
+                            <div class="text-xs text-gray-500 mt-1">客户端: ${log.clientIP}</div>
+                        </td>
+                    `;
+                } else {
+                    // 桌面设备显示完整信息
                    row.innerHTML = `
                        <td class="py-3 px-4">
                            <div class="text-sm font-medium">${formattedTime}</div>
                            <div class="text-xs text-gray-500 mt-1">${formattedDate}</div>
                        </td>
                        <td class="py-3 px-4 text-sm">
-                    <div class="font-medium">${log.ClientIP}</div>
-                    <div class="text-xs text-gray-500 mt-1">${log.Location || '未知 未知'}</div>
+                            <div class="font-medium">${log.clientIP}</div>
+                            <div class="text-xs text-gray-500 mt-1">${log.location || '未知 未知'}</div>
                        </td>
                        <td class="py-3 px-4 text-sm">
-                    <div class="font-medium">${log.Domain}</div>
-                    <div class="text-xs text-gray-500 mt-1">类型: ${log.QueryType}, <span class="${statusClass}">${statusText}</span>, <span class="${cacheStatusClass}">${log.FromCache ? '缓存' : '实时'}</span>${log.DNSSEC ? ', <span class="text-green-500"><i class="fa fa-lock"></i> DNSSEC</span>' : ''}${log.EDNS ? ', <span class="text-blue-500"><i class="fa fa-exchange"></i> EDNS</span>' : ''}</div>
-                    <div class="text-xs text-gray-500 mt-1">DNS 服务器: ${log.DNSServer || '无'}, DNSSEC专用: ${log.DNSSECServer || '无'}</div>
+                            <div class="font-medium flex items-center relative">
+                                ${log.dnssec ? '<i class="fa fa-lock text-green-500 mr-1" title="DNSSEC已启用"></i>' : ''}
+                                <div class="tracker-icon-container relative">
+                                    ${isTracker ? '<i class="fa fa-eye text-red-500 mr-1"></i>' : '<i class="fa fa-eye-slash text-gray-300 mr-1"></i>'}
+                                    ${trackerTooltip}
+                                </div>
+                                ${log.domain}
+                            </div>
+                            <div class="text-xs text-gray-500 mt-1">类型: ${log.queryType}, <span class="${statusClass}">${statusText}</span>, <span class="${cacheStatusClass}">${log.fromCache ? '缓存' : '非缓存'}</span>${log.dnssec ? ', <span class="text-green-500"><i class="fa fa-lock"></i> DNSSEC</span>' : ''}${log.edns ? ', <span class="text-blue-500"><i class="fa fa-exchange"></i> EDNS</span>' : ''}</div>
+                            <div class="text-xs text-gray-500 mt-1">DNS 服务器: ${log.dnsServer || '无'}, DNSSEC专用: ${log.dnssecServer || '无'}</div>
                        </td>
-                <td class="py-3 px-4 text-sm">${log.ResponseTime}ms</td>
-                <td class="py-3 px-4 text-sm text-gray-500">${log.BlockRule || '-'}</td>
+                        <td class="py-3 px-4 text-sm">${log.responseTime}ms</td>
                        <td class="py-3 px-4 text-sm text-center">
                            ${isBlocked ? 
-                        `<button class="unblock-btn px-3 py-1 bg-green-500 text-white rounded-md hover:bg-green-600 transition-colors text-xs" data-domain="${log.Domain}">放行</button>` : 
-                        `<button class="block-btn px-3 py-1 bg-red-500 text-white rounded-md hover:bg-red-600 transition-colors text-xs" data-domain="${log.Domain}">拦截</button>`
+                                `<button class="unblock-btn px-3 py-1 bg-green-500 text-white rounded-md hover:bg-green-600 transition-colors text-xs" data-domain="${log.domain}">放行</button>` : 
+                                `<button class="block-btn px-3 py-1 bg-red-500 text-white rounded-md hover:bg-red-600 transition-colors text-xs" data-domain="${log.domain}">拦截</button>`
                            }
                        </td>
                    `;
+                }
+                
+                // 添加跟踪器图标悬停事件
+                if (isTracker) {
+                    const iconContainer = row.querySelector('.tracker-icon-container');
+                    const tooltip = iconContainer.querySelector('.tracker-tooltip');
+                    if (iconContainer && tooltip) {
+                        tooltip.style.display = 'none';
+                        
+                        iconContainer.addEventListener('mouseenter', () => {
+                            tooltip.style.display = 'block';
+                        });
+                        
+                        iconContainer.addEventListener('mouseleave', () => {
+                            tooltip.style.display = 'none';
+                        });
+                    }
+                }
            
            // 绑定按钮事件
            const blockBtn = row.querySelector('.block-btn');
@@ -437,8 +617,18 @@ function updateLogsTable(logs) {
                });
            }
            
-        tableBody.appendChild(row);
+            // 绑定日志详情点击事件
+            row.addEventListener('click', (e) => {
+                // 如果点击的是按钮，不触发详情弹窗
+                if (e.target.closest('button')) {
+                    return;
+                }
+                console.log('Row clicked, log object:', log);
+                showLogDetailModal(log);
            });
+        
+        tableBody.appendChild(row);
+    }
 }

 // 更新分页信息
@@ -447,6 +637,13 @@ function updateLogsPagination() {
    document.getElementById('logs-current-page').textContent = currentPage;
    document.getElementById('logs-total-pages').textContent = totalPages;
    
+    // 更新页码输入框
+    const pageInput = document.getElementById('logs-page-input');
+    if (pageInput) {
+        pageInput.max = totalPages;
+        pageInput.value = currentPage;
+    }
+    
    // 更新按钮状态
    const prevBtn = document.getElementById('logs-prev-page');
    const nextBtn = document.getElementById('logs-next-page');
@@ -785,6 +982,467 @@ async function unblockDomain(domain) {
    }
 }

+// 独立的DNS记录格式化函数
+function formatDNSRecords(log, result) {
+    if (result === 'blocked') return '无';
+    
+    let records = '';
+    const sources = [
+        log.answers,
+        log.answer,
+        log.Records,
+        log.records,
+        log.response
+    ];
+    
+    for (const source of sources) {
+        if (records) break;
+        if (!source || source === '无') continue;
+        
+        // 处理数组类型
+        if (Array.isArray(source)) {
+            records = source.map(answer => {
+                const type = answer.type || answer.Type || '未知';
+                let value = answer.value || answer.Value || answer.data || answer.Data || '未知';
+                const ttl = answer.TTL || answer.ttl || answer.expires || '未知';
+                
+                // 增强的记录值提取逻辑
+                if (typeof value === 'string') {
+                    value = value.trim();
+                    // 处理制表符分隔的格式
+                    if (value.includes('\t') || value.includes('\\t')) {
+                        const parts = value.replace(/\\t/g, '\t').split('\t');
+                        if (parts.length >= 4) {
+                            value = parts[parts.length - 1].trim();
+                        }
+                    }
+                    // 处理JSON格式
+                    else if (value.startsWith('{') && value.endsWith('}')) {
+                        try {
+                            const parsed = JSON.parse(value);
+                            value = parsed.data || parsed.value || value;
+                        } catch (e) {}
+                    }
+                }
+                
+                return `${type}: ${value} (ttl=${ttl})`;
+            }).join('\n').trim();
+        }
+        // 处理字符串类型
+        else if (typeof source === 'string') {
+            // 尝试解析为JSON数组
+            if (source.startsWith('[') && source.endsWith(']')) {
+                try {
+                    const parsed = JSON.parse(source);
+                    if (Array.isArray(parsed)) {
+                        records = parsed.map(answer => {
+                            const type = answer.type || answer.Type || '未知';
+                            let value = answer.value || answer.Value || answer.data || answer.Data || '未知';
+                            const ttl = answer.TTL || answer.ttl || answer.expires || '未知';
+                            
+                            if (typeof value === 'string') {
+                                value = value.trim();
+                            }
+                            
+                            return `${type}: ${value} (ttl=${ttl})`;
+                        }).join('\n').trim();
+                    }
+                } catch (e) {
+                    // 解析失败，尝试直接格式化
+                    records = formatDNSString(source);
+                }
+            } else {
+                // 直接格式化字符串
+                records = formatDNSString(source);
+            }
+        }
+    }
+    
+    return records || '无解析记录';
+}
+
+// 格式化DNS字符串记录
+function formatDNSString(str) {
+    // 处理可能的转义字符并分割行
+    const recordLines = str.split(/\r?\n/).map(line => line.replace(/^\s+/, '')).filter(line => line.trim() !== '');
+    
+    return recordLines.map(line => {
+        // 检查是否已经是标准格式
+        if (line.includes(':') && line.includes('(')) {
+            return line;
+        }
+        // 尝试解析为标准DNS格式
+        const parts = line.split(/\s+/);
+        if (parts.length >= 5) {
+            const type = parts[3];
+            const value = parts.slice(4).join(' ');
+            const ttl = parts[1];
+            return `${type}: ${value} (ttl=${ttl})`;
+        }
+        // 无法解析，返回原始行但移除前导空格
+        return line.replace(/^\s+/, '');
+    }).join('\n');
+}
+
+// 显示日志详情弹窗
+async function showLogDetailModal(log) {
+    console.log('showLogDetailModal called with log:', JSON.stringify(log, null, 2)); // 输出完整的log对象
+    
+    if (!log) {
+        console.error('No log data provided!');
+        return;
+    }
+    
+    try {
+        // 安全获取log属性，提供默认值
+        const timestamp = log.timestamp ? new Date(log.timestamp) : null;
+        const dateStr = timestamp ? timestamp.toLocaleDateString() : '未知';
+        const timeStr = timestamp ? timestamp.toLocaleTimeString() : '未知';
+        const domain = log.domain || '未知';
+        const queryType = log.queryType || '未知';
+        const result = log.result || '未知';
+        const responseTime = log.responseTime || '未知';
+        const clientIP = log.clientIP || '未知';
+        const location = log.location || '未知';
+        const fromCache = log.fromCache || false;
+        const dnssec = log.dnssec || false;
+        const edns = log.edns || false;
+        const dnsServer = log.dnsServer || '无';
+        const dnssecServer = log.dnssecServer || '无';
+        const blockRule = log.blockRule || '无';
+        
+        // 检查域名是否在跟踪器数据库中
+        const trackerInfo = await isDomainInTrackerDatabase(log.domain);
+        const isTracker = trackerInfo !== null;
+        
+        // 格式化DNS解析记录
+        const dnsRecords = formatDNSRecords(log, result);
+        
+        // 创建模态框容器
+        const modalContainer = document.createElement('div');
+        modalContainer.className = 'fixed inset-0 bg-black bg-opacity-50 z-50 flex items-center justify-center p-4 animate-fade-in';
+        modalContainer.style.zIndex = '9999';
+        
+        // 创建模态框内容
+        const modalContent = document.createElement('div');
+        modalContent.className = 'bg-white rounded-xl shadow-2xl w-full max-w-2xl max-h-[90vh] overflow-y-auto animate-slide-in';
+        
+        // 创建标题栏
+        const header = document.createElement('div');
+        header.className = 'sticky top-0 bg-white border-b border-gray-200 px-6 py-4 flex justify-between items-center';
+        
+        const title = document.createElement('h3');
+        title.className = 'text-xl font-semibold text-gray-900';
+        title.textContent = '日志详情';
+        
+        const closeButton = document.createElement('button');
+        closeButton.innerHTML = '<i class="fa fa-times text-xl"></i>';
+        closeButton.className = 'text-gray-500 hover:text-gray-700 focus:outline-none transition-colors';
+        closeButton.onclick = () => closeModal();
+        
+        header.appendChild(title);
+        header.appendChild(closeButton);
+        
+        // 创建内容区域
+        const content = document.createElement('div');
+        content.className = 'p-6 space-y-6';
+        
+        // 基本信息部分
+        const basicInfo = document.createElement('div');
+        basicInfo.className = 'space-y-4';
+        
+        const basicInfoTitle = document.createElement('h4');
+        basicInfoTitle.className = 'text-sm font-medium text-gray-700 uppercase tracking-wider';
+        basicInfoTitle.textContent = '基本信息';
+        
+        const basicInfoGrid = document.createElement('div');
+        basicInfoGrid.className = 'grid grid-cols-1 md:grid-cols-2 gap-4';
+        
+        // 添加基本信息项
+        basicInfoGrid.innerHTML = `
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">日期</div>
+                <div class="text-sm font-medium text-gray-900">${dateStr}</div>
+            </div>
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">时间</div>
+                <div class="text-sm font-medium text-gray-900">${timeStr}</div>
+            </div>
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">状态</div>
+                <div class="text-sm font-medium ${result === 'blocked' ? 'text-red-600' : result === 'allowed' ? 'text-green-600' : 'text-gray-500'}">
+                    ${result === 'blocked' ? '已拦截' : result === 'allowed' ? '允许' : result}
+                </div>
+            </div>
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">域名</div>
+                <div class="text-sm font-medium text-gray-900 break-all">${domain}</div>
+            </div>
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">类型</div>
+                <div class="text-sm font-medium text-gray-900">${queryType}</div>
+            </div>
+        `;
+        
+        // DNS特性
+        const dnsFeatures = document.createElement('div');
+        dnsFeatures.className = 'col-span-1 md:col-span-2 space-y-1';
+        dnsFeatures.innerHTML = `
+            <div class="text-xs text-gray-500">DNS特性</div>
+            <div class="text-sm font-medium text-gray-900">
+                ${dnssec ? '<i class="fa fa-lock text-green-500 mr-1" title="DNSSEC已启用"></i>DNSSEC ' : ''}
+                ${edns ? '<i class="fa fa-exchange text-blue-500 mr-1" title="EDNS已启用"></i>EDNS' : ''}
+                ${!dnssec && !edns ? '无' : ''}
+            </div>
+        `;
+        
+        // 跟踪器信息
+        const trackerDiv = document.createElement('div');
+        trackerDiv.className = 'col-span-1 md:col-span-2 space-y-1';
+        trackerDiv.innerHTML = `
+            <div class="text-xs text-gray-500">跟踪器信息</div>
+            <div class="text-sm font-medium text-gray-900">
+                ${isTracker ? `
+                    <div class="flex items-center">
+                        <i class="fa fa-eye text-red-500 mr-1"></i>
+                        <span>${trackerInfo.name} (${trackersDatabase.categories[trackerInfo.categoryId] || '未知'})</span>
+                    </div>
+                ` : '无'}
+            </div>
+        `;
+        
+        // 解析记录
+        const recordsDiv = document.createElement('div');
+        recordsDiv.className = 'col-span-1 md:col-span-2 space-y-1';
+        recordsDiv.innerHTML = `
+            <div class="text-xs text-gray-500">解析记录</div>
+            <div class="text-sm font-medium text-gray-900 whitespace-pre-wrap break-all bg-gray-50 p-3 rounded-md border border-gray-200">${dnsRecords}</div>
+        `;
+        
+        // DNS服务器
+        const dnsServerDiv = document.createElement('div');
+        dnsServerDiv.className = 'col-span-1 md:col-span-2 space-y-1';
+        dnsServerDiv.innerHTML = `
+            <div class="text-xs text-gray-500">DNS服务器</div>
+            <div class="text-sm font-medium text-gray-900">${dnsServer}</div>
+        `;
+        
+        // DNSSEC专用服务器
+        const dnssecServerDiv = document.createElement('div');
+        dnssecServerDiv.className = 'col-span-1 md:col-span-2 space-y-1';
+        dnssecServerDiv.innerHTML = `
+            <div class="text-xs text-gray-500">DNSSEC专用服务器</div>
+            <div class="text-sm font-medium text-gray-900">${dnssecServer}</div>
+        `;
+        
+        basicInfoGrid.appendChild(dnsFeatures);
+        basicInfoGrid.appendChild(trackerDiv);
+        basicInfoGrid.appendChild(recordsDiv);
+        basicInfoGrid.appendChild(dnsServerDiv);
+        basicInfoGrid.appendChild(dnssecServerDiv);
+        
+        basicInfo.appendChild(basicInfoTitle);
+        basicInfo.appendChild(basicInfoGrid);
+        
+        // 响应细节部分
+        const responseDetails = document.createElement('div');
+        responseDetails.className = 'space-y-4 pt-4 border-t border-gray-200';
+        
+        const responseDetailsTitle = document.createElement('h4');
+        responseDetailsTitle.className = 'text-sm font-medium text-gray-700 uppercase tracking-wider';
+        responseDetailsTitle.textContent = '响应细节';
+        
+        // 准备响应细节内容，根据条件添加规则信息
+        let responseDetailsHTML = `
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">响应时间</div>
+                <div class="text-sm font-medium text-gray-900">${responseTime}毫秒</div>
+            </div>
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">响应代码</div>
+                <div class="text-sm font-medium text-gray-900">${getResponseCodeText(log.responseCode)}</div>
+            </div>
+            <div class="space-y-1">
+                <div class="text-xs text-gray-500">缓存状态</div>
+                <div class="text-sm font-medium ${fromCache ? 'text-primary' : 'text-gray-500'}">
+                    ${fromCache ? '缓存' : '非缓存'}
+                </div>
+            </div>
+        `;
+        
+        // 只有被屏蔽或者有自定义规则时才显示规则信息
+        if (result === 'blocked' || (blockRule && blockRule !== '无' && blockRule !== '-')) {
+            responseDetailsHTML += `
+                <div class="space-y-1">
+                    <div class="text-xs text-gray-500">规则</div>
+                    <div class="text-sm font-medium text-gray-900">${blockRule || '-'}</div>
+                </div>
+            `;
+        }
+        
+        const responseGrid = document.createElement('div');
+        responseGrid.className = 'grid grid-cols-1 md:grid-cols-2 gap-4';
+        responseGrid.innerHTML = responseDetailsHTML;
+        
+        responseDetails.appendChild(responseDetailsTitle);
+        responseDetails.appendChild(responseGrid);
+        
+        // 客户端详情部分
+        const clientDetails = document.createElement('div');
+        clientDetails.className = 'space-y-4 pt-4 border-t border-gray-200';
+        
+        const clientDetailsTitle = document.createElement('h4');
+        clientDetailsTitle.className = 'text-sm font-medium text-gray-700 uppercase tracking-wider';
+        clientDetailsTitle.textContent = '客户端详情';
+        
+        const clientIPDiv = document.createElement('div');
+        clientIPDiv.className = 'space-y-1';
+        clientIPDiv.innerHTML = `
+            <div class="text-xs text-gray-500">IP地址</div>
+            <div class="text-sm font-medium text-gray-900">${clientIP} (${location})</div>
+        `;
+        
+        clientDetails.appendChild(clientDetailsTitle);
+        clientDetails.appendChild(clientIPDiv);
+        
+        // 组装内容
+        content.appendChild(basicInfo);
+        content.appendChild(responseDetails);
+        content.appendChild(clientDetails);
+        
+        // 组装模态框
+        modalContent.appendChild(header);
+        modalContent.appendChild(content);
+        modalContainer.appendChild(modalContent);
+        
+        // 添加到页面
+        document.body.appendChild(modalContainer);
+        
+        // 关闭模态框函数
+        function closeModal() {
+            modalContainer.classList.add('animate-fade-out');
+            modalContent.classList.add('animate-slide-out');
+            
+            // 等待动画结束后移除元素
+            setTimeout(() => {
+                document.body.removeChild(modalContainer);
+            }, 300);
+        }
+        
+        // 点击外部关闭
+        modalContainer.addEventListener('click', (e) => {
+            if (e.target === modalContainer) {
+                closeModal();
+            }
+        });
+        
+        // ESC键关闭
+        const handleEsc = (e) => {
+            if (e.key === 'Escape') {
+                closeModal();
+                document.removeEventListener('keydown', handleEsc);
+            }
+        };
+        document.addEventListener('keydown', handleEsc);
+        
+    } catch (error) {
+        console.error('Error in showLogDetailModal:', error);
+        
+        // 显示错误提示
+        const errorModal = document.createElement('div');
+        errorModal.className = 'fixed inset-0 bg-black bg-opacity-50 z-50 flex items-center justify-center p-4 animate-fade-in';
+        errorModal.style.zIndex = '9999';
+        
+        const errorContent = document.createElement('div');
+        errorContent.className = 'bg-white rounded-xl shadow-2xl p-6 w-full max-w-md animate-slide-in';
+        
+        errorContent.innerHTML = `
+            <div class="flex justify-between items-center mb-4">
+                <h3 class="text-xl font-semibold text-gray-900">错误</h3>
+                <button onclick="closeErrorModal()" class="text-gray-500 hover:text-gray-700 focus:outline-none transition-colors">
+                    <i class="fa fa-times text-xl"></i>
+                </button>
+            </div>
+            <div class="text-red-600 text-sm">
+                加载日志详情失败: ${error.message}
+            </div>
+        `;
+        
+        errorModal.appendChild(errorContent);
+        document.body.appendChild(errorModal);
+        
+        // 关闭错误模态框函数
+        function closeErrorModal() {
+            errorModal.classList.add('animate-fade-out');
+            errorContent.classList.add('animate-slide-out');
+            
+            // 等待动画结束后移除元素
+            setTimeout(() => {
+                document.body.removeChild(errorModal);
+            }, 300);
+        }
+        
+        // ESC键关闭错误模态框
+        const handleErrorEsc = (e) => {
+            if (e.key === 'Escape') {
+                closeErrorModal();
+                document.removeEventListener('keydown', handleErrorEsc);
+            }
+        };
+        document.addEventListener('keydown', handleErrorEsc);
+    }
+}
+
+// 关闭日志详情弹窗
+// 获取响应代码文本
+function getResponseCodeText(rcode) {
+    const rcodeMap = {
+        0: 'NOERROR',
+        1: 'FORMERR',
+        2: 'SERVFAIL',
+        3: 'NXDOMAIN',
+        4: 'NOTIMP',
+        5: 'REFUSED',
+        6: 'YXDOMAIN',
+        7: 'YXRRSET',
+        8: 'NXRRSET',
+        9: 'NOTAUTH',
+        10: 'NOTZONE'
+    };
+    return rcodeMap[rcode] || `UNKNOWN(${rcode})`;
+}
+
+function closeLogDetailModal() {
+    const modal = document.getElementById('log-detail-modal');
+    modal.classList.add('hidden');
+}
+
+// 初始化日志详情弹窗事件
+function initLogDetailModal() {
+    // 关闭按钮事件
+    const closeBtn = document.getElementById('close-log-modal-btn');
+    if (closeBtn) {
+        closeBtn.addEventListener('click', closeLogDetailModal);
+    }
+    
+    // 点击模态框外部关闭
+    const modal = document.getElementById('log-detail-modal');
+    if (modal) {
+        modal.addEventListener('click', (e) => {
+            if (e.target === modal) {
+                closeLogDetailModal();
+            }
+        });
+    }
+    
+    // ESC键关闭
+    document.addEventListener('keydown', (e) => {
+        if (e.key === 'Escape') {
+            closeLogDetailModal();
+        }
+    });
+}
+
 // 定期更新日志统计数据（备用方案）
 setInterval(() => {
    // 只有在查询日志页面时才更新
--- a/static/js/main.js
+++ b/static/js/main.js
@@ -28,7 +28,7 @@ function setupNavigation() {
    // 移动端侧边栏切换
    const toggleSidebar = document.getElementById('toggle-sidebar');
    const closeSidebarBtn = document.getElementById('close-sidebar');
-    const sidebar = document.getElementById('sidebar');
+    const sidebar = document.getElementById('mobile-sidebar');
    const sidebarOverlay = document.getElementById('sidebar-overlay');
    
    // 打开侧边栏函数
--- a/tracker/trackers.json
+++ b/tracker/trackers.json
--- a/tracker/trackers.json.bak
+++ b/tracker/trackers.json.bak
Author	SHA1	Message	Date
Alex Yang	ecbc20d89f	更新Swagger API	2025-12-26 09:28:29 +08:00
Alex Yang	b48dc4ed27	多项更新优化	2025-12-26 09:02:59 +08:00
Alex Yang	356310ae75	版本更新	2025-12-24 10:59:29 +08:00
Alex Yang	fe77539da1	增加日志查询页面跟踪器显示	2025-12-24 10:08:35 +08:00