feat: host support domain and multiple ips

component/resolver/host.go

@@ -0,0 +1,78 @@
+package resolver
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"net/netip"
+	"reflect"
+	"strings"
+)
+
+type HostValue struct {
+	IsDomain bool
+	IPs      []netip.Addr
+	Domain   string
+}
+
+func NewHostValue(value any) (HostValue, error) {
+	isDomain := true
+	ips := make([]netip.Addr, 0)
+	domain := ""
+	switch reflect.TypeOf(value).Kind() {
+	case reflect.Slice, reflect.Array:
+		isDomain = false
+		origin := reflect.ValueOf(value)
+		for i := 0; i < origin.Len(); i++ {
+			if ip, err := netip.ParseAddr(fmt.Sprintf("%v", origin.Index(i))); err == nil {
+				ips = append(ips, ip)
+			} else {
+				return HostValue{}, err
+			}
+		}
+	case reflect.String:
+		host := fmt.Sprintf("%v", value)
+		if ip, err := netip.ParseAddr(host); err == nil {
+			ips = append(ips, ip)
+			isDomain = false
+		} else {
+			domain = host
+		}
+	default:
+		return HostValue{}, errors.New("value format error, must be string or array")
+	}
+	if isDomain {
+		return NewHostValueByDomain(domain)
+	} else {
+		return NewHostValueByIPs(ips)
+	}
+}
+
+func NewHostValueByIPs(ips []netip.Addr) (HostValue, error) {
+	if len(ips) == 0 {
+		return HostValue{}, errors.New("ip list is empty")
+	}
+	return HostValue{
+		IsDomain: false,
+		IPs:      ips,
+	}, nil
+}
+
+func NewHostValueByDomain(domain string) (HostValue, error) {
+	domain = strings.Trim(domain, ".")
+	item := strings.Split(domain, ".")
+	if len(item) < 2 {
+		return HostValue{}, errors.New("invaild domain")
+	}
+	return HostValue{
+		IsDomain: true,
+		Domain:   domain,
+	}, nil
+}
+
+func (hv HostValue) RandIP() (netip.Addr, error) {
+	if hv.IsDomain {
+		return netip.Addr{}, errors.New("value type is error")
+	}
+	return hv.IPs[rand.Intn(len(hv.IPs)-1)], nil
+}

component/resolver/resolver.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/Dreamacro/clash/common/utils"
 	"github.com/Dreamacro/clash/component/trie"
 
 	"github.com/miekg/dns"
@@ -27,7 +28,7 @@ var (
 	DisableIPv6 = true
 
 	// DefaultHosts aim to resolve hosts
-	DefaultHosts = trie.New[netip.Addr]()
+	DefaultHosts = trie.New[HostValue]()
 
 	// DefaultDNSTimeout defined the default dns request timeout
 	DefaultDNSTimeout = time.Second * 5
@@ -52,8 +53,14 @@ type Resolver interface {
 // LookupIPv4WithResolver same as LookupIPv4, but with a resolver
 func LookupIPv4WithResolver(ctx context.Context, host string, r Resolver) ([]netip.Addr, error) {
 	if node := DefaultHosts.Search(host); node != nil {
-		if ip := node.Data(); ip.Is4() {
-			return []netip.Addr{node.Data()}, nil
+		if value := node.Data(); !value.IsDomain {
+			if addrs := utils.Filter(value.IPs, func(ip netip.Addr) bool {
+				return ip.Is4()
+			}); len(addrs) > 0 {
+				return addrs, nil
+			}
+		}else{
+			return LookupIPv4WithResolver(ctx,value.Domain,r)
 		}
 	}
 
@@ -107,8 +114,14 @@ func LookupIPv6WithResolver(ctx context.Context, host string, r Resolver) ([]net
 	}
 
 	if node := DefaultHosts.Search(host); node != nil {
-		if ip := node.Data(); ip.Is6() {
-			return []netip.Addr{ip}, nil
+		if value := node.Data(); !value.IsDomain {
+			if addrs := utils.Filter(value.IPs, func(ip netip.Addr) bool {
+				return ip.Is6()
+			}); len(addrs) > 0 {
+				return addrs, nil
+			}
+		}else{
+			return LookupIPv6WithResolver(ctx,value.Domain,r)
 		}
 	}
 
@@ -156,7 +169,11 @@ func ResolveIPv6(ctx context.Context, host string) (netip.Addr, error) {
 // LookupIPWithResolver same as LookupIP, but with a resolver
 func LookupIPWithResolver(ctx context.Context, host string, r Resolver) ([]netip.Addr, error) {
 	if node := DefaultHosts.Search(host); node != nil {
-		return []netip.Addr{node.Data()}, nil
+		if !node.Data().IsDomain{
+			return node.Data().IPs, nil
+		}else{
+			return LookupIPWithResolver(ctx,node.Data().Domain,r)
+		}
 	}
 
 	if r != nil {