讨论：在fakedns中使用基于哈希的稳定域名IP映射

[wyzhoudev]

此讨论受此issue启发：shadowsocks/shadowsocks-rust#1906
正如问题中所描述的，TTL、DNS 缓存造成的不一致性的确会造成一些问题，a.com重定向成b.com这样的情况确实有可能发生，在实际使用中我通过观察服务器日志发现，某些时候v2ray甚至会直接将fakeip直接路由到服务器，重启则可能会造成断网一段时间，所以使用基于哈希的稳定映射不失为一种解决方案。

以下是我使用AI生成一个简单实现，使用xxhash3和线性探测解决碰撞，我已经在我的透明代理环境中使用了几天，到目前为止它似乎工作正常~ 这种方式即使重启也能够保持相对稳定的映射关系。

我想讨论一下将该方案整合到 v2ray 的可行性，下面的代码移除了之前的 IP 分配逻辑和 Lru 淘汰机制，但是在实际实现中，我们可以保留原版的功能，并通过增加配置选项使用新特性，例如我们可以增加一个 StableMapping bool选项来使用稳定映射。

对于 IP 池满的问题，我们假定显式的指定 StableMapping 的用户知道自己在干什么，如果池满我们可以简单的抛出一个错误，提醒用户设置更大的 IP 地址池，而且在实际使用中 fakedns 通常仅解析特定的域名列表，典型的是 gfwlist 即使默认的 ipv4 地址池也不应该轻易出现池满问题。

要彻底解决问题还需要配合数据持久化，简单方案可以使用GOB，或者干脆使用kv数据库。

另外有一点想法供开发人员参考：

fakedns 能否作为入站协议或者直接在 DNS 设置中设置监听端口作为一个标准 DNS 服务器来使用？这对于使用 iptables 或 nftables 进行分流的用例十分有用，局域网中的 DNS 服务器只需要将特定的查询转发至 fakedns 即可， 如果我们有了一种稳定的映射方式，DNS 缓存也不再是问题。目前要以这种方式使用 fakedns 我们不得不采取一些迂回的方式，在入站设置一个 dokodemo 并通过路由设置将流量路由到出站 DNS。

很遗憾我无法为此提交PR，我不是专业人士。

以上 @xiaokangwang

注意：以下代码完全AI生成，未作修改和调试，仅做参考。

//go:build !confonly
// +build !confonly

package fakedns

import (
	"context"
	"fmt"
	"github.com/zeebo/xxh3" // Using XXH3
	"math/big"
	gonet "net"
	"sync"

	"github.com/v2fly/v2ray-core/v5/common"
	"github.com/v2fly/v2ray-core/v5/common/log"                  // V2Ray's logger package
	common_net "github.com/v2fly/v2ray-core/v5/common/net" // Alias to avoid clash with standard net
	"github.com/v2fly/v2ray-core/v5/features/dns"
)

var (
	// Error returned when the pool is effectively full during allocation attempt.
	// Note: The GetFakeIPForDomain interface doesn't return errors, so this is used for internal logging.
	errFakeDnsPoolDepleted = newError("FakeDNS IP Pool depleted for allocation attempt")
)

// Represents the number 1 as a big.Int for incrementing IPs.
var bigOne = big.NewInt(1)

type Holder struct {
	mu *sync.Mutex

	// Configuration
	config *FakeDnsPool

	// IP Pool Range Info
	ipRange    *gonet.IPNet
	startIPNum *big.Int // Numeric representation of the first IP in the range
	endIPNum   *big.Int // Numeric representation of the last IP in the range
	poolSize   *big.Int // Total number of assignable IPs in the range

	// State: Maps for tracking assignments
	// Used for stable direct lookup: domain -> ip_string
	domainToIp map[string]string
	// Used for occupancy check and reverse lookup: ip_string -> domain
	ipToDomain map[string]string
}

// hashDomain generates a uint64 hash for a given domain string using XXH3.
func hashDomain(domain string) uint64 {
	// Use XXH3 for hashing
	return xxh3.HashString(domain)
}

// ipToBigInt converts an IP address to its big.Int representation.
func ipToBigInt(ip gonet.IP) *big.Int {
	return big.NewInt(0).SetBytes(ip)
}

