Merge c9e273e856 into 52c91e0862

Currently ip.IsPrivate and netip.Addr.IsPrivate only matches a part of private IPs.

adapter/provider/parser.go

@@ -28,7 +28,10 @@ type healthCheckSchema struct {
 }
 
 type OverrideSchema struct {
+	TFO              *bool   `provider:"tfo,omitempty"`
+	MPTcp            *bool   `provider:"mptcp,omitempty"`
 	UDP              *bool   `provider:"udp,omitempty"`
+	UDPOverTCP       *bool   `provider:"udp-over-tcp,omitempty"`
 	Up               *string `provider:"up,omitempty"`
 	Down             *string `provider:"down,omitempty"`
 	DialerProxy      *string `provider:"dialer-proxy,omitempty"`

adapter/provider/provider.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"reflect"
 	"runtime"
 	"strings"
 	"time"
@@ -373,37 +374,23 @@ func proxiesParseAndFilter(filter string, excludeFilter string, excludeTypeArray
 					mapping["dialer-proxy"] = dialerProxy
 				}
 
-				if override.UDP != nil {
-					mapping["udp"] = *override.UDP
-				}
-				if override.Up != nil {
-					mapping["up"] = *override.Up
-				}
-				if override.Down != nil {
-					mapping["down"] = *override.Down
-				}
-				if override.DialerProxy != nil {
-					mapping["dialer-proxy"] = *override.DialerProxy
-				}
-				if override.SkipCertVerify != nil {
-					mapping["skip-cert-verify"] = *override.SkipCertVerify
-				}
-				if override.Interface != nil {
-					mapping["interface-name"] = *override.Interface
-				}
-				if override.RoutingMark != nil {
-					mapping["routing-mark"] = *override.RoutingMark
-				}
-				if override.IPVersion != nil {
-					mapping["ip-version"] = *override.IPVersion
-				}
-				if override.AdditionalPrefix != nil {
-					name := mapping["name"].(string)
-					mapping["name"] = *override.AdditionalPrefix + name
-				}
-				if override.AdditionalSuffix != nil {
-					name := mapping["name"].(string)
-					mapping["name"] = name + *override.AdditionalSuffix
+				val := reflect.ValueOf(override)
+				for i := 0; i < val.NumField(); i++ {
+					field := val.Field(i)
+					if field.IsNil() {
+						continue
+					}
+					fieldName := strings.Split(val.Type().Field(i).Tag.Get("provider"), ",")[0]
+					switch fieldName {
+					case "additional-prefix":
+						name := mapping["name"].(string)
+						mapping["name"] = *field.Interface().(*string) + name
+					case "additional-suffix":
+						name := mapping["name"].(string)
+						mapping["name"] = name + *field.Interface().(*string)
+					default:
+						mapping[fieldName] = *field.Interface().(*string)
+					}
 				}
 
 				proxy, err := adapter.ParseProxy(mapping)

common/nnip/netip.go

@@ -6,6 +6,28 @@ import (
 	"net/netip"
 )
 
+// Private IP CIDRs
+var privateIPCIDRs = []string{
+	"0.0.0.0/8",
+	"10.0.0.0/8",
+	"100.64.0.0/10",
+	"127.0.0.0/8",
+	"169.254.0.0/16",
+	"172.16.0.0/12",
+	"192.0.0.0/24",
+	"192.0.2.0/24",
+	"192.88.99.0/24",
+	"192.168.0.0/16",
+	"198.18.0.0/15",
+	"198.51.100.0/24",
+	"203.0.113.0/24",
+	"224.0.0.0/3",
+	"::/127",
+	"fc00::/7",
+	"fe80::/10",
+	"ff00::/8",
+}
+
 // IpToAddr converts the net.IP to netip.Addr.
 // If slice's length is not 4 or 16, IpToAddr returns netip.Addr{}
 func IpToAddr(slice net.IP) netip.Addr {
@@ -51,3 +73,18 @@ func UnMasked(p netip.Prefix) netip.Addr {
 	}
 	return addr
 }
+
+// IsPrivateIP returns whether IP is private
+// If IP is private, return true, else return false
+func IsPrivateIP(ip netip.Addr) bool {
+	for _, network := range privateIPCIDRs {
+		_, subnet, err := net.ParseCIDR(network)
+		if err != nil {
+			continue
+		}
+		if subnet.Contains(ip.AsSlice()) {
+			return true
+		}
+	}
+	return false
+}

dns/filters.go

@@ -4,6 +4,7 @@ import (
 	"net/netip"
 	"strings"
 
+	"github.com/metacubex/mihomo/common/nnip"
 	"github.com/metacubex/mihomo/component/geodata"
 	"github.com/metacubex/mihomo/component/geodata/router"
 	"github.com/metacubex/mihomo/component/mmdb"
@@ -26,7 +27,7 @@ func (gf *geoipFilter) Match(ip netip.Addr) bool {
 	if !C.GeodataMode {
 		codes := mmdb.IPInstance().LookupCode(ip.AsSlice())
 		for _, code := range codes {
-			if !strings.EqualFold(code, gf.code) && !ip.IsPrivate() {
+			if !strings.EqualFold(code, gf.code) && !nnip.IsPrivateIP(ip) {
 				return true
 			}
 		}
@@ -35,13 +36,13 @@ func (gf *geoipFilter) Match(ip netip.Addr) bool {
 
 	if geoIPMatcher == nil {
 		var err error
-		geoIPMatcher, _, err = geodata.LoadGeoIPMatcher("CN")
+		geoIPMatcher, _, err = geodata.LoadGeoIPMatcher(gf.code)
 		if err != nil {
 			log.Errorln("[GeoIPFilter] LoadGeoIPMatcher error: %s", err.Error())
 			return false
 		}
 	}
-	return !geoIPMatcher.Match(ip)
+	return !geoIPMatcher.Match(ip) && !nnip.IsPrivateIP(ip)
 }
 
 type ipnetFilter struct {