Fix windows admin auto launch issues

Add android vpn options Support proxies icon configuration Optimize android immersion display Fix some issues
2024-09-26 14:29:04 +08:00
parent 82767325e5
commit c91d78b63f
80 changed files with 3922 additions and 2454 deletions
--- a/core/common.go
+++ b/core/common.go
@@ -3,14 +3,15 @@ package main
 import "C"
 import (
 	"context"
+	"core/state"
 	"errors"
-	route "github.com/metacubex/mihomo/hub/route"
+	"github.com/metacubex/mihomo/constant/features"
+	"github.com/metacubex/mihomo/hub/route"
 	"math"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"strings"
 	"sync"
 	"syscall"
 	"time"
@@ -234,151 +235,151 @@ func decorationConfig(profileId string, cfg config.RawConfig) *config.RawConfig
 	return prof
 }

-func Reduce[T any, U any](s []T, initVal U, f func(U, T) U) U {
-	for _, v := range s {
-		initVal = f(initVal, v)
-	}
-	return initVal
-}
+//func Reduce[T any, U any](s []T, initVal U, f func(U, T) U) U {
+//	for _, v := range s {
+//		initVal = f(initVal, v)
+//	}
+//	return initVal
+//}
+//
+//func Map[T, U any](slice []T, fn func(T) U) []U {
+//	result := make([]U, len(slice))
+//	for i, v := range slice {
+//		result[i] = fn(v)
+//	}
+//	return result
+//}
+//
+//func replaceFromMap(s string, m map[string]string) string {
+//	for k, v := range m {
+//		s = strings.ReplaceAll(s, k, v)
+//	}
+//	return s
+//}
+//
+//func removeDuplicateFromSlice[T any](slice []T) []T {
+//	result := make([]T, 0)
+//	seen := make(map[any]struct{})
+//	for _, value := range slice {
+//		if _, ok := seen[value]; !ok {
+//			result = append(result, value)
+//			seen[value] = struct{}{}
+//		}
+//	}
+//	return result
+//}