// bigIntToIP converts a big.Int back to an IP address (respecting original IP version).
// It assumes the original IP range (IPv4 or IPv6) dictates the byte length.
func bigIntToIP(n *big.Int, isIPv6 bool) gonet.IP {
	ipBytes := n.Bytes()
	targetLen := gonet.IPv4len
	if isIPv6 {
		targetLen = gonet.IPv6len
	}

	paddedBytes := make([]byte, targetLen)
	if len(ipBytes) >= targetLen {
		// If longer or equal, copy the lower bytes
		copy(paddedBytes, ipBytes[len(ipBytes)-targetLen:])
	} else {
		// If shorter, pad with leading zeros
		copy(paddedBytes[targetLen-len(ipBytes):], ipBytes)
	}
	return gonet.IP(paddedBytes)
}


// IsIPInIPPool checks if an IP address is within the configured pool.
func (fkdns *Holder) IsIPInIPPool(ip common_net.Address) bool { // Use aliased common_net
	if ip.Family().IsDomain() || fkdns.ipRange == nil { // Added nil check
		return false
	}
	return fkdns.ipRange.Contains(ip.IP())
}

// GetFakeIPForDomain3 checks IP type and calls GetFakeIPForDomain.
func (fkdns *Holder) GetFakeIPForDomain3(domain string, ipv4, ipv6 bool) []common_net.Address { // Use aliased common_net
	if fkdns.ipRange == nil { // Check if initialized
		return []common_net.Address{}
	}
	isIPv6 := fkdns.ipRange.IP.To4() == nil
	if (isIPv6 && ipv6) || (!isIPv6 && ipv4) {
		return fkdns.GetFakeIPForDomain(domain)
	}
	return []common_net.Address{}
}

func (*Holder) Type() interface{} {
	return dns.FakeDNSEngineType()
}

// Start initializes the Holder based on its configuration.
func (fkdns *Holder) Start() error {
	if fkdns.config != nil && fkdns.config.IpPool != "" {
		// LruSize from config is ignored in this implementation.
		if fkdns.config.LruSize > 0 {
			// Use V2Ray logger
			log.Record(&log.GeneralMessage{
				Severity: log.Severity_Warning,
				Content:  "FakeDNS: LruSize configuration is ignored in hash-based implementation.",
			})
		}
		return fkdns.initialize(fkdns.config.IpPool)
	}
	return newError("invalid fakeDNS setting: missing IpPool")
}

// Close cleans up the Holder's state.
func (fkdns *Holder) Close() error {
	fkdns.mu.Lock()
	defer fkdns.mu.Unlock()
	fkdns.ipRange = nil
	fkdns.startIPNum = nil
	fkdns.endIPNum = nil
	fkdns.poolSize = nil
	fkdns.domainToIp = nil // Release maps
	fkdns.ipToDomain = nil
	return nil
}

// NewFakeDNSHolder creates a default Holder (using defaults if no config was provided).
// Note: Default IP Pool "198.18.0.0/15" might still be used if config is nil during Start.
func NewFakeDNSHolder() (*Holder, error) {
	// Provide a default config if needed, Start will handle initialization
	conf := &FakeDnsPool{
		IpPool:  "198.18.0.0/15", // V2Ray's default
		LruSize: 0,               // Ignored
	}
	return NewFakeDNSHolderConfigOnly(conf)
}

// NewFakeDNSHolderConfigOnly creates a Holder with configuration, ready for Start.
func NewFakeDNSHolderConfigOnly(conf *FakeDnsPool) (*Holder, error) {
	return &Holder{
		mu:     new(sync.Mutex),
		config: conf, // Store config for Start()
		// State maps initialized in Start/initialize
	}, nil
}