-func Map[T, U any](slice []T, fn func(T) U) []U {
-	result := make([]U, len(slice))
-	for i, v := range slice {
-		result[i] = fn(v)
-	}
-	return result
-}
-
-func replaceFromMap(s string, m map[string]string) string {
-	for k, v := range m {
-		s = strings.ReplaceAll(s, k, v)
-	}
-	return s
-}
-
-func removeDuplicateFromSlice[T any](slice []T) []T {
-	result := make([]T, 0)
-	seen := make(map[any]struct{})
-	for _, value := range slice {
-		if _, ok := seen[value]; !ok {
-			result = append(result, value)
-			seen[value] = struct{}{}
-		}
-	}
-	return result
-}
-
-func generateProxyGroupAndRule(proxyGroup *[]map[string]any, rule *[]string) {
-	var replacements = map[string]string{}
-	var selectArr []map[string]any
-	var urlTestArr []map[string]any
-	var fallbackArr []map[string]any
-	for _, group := range *proxyGroup {
-		switch group["type"] {
-		case "select":
-			selectArr = append(selectArr, group)
-			replacements[group["name"].(string)] = "Proxy"
-			break
-		case "url-test":
-			urlTestArr = append(urlTestArr, group)
-			replacements[group["name"].(string)] = "Auto"
-			break
-		case "fallback":
-			fallbackArr = append(fallbackArr, group)
-			replacements[group["name"].(string)] = "Fallback"
-			break
-		default:
-			break
-		}
-	}
-
-	ProxyProxies := Reduce(selectArr, []string{}, func(res []string, cur map[string]any) []string {
-		if cur["proxies"] == nil {
-			return res
-		}
-		for _, proxyName := range cur["proxies"].([]interface{}) {
-			if str, ok := proxyName.(string); ok {
-				str = replaceFromMap(str, replacements)
-				if str != "Proxy" {
-					res = append(res, str)
-				}
-			}
-		}
-		return res
-	})
-
-	ProxyProxies = removeDuplicateFromSlice(ProxyProxies)
-
-	AutoProxies := Reduce(urlTestArr, []string{}, func(res []string, cur map[string]any) []string {
-		if cur["proxies"] == nil {
-			return res
-		}
-		for _, proxyName := range cur["proxies"].([]interface{}) {
-			if str, ok := proxyName.(string); ok {
-				str = replaceFromMap(str, replacements)
-				if str != "Auto" {
-					res = append(res, str)
-				}
-			}
-		}
-		return res
-	})
-
-	AutoProxies = removeDuplicateFromSlice(AutoProxies)
-
-	FallbackProxies := Reduce(fallbackArr, []string{}, func(res []string, cur map[string]any) []string {
-		if cur["proxies"] == nil {
-			return res
-		}
-		for _, proxyName := range cur["proxies"].([]interface{}) {
-			if str, ok := proxyName.(string); ok {
-				str = replaceFromMap(str, replacements)
-				if str != "Fallback" {
-					res = append(res, str)
-				}
-			}
-		}
-		return res
-	})
-
-	FallbackProxies = removeDuplicateFromSlice(FallbackProxies)
-
-	var computedProxyGroup []map[string]any
-
-	if len(ProxyProxies) > 0 {
-		computedProxyGroup = append(computedProxyGroup,
-			map[string]any{
-				"name":    "Proxy",
-				"type":    "select",
-				"proxies": ProxyProxies,
-			})
-	}
-
-	if len(AutoProxies) > 0 {
-		computedProxyGroup = append(computedProxyGroup,
-			map[string]any{
-				"name":    "Auto",
-				"type":    "url-test",
-				"proxies": AutoProxies,
-			})
-	}
-
-	if len(FallbackProxies) > 0 {
-		computedProxyGroup = append(computedProxyGroup,
-			map[string]any{
-				"name":    "Fallback",
-				"type":    "fallback",
-				"proxies": FallbackProxies,
-			})
-	}
-
-	computedRule := Map(*rule, func(value string) string {
-		return replaceFromMap(value, replacements)
-	})
-
-	*proxyGroup = computedProxyGroup
-	*rule = computedRule
-}
+//func generateProxyGroupAndRule(proxyGroup *[]map[string]any, rule *[]string) {
+//	var replacements = map[string]string{}
+//	var selectArr []map[string]any
+//	var urlTestArr []map[string]any
+//	var fallbackArr []map[string]any
+//	for _, group := range *proxyGroup {
+//		switch group["type"] {
+//		case "select":
+//			selectArr = append(selectArr, group)
+//			replacements[group["name"].(string)] = "Proxy"
+//			break
+//		case "url-test":
+//			urlTestArr = append(urlTestArr, group)
+//			replacements[group["name"].(string)] = "Auto"
+//			break
+//		case "fallback":
+//			fallbackArr = append(fallbackArr, group)
+//			replacements[group["name"].(string)] = "Fallback"
+//			break
+//		default:
+//			break
+//		}
+//	}
+//
+//	ProxyProxies := Reduce(selectArr, []string{}, func(res []string, cur map[string]any) []string {
+//		if cur["proxies"] == nil {
+//			return res
+//		}
+//		for _, proxyName := range cur["proxies"].([]interface{}) {
+//			if str, ok := proxyName.(string); ok {
+//				str = replaceFromMap(str, replacements)
+//				if str != "Proxy" {
+//					res = append(res, str)
+//				}
+//			}
+//		}
+//		return res
+//	})
+//
+//	ProxyProxies = removeDuplicateFromSlice(ProxyProxies)
+//
+//	AutoProxies := Reduce(urlTestArr, []string{}, func(res []string, cur map[string]any) []string {
+//		if cur["proxies"] == nil {
+//			return res
+//		}
+//		for _, proxyName := range cur["proxies"].([]interface{}) {
+//			if str, ok := proxyName.(string); ok {
+//				str = replaceFromMap(str, replacements)
+//				if str != "Auto" {
+//					res = append(res, str)
+//				}
+//			}
+//		}
+//		return res
+//	})
+//
+//	AutoProxies = removeDuplicateFromSlice(AutoProxies)
+//
+//	FallbackProxies := Reduce(fallbackArr, []string{}, func(res []string, cur map[string]any) []string {
+//		if cur["proxies"] == nil {
+//			return res
+//		}
+//		for _, proxyName := range cur["proxies"].([]interface{}) {
+//			if str, ok := proxyName.(string); ok {
+//				str = replaceFromMap(str, replacements)
+//				if str != "Fallback" {
+//					res = append(res, str)
+//				}
+//			}
+//		}
+//		return res
+//	})
+//
+//	FallbackProxies = removeDuplicateFromSlice(FallbackProxies)
+//
+//	var computedProxyGroup []map[string]any
+//
+//	if len(ProxyProxies) > 0 {
+//		computedProxyGroup = append(computedProxyGroup,
+//			map[string]any{
+//				"name":    "Proxy",
+//				"type":    "select",
+//				"proxies": ProxyProxies,
+//			})
+//	}
+//
+//	if len(AutoProxies) > 0 {
+//		computedProxyGroup = append(computedProxyGroup,
+//			map[string]any{
+//				"name":    "Auto",
+//				"type":    "url-test",
+//				"proxies": AutoProxies,
+//			})
+//	}
+//
+//	if len(FallbackProxies) > 0 {
+//		computedProxyGroup = append(computedProxyGroup,
+//			map[string]any{
+//				"name":    "Fallback",
+//				"type":    "fallback",
+//				"proxies": FallbackProxies,
+//			})
+//	}
+//
+//	computedRule := Map(*rule, func(value string) string {
+//		return replaceFromMap(value, replacements)
+//	})
+//
+//	*proxyGroup = computedProxyGroup
+//	*rule = computedRule
+//}

 func genHosts(hosts, patchHosts map[string]any) {
 	for k, v := range patchHosts {
@@ -468,7 +469,9 @@ func updateListeners(general *config.General, listeners map[string]constant.Inbo
 	listener.ReCreateShadowSocks(general.ShadowSocksConfig, tunnel.Tunnel)
 	listener.ReCreateVmess(general.VmessConfig, tunnel.Tunnel)
 	listener.ReCreateTuic(general.TuicServer, tunnel.Tunnel)
-	listener.ReCreateTun(general.Tun, tunnel.Tunnel)
+	if !features.Android {
+		listener.ReCreateTun(general.Tun, tunnel.Tunnel)
+	}
 }

 func stopListeners() {
@@ -522,7 +525,7 @@ func patchSelectGroup() {
 }

 func applyConfig() error {
-	cfg, err := config.ParseRawConfig(currentRawConfig)
+	cfg, err := config.ParseRawConfig(state.CurrentRawConfig)
 	if err != nil {
 		cfg, _ = config.ParseRawConfig(config.DefaultRawConfig())
 	}
--- a/core/hub.go
+++ b/core/hub.go
@@ -7,6 +7,7 @@ import "C"
 import (
 	"context"
 	bridge "core/dart-bridge"
+	"core/state"
 	"encoding/json"
 	"fmt"
 	"github.com/metacubex/mihomo/common/utils"
@@ -30,8 +31,6 @@ import (
 	"github.com/metacubex/mihomo/tunnel/statistic"
 )

-var currentRawConfig = config.DefaultRawConfig()
-
 var configParams = ConfigExtendedParams{}

 var externalProviders = map[string]cp.Provider{}
@@ -124,7 +123,7 @@ func updateConfig(s *C.char, port C.longlong) {
 		}
 		configParams = params.Params
 		prof := decorationConfig(params.ProfileId, params.Config)
-		currentRawConfig = prof
+		state.CurrentRawConfig = prof
 		err = applyConfig()
 		if err != nil {
 			bridge.SendToPort(i, err.Error())
@@ -184,7 +183,7 @@ func changeProxy(s *C.char) {

 //export getTraffic
 func getTraffic() *C.char {
-	up, down := statistic.DefaultManager.Current(state.OnlyProxy)
+	up, down := statistic.DefaultManager.Current(state.CurrentState.OnlyProxy)
 	traffic := map[string]int64{
 		"up":   up,
 		"down": down,
@@ -199,7 +198,7 @@ func getTraffic() *C.char {

 //export getTotalTraffic
 func getTotalTraffic() *C.char {
-	up, down := statistic.DefaultManager.Total(state.OnlyProxy)
+	up, down := statistic.DefaultManager.Total(state.CurrentState.OnlyProxy)
 	traffic := map[string]int64{
 		"up":   up,
 		"down": down,
--- a/core/state.go
+++ b/core/state.go
@@ -2,37 +2,33 @@ package main

 import "C"
 import (
+	"core/state"
 	"encoding/json"
 	"fmt"
 )

-type AccessControl struct {
-	Mode              string   `json:"mode"`
-	AcceptList        []string `json:"acceptList"`
-	RejectList        []string `json:"rejectList"`
-	IsFilterSystemApp bool     `json:"isFilterSystemApp"`
+//export getCurrentProfileName
+func getCurrentProfileName() *C.char {
+	if state.CurrentState == nil {
+		return C.CString("")
+	}
+	return C.CString(state.CurrentState.CurrentProfileName)
 }

-type AndroidProps struct {
-	Enable        bool           `json:"enable"`
-	AccessControl *AccessControl `json:"accessControl"`
-	AllowBypass   bool           `json:"allowBypass"`
-	SystemProxy   bool           `json:"systemProxy"`
-	Ipv6          bool           `json:"ipv6"`
-}
-
-type State struct {
-	AndroidProps
-	CurrentProfileName string `json:"currentProfileName"`
-	MixedPort          int    `json:"mixedPort"`
-	OnlyProxy          bool   `json:"onlyProxy"`
-}
-
-var state State
-
-//export getState
-func getState() *C.char {
-	data, err := json.Marshal(state)
+//export getAndroidVpnOptions
+func getAndroidVpnOptions() *C.char {
+	options := state.AndroidVpnOptions{
+		Enable:           state.CurrentState.Enable,
+		Port:             state.CurrentRawConfig.MixedPort,
+		Ipv4Address:      state.DefaultIpv4Address,
+		Ipv6Address:      state.GetIpv6Address(),
+		AccessControl:    state.CurrentState.AccessControl,
+		SystemProxy:      state.CurrentState.SystemProxy,
+		AllowBypass:      state.CurrentState.AllowBypass,
+		BypassDomain:     state.CurrentState.BypassDomain,
+		DnsServerAddress: state.GetDnsServerAddress(),
+	}
+	data, err := json.Marshal(options)
 	if err != nil {
 		fmt.Println("Error:", err)
 		return C.CString("")
@@ -43,7 +39,7 @@ func getState() *C.char {
 //export setState
 func setState(s *C.char) {
 	paramsString := C.GoString(s)
-	err := json.Unmarshal([]byte(paramsString), &state)
+	err := json.Unmarshal([]byte(paramsString), state.CurrentState)
 	if err != nil {
 		return
 	}
--- a/core/state/state.go
+++ b/core/state/state.go
@@ -0,0 +1,59 @@
+package state
+
+import "github.com/metacubex/mihomo/config"
+
+var DefaultIpv4Address = "172.19.0.1/30"
+var DefaultDnsAddress = "172.19.0.2"
+var DefaultIpv6Address = "fdfe:dcba:9876::1/126"
+
+var CurrentRawConfig = config.DefaultRawConfig()
+
+type AndroidVpnOptions struct {
+	Enable           bool           `json:"enable"`
+	Port             int            `json:"port"`
+	AccessControl    *AccessControl `json:"accessControl"`
+	AllowBypass      bool           `json:"allowBypass"`
+	SystemProxy      bool           `json:"systemProxy"`
+	BypassDomain     []string       `json:"bypassDomain"`
+	Ipv4Address      string         `json:"ipv4Address"`
+	Ipv6Address      string         `json:"ipv6Address"`
+	DnsServerAddress string         `json:"dnsServerAddress"`
+}
+
+type AccessControl struct {
+	Mode              string   `json:"mode"`
+	AcceptList        []string `json:"acceptList"`
+	RejectList        []string `json:"rejectList"`
+	IsFilterSystemApp bool     `json:"isFilterSystemApp"`
+}
+
+type AndroidVpnRawOptions struct {
+	Enable        bool           `json:"enable"`
+	AccessControl *AccessControl `json:"accessControl"`
+	AllowBypass   bool           `json:"allowBypass"`
+	SystemProxy   bool           `json:"systemProxy"`
+	Ipv6          bool           `json:"ipv6"`
+	BypassDomain  []string       `json:"bypassDomain"`
+}
+
+type State struct {
+	AndroidVpnRawOptions
+	CurrentProfileName string `json:"currentProfileName"`
+	OnlyProxy          bool   `json:"onlyProxy"`
+}
+
+var CurrentState = &State{}
+
+func GetIpv6Address() string {
+	if CurrentState.Ipv6 {
+		return DefaultIpv6Address
+	} else {
+		return ""
+	}
+}
+
+func GetDnsServerAddress() string {
+	//prefix, _ := netip.ParsePrefix(DefaultIpv4Address)
+	//return prefix.Addr().String()
+	return DefaultDnsAddress
+}
--- a/core/tun.go
+++ b/core/tun.go
@@ -6,7 +6,6 @@ import "C"
 import (
 	"core/platform"
 	t "core/tun"
-	"encoding/json"
 	"errors"
 	"github.com/metacubex/mihomo/listener/sing_tun"
 	"strconv"
@@ -42,11 +41,10 @@ var (
 )

 //export startTUN
-func startTUN(s *C.char, port C.longlong) {
+func startTUN(fd C.int, port C.longlong) {
 	i := int64(port)
 	ServicePort = i
-	paramsString := C.GoString(s)
-	if paramsString == "" {
+	if fd == 0 {
 		tunLock.Lock()
 		defer tunLock.Unlock()
 		now := time.Now()
@@ -61,20 +59,8 @@ func startTUN(s *C.char, port C.longlong) {
 	go func() {
 		tunLock.Lock()
 		defer tunLock.Unlock()
-
-		var tunProps = &t.Props{}
-		err := json.Unmarshal([]byte(paramsString), tunProps)
-		if err != nil {
-			log.Errorln("startTUN error: %v", err)
-			return
-		}
-
-		tunListener, err = t.Start(*tunProps)
-
-		if err != nil {
-			return
-		}
-
+		f := int(fd)
+		tunListener, _ = t.Start(f)
 		if tunListener != nil {
 			log.Infoln("TUN address: %v", tunListener.Address())
 		}
--- a/core/tun/tun.go
+++ b/core/tun/tun.go
@@ -4,7 +4,7 @@ package tun

 import "C"
 import (
-	"github.com/metacubex/mihomo/constant"
+	"core/state"
 	LC "github.com/metacubex/mihomo/listener/config"
 	"github.com/metacubex/mihomo/listener/sing_tun"
 	"github.com/metacubex/mihomo/log"
@@ -23,17 +23,17 @@ type Props struct {
 	Dns6     string `json:"dns6"`
 }

-func Start(tunProps Props) (*sing_tun.Listener, error) {
+func Start(fd int) (*sing_tun.Listener, error) {
 	var prefix4 []netip.Prefix
-	tempPrefix4, err := netip.ParsePrefix(tunProps.Gateway)
+	tempPrefix4, err := netip.ParsePrefix(state.DefaultIpv4Address)
 	if err != nil {
 		log.Errorln("startTUN error:", err)
 		return nil, err
 	}
 	prefix4 = append(prefix4, tempPrefix4)
 	var prefix6 []netip.Prefix
-	if tunProps.Gateway6 != "" {
-		tempPrefix6, err := netip.ParsePrefix(tunProps.Gateway6)
+	if state.CurrentState.Ipv6 {
+		tempPrefix6, err := netip.ParsePrefix(state.DefaultIpv6Address)
 		if err != nil {
 			log.Errorln("startTUN error:", err)
 			return nil, err
@@ -42,22 +42,19 @@ func Start(tunProps Props) (*sing_tun.Listener, error) {
 	}

 	var dnsHijack []string
-	dnsHijack = append(dnsHijack, net.JoinHostPort(tunProps.Dns, "53"))
-	if tunProps.Dns6 != "" {
-		dnsHijack = append(dnsHijack, net.JoinHostPort(tunProps.Dns6, "53"))
-	}
+	dnsHijack = append(dnsHijack, net.JoinHostPort(state.GetDnsServerAddress(), "53"))

 	options := LC.Tun{
 		Enable:              true,
-		Device:              sing_tun.InterfaceName,
-		Stack:               constant.TunMixed,
+		Device:              state.CurrentRawConfig.Tun.Device,
+		Stack:               state.CurrentRawConfig.Tun.Stack,
 		DNSHijack:           dnsHijack,
 		AutoRoute:           false,
 		AutoDetectInterface: false,
 		Inet4Address:        prefix4,
 		Inet6Address:        prefix6,
 		MTU:                 9000,
-		FileDescriptor:      tunProps.Fd,
+		FileDescriptor:      fd,
 	}

 	listener, err := sing_tun.New(options, tunnel.Tunnel)