// initialize sets up the Holder based on the CIDR range.
func (fkdns *Holder) initialize(ipPoolCidr string) error {
	// Use blank identifier _ for unused ipaddr
	_, ipNet, err := gonet.ParseCIDR(ipPoolCidr)
	if err != nil {
		return newError("Unable to parse CIDR for Fake DNS IP assignment").Base(err).AtError()
	}

	fkdns.ipRange = ipNet
	fkdns.startIPNum = ipToBigInt(ipNet.IP)

	// Calculate pool size and end IP
	ones, bits := ipNet.Mask.Size()
	hostBits := bits - ones
	if hostBits <= 0 || hostBits > 128 { // Basic sanity check
		return newError("Invalid CIDR mask size for Fake DNS pool").AtError()
	}

	// poolSize = 2^hostBits
	fkdns.poolSize = big.NewInt(0).Exp(big.NewInt(2), big.NewInt(int64(hostBits)), nil)

	// Calculate last IP in the range
	// Create a mask for the host part (all ones)
	hostMask := big.NewInt(0).Sub(fkdns.poolSize, bigOne) // 2^hostBits - 1
	// endIPNum = startIPNum | hostMask (using network address part which is startIPNum for CIDR)
	fkdns.endIPNum = big.NewInt(0).Or(fkdns.startIPNum, hostMask)

	// Check if startIPNum calculation makes sense (especially for /31, /32 which aren't practical pools)
	if fkdns.poolSize.Cmp(big.NewInt(2)) < 0 {
		log.Record(&log.GeneralMessage{
			Severity: log.Severity_Warning,
			Content:  fmt.Sprintf("FakeDNS: IP Pool size is very small (less than 2). This may not be practical: %s", ipPoolCidr),
		})
	}

	fkdns.domainToIp = make(map[string]string)
	fkdns.ipToDomain = make(map[string]string)

	log.Record(&log.GeneralMessage{
		Severity: log.Severity_Info,
		Content:  fmt.Sprintf("FakeDNS: Initialized IP pool %s with size %s using xxHash3", ipPoolCidr, fkdns.poolSize.String()),
	})

	return nil
}

// GetFakeIPForDomain finds or allocates a stable fake IP for a domain using hashing and linear probing.
func (fkdns *Holder) GetFakeIPForDomain(domain string) []common_net.Address { // Use aliased common_net
	fkdns.mu.Lock()
	defer fkdns.mu.Unlock()

	if fkdns.ipRange == nil || fkdns.startIPNum == nil || fkdns.poolSize == nil {
		log.Record(&log.GeneralMessage{
			Severity: log.Severity_Error,
			Content:  "FakeDNS: GetFakeIPForDomain called on uninitialized Holder.",
		})
		return []common_net.Address{} // Not initialized
	}

	isIPv6 := fkdns.ipRange.IP.To4() == nil

	// 1. Check if domain already has a stable IP assigned
	if assignedIpStr, ok := fkdns.domainToIp[domain]; ok {
		// Verify the IP is still valid (should be, unless state corrupted)
		ip := gonet.ParseIP(assignedIpStr)
		if ip != nil {
			// Use V2Ray logger
			log.Record(&log.GeneralMessage{
				Severity: log.Severity_Debug,
				Content:  fmt.Sprintf("FakeDNS: Returning existing stable IP %s for domain %s", assignedIpStr, domain),
			})
			return []common_net.Address{common_net.IPAddress(ip)} // Use aliased common_net
		}
		// If ParseIP fails, something is wrong, clean up the bad entry
		log.Record(&log.GeneralMessage{
			Severity: log.Severity_Error,
			Content:  fmt.Sprintf("FakeDNS: Found invalid IP string '%s' in domainToIp map for domain %s. Cleaning up.", assignedIpStr, domain),
		})
		delete(fkdns.domainToIp, domain)
		// Continue to allocation logic...
	}

	// 2. Calculate base IP from hash
	// Use the updated hashDomain function (XXH3)
	domainHash := hashDomain(domain)
	hashBig := big.NewInt(0).SetUint64(domainHash)

	// offset = hash % poolSize
	offset := big.NewInt(0).Mod(hashBig, fkdns.poolSize)

	// currentIPNum = startIPNum + offset
	currentIPNum := big.NewInt(0).Add(fkdns.startIPNum, offset)

	// 3. Linear Probing
	// Iterate at most poolSize times to prevent infinite loops and detect exhaustion
	numProbes := big.NewInt(0)

	for numProbes.Cmp(fkdns.poolSize) < 0 {
		// Ensure currentIPNum stays within the range [startIPNum, endIPNum]
		if currentIPNum.Cmp(fkdns.startIPNum) < 0 || currentIPNum.Cmp(fkdns.endIPNum) > 0 {
			log.Record(&log.GeneralMessage{
				Severity: log.Severity_Error,
				Content: fmt.Sprintf("FakeDNS: currentIPNum %s went out of range [%s, %s]. Aborting probe for domain %s.",
					currentIPNum.String(), fkdns.startIPNum.String(), fkdns.endIPNum.String(), domain),
			})
			return []common_net.Address{}
		}

		currentIP := bigIntToIP(currentIPNum, isIPv6)
		currentIpStr := currentIP.String()

		// Check occupancy
		existingDomain, occupied := fkdns.ipToDomain[currentIpStr]

		if !occupied {
			// Found an empty slot
			log.Record(&log.GeneralMessage{
				Severity: log.Severity_Debug,
				Content: fmt.Sprintf("FakeDNS: Assigning new IP %s to domain %s (XXH3 base offset: %s, Probes: %s)",
					currentIpStr, domain, offset.String(), numProbes.String()),
			})
			fkdns.ipToDomain[currentIpStr] = domain
			fkdns.domainToIp[domain] = currentIpStr
			return []common_net.Address{common_net.IPAddress(currentIP)} // Use aliased common_net
		} else if existingDomain == domain {
			// Found the correct, existing stable mapping for this domain during probing
			log.Record(&log.GeneralMessage{
				Severity: log.Severity_Debug,
				Content:  fmt.Sprintf("FakeDNS: Confirmed existing stable IP %s for domain %s during probing.", currentIpStr, domain),
			})
			return []common_net.Address{common_net.IPAddress(currentIP)} // Use aliased common_net
		}
		// else: Slot occupied by another domain, continue linear probing

		// Increment IP for next probe: currentIPNum = currentIPNum + 1
		currentIPNum.Add(currentIPNum, bigOne)

		// Wrap around if it exceeds the endIPNum
		if currentIPNum.Cmp(fkdns.endIPNum) > 0 {
			currentIPNum.Set(fkdns.startIPNum) // Wrap back to the start of the pool
		}

		numProbes.Add(numProbes, bigOne) // Increment probe count
	}

	// 4. Pool Depleted for this allocation
	// Use V2Ray logger
	log.Record(&log.GeneralMessage{
		Severity: log.Severity_Error,
		Content: fmt.Sprintf("%s for domain %s. Pool size: %s, Current occupancy: %d",
			errFakeDnsPoolDepleted.Error(), domain, fkdns.poolSize.String(), len(fkdns.ipToDomain)),
	})
	// Interface doesn't support returning errors, return empty slice
	return []common_net.Address{}
}

// GetDomainFromFakeDNS checks if an IP is a fake IP and returns the corresponding domain name.
func (fkdns *Holder) GetDomainFromFakeDNS(ip common_net.Address) string { // Use aliased common_net
	fkdns.mu.Lock()
	defer fkdns.mu.Unlock()

	if fkdns.ipRange == nil {
		return "" // Not initialized
	}

	// Check if IP is within the managed range first
	if !ip.Family().IsIP() || !fkdns.ipRange.Contains(ip.IP()) {
		return ""
	}

	ipStr := ip.IP().String()
	if domain, ok := fkdns.ipToDomain[ipStr]; ok {
		return domain
	}

	return ""
}

//---------------------------------------------------------
// HolderMulti Section - Updated error creation
//---------------------------------------------------------

type HolderMulti struct {
	holders []*Holder
}

func (h *HolderMulti) IsIPInIPPool(ip common_net.Address) bool { // Use aliased common_net
	if ip.Family().IsDomain() {
		return false
	}
	for _, v := range h.holders {
		if v.IsIPInIPPool(ip) {
			return true
		}
	}
	return false
}

func (h *HolderMulti) GetFakeIPForDomain3(domain string, ipv4, ipv6 bool) []common_net.Address { // Use aliased common_net
	var ret []common_net.Address
	for _, v := range h.holders {
		ret = append(ret, v.GetFakeIPForDomain3(domain, ipv4, ipv6)...)
	}
	return ret
}

func (h *HolderMulti) GetFakeIPForDomain(domain string) []common_net.Address { // Use aliased common_net
	var ret []common_net.Address
	for _, v := range h.holders {
		ret = append(ret, v.GetFakeIPForDomain(domain)...)
	}
	return ret
}

func (h *HolderMulti) GetDomainFromFakeDNS(ip common_net.Address) string { // Use aliased common_net
	for _, v := range h.holders {
		if domain := v.GetDomainFromFakeDNS(ip); domain != "" {
			return domain
		}
	}
	return ""
}

func (h *HolderMulti) IsEmpty() bool {
	return len(h.holders) == 0
}

func (h *HolderMulti) AddPool(poolConfig *FakeDnsPool) (*Holder, error) {
	newAddr, newIPRange, err := gonet.ParseCIDR(poolConfig.IpPool)
	if err != nil {
		return nil, newError("AddPool: Failed to parse CIDR").Base(err)
	}

	// Check if the holder is already started by checking its internal state
	running := false
	for _, v := range h.holders {
		v.mu.Lock()
		isInitialized := v.ipRange != nil
		v.mu.Unlock()
		if isInitialized {
			running = true
			break // Found one running pool, assume system is 'running'
		}
	}


	for _, v := range h.holders {
		v.mu.Lock() // Lock individual holder to access its state safely
		var currentIPRange *gonet.IPNet
		if v.ipRange != nil {
			currentIPRange = v.ipRange
		} else if v.config != nil {
			// Parse config's CIDR only if not already initialized
			_, parsedRange, parseErr := gonet.ParseCIDR(v.config.IpPool)
			if parseErr != nil {
				v.mu.Unlock() // Unlock before continuing/returning
				log.Record(&log.GeneralMessage{ // Log the error
					Severity: log.Severity_Error,
					Content:  fmt.Sprintf("FakeDNS: AddPool: Error parsing existing pool config CIDR %s: %v", v.config.IpPool, parseErr),
				})
				continue // Skip this potentially invalid holder
			}
			currentIPRange = parsedRange
		} else {
			v.mu.Unlock() // Unlock if holder has no range and no config
			continue
		}

		// Compare networks (canonical string representation)
		if currentIPRange.String() == newIPRange.String() {
			log.Record(&log.GeneralMessage{ // Log info
				Severity: log.Severity_Info,
				Content:  fmt.Sprintf("FakeDNS: AddPool found existing pool for CIDR %s", poolConfig.IpPool),
			})
			v.mu.Unlock() // Unlock before returning
			return v, nil // Return existing holder
		}

		// Overlap check
		containsOther := currentIPRange.Contains(newAddr) && currentIPRange.Mask.String() != newIPRange.Mask.String()
		isContainedByOther := newIPRange.Contains(currentIPRange.IP) && newIPRange.Mask.String() != currentIPRange.Mask.String()

		if containsOther || isContainedByOther {
		    v.mu.Unlock() // Unlock before returning error
			return nil, newError(fmt.Sprintf("Trying to add ip pool %s that overlaps with existing ip pool %s", newIPRange.String(), currentIPRange.String()))
		}
		v.mu.Unlock() // Unlock after checking this holder
	}

	// Create new holder
	holder, err := NewFakeDNSHolderConfigOnly(poolConfig)
	if err != nil {
		// Although unlikely now, still handle potential error
		return nil, newError("AddPool: Failed to create holder instance").Base(err)
	}

	// If other pools are already running, start this one immediately
	if running {
		if err := holder.Start(); err != nil {
			return nil, newError(fmt.Sprintf("Failed to start newly added pool %s", poolConfig.IpPool)).Base(err)
		}
	}

	h.holders = append(h.holders, holder)
	log.Record(&log.GeneralMessage{ // Log info
		Severity: log.Severity_Info,
		Content:  fmt.Sprintf("FakeDNS: Added new pool with CIDR %s", poolConfig.IpPool),
	})
	return holder, nil
}


func (h *HolderMulti) AddPoolMulti(poolMultiConfig *FakeDnsPoolMulti) (*HolderMulti, error) {
	holderMulti := &HolderMulti{} // This is a temporary holder for the result, not the main one 'h'
	if poolMultiConfig == nil {
		return holderMulti, nil // Nothing to add
	}
	addedHolders := make(map[*Holder]bool) // Track holders added to the result to avoid duplicates

	for _, poolConfig := range poolMultiConfig.Pools {
		// AddPool handles checks and creation/retrieval using the main holder 'h'
		pool, err := h.AddPool(poolConfig)
		if err != nil {
			return nil, newError(fmt.Sprintf("Failed to add pool during AddPoolMulti for CIDR %s", poolConfig.IpPool)).Base(err)
		}
		// Add the returned holder (either new or existing) to the result set if not already added
		if pool != nil && !addedHolders[pool] {
			holderMulti.holders = append(holderMulti.holders, pool)
			addedHolders[pool] = true
		}
	}
	return holderMulti, nil // Returned holderMulti holds references to pools managed by `h`
}


func (h *HolderMulti) Type() interface{} {
	return dns.FakeDNSEngineType()
}

func (h *HolderMulti) Start() error {
	if len(h.holders) == 0 {
		log.Record(&log.GeneralMessage{
			Severity: log.Severity_Warning,
			Content:  "FakeDNS Multi Holder starting with no pools configured.",
		})
	}
	for i, v := range h.holders {
		// Check if already started (e.g., added via AddPool when running)
		v.mu.Lock()
		isInitialized := v.ipRange != nil
		poolCIDR := "N/A"
		if v.config != nil {
			poolCIDR = v.config.IpPool
		} else if isInitialized {
            poolCIDR = v.ipRange.String()
        }
		v.mu.Unlock()

		if isInitialized {
			log.Record(&log.GeneralMessage{
				Severity: log.Severity_Debug,
				Content:  fmt.Sprintf("FakeDNS: Pool %d (%s) already initialized, skipping Start.", i, poolCIDR),
			})
			continue
		}

		log.Record(&log.GeneralMessage{
			Severity: log.Severity_Debug,
			Content:  fmt.Sprintf("FakeDNS: Starting pool %d with CIDR %s", i, poolCIDR),
		})
		if err := v.Start(); err != nil {
			return newError(fmt.Sprintf("Cannot start fake dns pool %d with CIDR %s", i, poolCIDR)).Base(err)
		}
	}
	log.Record(&log.GeneralMessage{
		Severity: log.Severity_Info,
		Content:  fmt.Sprintf("FakeDNS Multi Holder started successfully with %d pools.", len(h.holders)),
	})
	return nil
}


func (h *HolderMulti) Close() error {
	log.Record(&log.GeneralMessage{
		Severity: log.Severity_Info,
		Content:  fmt.Sprintf("FakeDNS Multi Holder closing %d pools.", len(h.holders)),
	})
	var firstErr error // Keep type implicit, newError returns *errors.Error
	for i, v := range h.holders {
		log.Record(&log.GeneralMessage{
			Severity: log.Severity_Debug,
			Content:  fmt.Sprintf("FakeDNS: Closing pool %d", i),
		})
		if err := v.Close(); err != nil {
			errMsg := fmt.Sprintf("FakeDNS: Error closing pool %d: %v", i, err)
			log.Record(&log.GeneralMessage{ // Log error
				Severity: log.Severity_Error,
				Content:  errMsg,
			})
			if firstErr == nil {
				firstErr = newError(errMsg)
			}
		}
	}
	h.holders = nil // Clear the slice
	return firstErr // Return the first error encountered, if any
}


// createHolderGroups is likely called by NewFakeDNSHolderMulti
func (h *HolderMulti) createHolderGroups(conf *FakeDnsPoolMulti) error {
	if conf == nil {
		return nil // Nothing to create
	}
	for _, poolConfig := range conf.Pools {
		// Use AddPool logic to handle potential overlaps and creation
		_, err := h.AddPool(poolConfig)
		if err != nil {
			return newError(fmt.Sprintf("Failed to create holder group for pool %s", poolConfig.IpPool)).Base(err)
		}
	}
	return nil
}

// NewFakeDNSHolderMulti creates a HolderMulti from configuration.
func NewFakeDNSHolderMulti(conf *FakeDnsPoolMulti) (*HolderMulti, error) {
	holderMulti := &HolderMulti{}
	if err := holderMulti.createHolderGroups(conf); err != nil {
		return nil, err // Error already contains details from createHolderGroups
	}
	return holderMulti, nil
}

// init registers the configuration loaders.
func init() {
	common.Must(common.RegisterConfig((*FakeDnsPool)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
		// Return the holder ready to be started
		return NewFakeDNSHolderConfigOnly(config.(*FakeDnsPool))
	}))

	common.Must(common.RegisterConfig((*FakeDnsPoolMulti)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
		// Return the multi-holder ready to be started
		return NewFakeDNSHolderMulti(config.(*FakeDnsPoolMulti))
	}))
}

[Losalado]

这是一个很好的想法，稳定的映射可以帮助V2Ray重启后设备快速恢复连接。实际使用时，我通常需要重启浏览器或者重新连接网络来刷新DNS。