Add runtime warnings

route/router.go

@@ -21,6 +21,7 @@ import (
 	"github.com/sagernet/sing-box/common/process"
 	"github.com/sagernet/sing-box/common/sniff"
 	"github.com/sagernet/sing-box/common/urltest"
+	"github.com/sagernet/sing-box/common/warning"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
 	"github.com/sagernet/sing-box/option"
@@ -38,6 +39,27 @@ import (
 	"golang.org/x/net/dns/dnsmessage"
 )
 
+var warnDefaultInterfaceOnUnsupportedPlatform = warning.New(
+	func() bool {
+		return !(C.IsLinux || C.IsWindows)
+	},
+	"route option `default_mark` is only supported on Linux and Windows",
+)
+
+var warnDefaultMarkOnNonLinux = warning.New(
+	func() bool {
+		return !C.IsLinux
+	},
+	"route option `default_mark` is only supported on Linux",
+)
+
+var warnFindProcessOnUnsupportedPlatform = warning.New(
+	func() bool {
+		return !(C.IsLinux || C.IsWindows || C.IsDarwin)
+	},
+	"route option `find_process` is only supported on Linux, Windows, and Mac OS X",
+)
+
 var _ adapter.Router = (*Router)(nil)
 
 type Router struct {
@@ -75,6 +97,16 @@ type Router struct {
 }
 
 func NewRouter(ctx context.Context, logger log.ContextLogger, dnsLogger log.ContextLogger, options option.RouteOptions, dnsOptions option.DNSOptions) (*Router, error) {
+	if options.DefaultInterface != "" {
+		warnDefaultInterfaceOnUnsupportedPlatform.Check()
+	}
+	if options.DefaultMark != 0 {
+		warnDefaultMarkOnNonLinux.Check()
+	}
+	if options.FindProcess {
+		warnFindProcessOnUnsupportedPlatform.Check()
+	}
+
 	router := &Router{
 		ctx:                   ctx,
 		logger:                logger,
@@ -225,9 +257,12 @@ func NewRouter(ctx context.Context, logger log.ContextLogger, dnsLogger log.Cont
 	if hasRule(options.Rules, isProcessRule) || hasDNSRule(dnsOptions.Rules, isProcessDNSRule) || options.FindProcess {
 		searcher, err := process.NewSearcher(logger)
 		if err != nil {
-			return nil, E.Cause(err, "create process searcher")
+			if err != os.ErrInvalid {
+				logger.Warn(E.Cause(err, "create process searcher"))
+			}
+		} else {
+			router.processSearcher = searcher
 		}
-		router.processSearcher = searcher
 	}
 	return router, nil
 }
@@ -388,7 +423,8 @@ func (r *Router) Start() error {
 		if starter, isStarter := r.processSearcher.(common.Starter); isStarter {
 			err := starter.Start()
 			if err != nil {
-				return E.Cause(err, "initialize process searcher")
+				r.logger.Error(E.Cause(err, "initialize process searcher"))
+				r.processSearcher = nil
 			}
 		}
 	}

route/rule_package_name.go

@@ -4,6 +4,13 @@ import (
 	"strings"
 
 	"github.com/sagernet/sing-box/adapter"
+	"github.com/sagernet/sing-box/common/warning"
+	C "github.com/sagernet/sing-box/constant"
+)
+
+var warnPackageNameOnNonAndroid = warning.New(
+	func() bool { return !C.IsAndroid },
+	"rule item `package_name` is only supported on Android",
 )
 
 var _ RuleItem = (*PackageNameItem)(nil)
@@ -14,6 +21,7 @@ type PackageNameItem struct {
 }
 
 func NewPackageNameItem(packageNameList []string) *PackageNameItem {
+	warnPackageNameOnNonAndroid.Check()
 	rule := &PackageNameItem{
 		packageNames: packageNameList,
 		packageMap:   make(map[string]bool),

route/rule_process.go

@@ -5,6 +5,13 @@ import (
 	"strings"
 
 	"github.com/sagernet/sing-box/adapter"
+	"github.com/sagernet/sing-box/common/warning"
+	C "github.com/sagernet/sing-box/constant"
+)
+
+var warnProcessNameOnNonSupportedPlatform = warning.New(
+	func() bool { return !(C.IsLinux || C.IsWindows || C.IsDarwin) },
+	"rule item `process_item` is only supported on Linux, Windows, and Mac OS X",
 )
 
 var _ RuleItem = (*ProcessItem)(nil)
@@ -15,6 +22,7 @@ type ProcessItem struct {
 }
 
 func NewProcessItem(processNameList []string) *ProcessItem {
+	warnProcessNameOnNonSupportedPlatform.Check()
 	rule := &ProcessItem{
 		processes:  processNameList,
 		processMap: make(map[string]bool),

route/rule_user.go

@@ -4,9 +4,22 @@ import (
 	"strings"
 
 	"github.com/sagernet/sing-box/adapter"
+	"github.com/sagernet/sing-box/common/warning"
+	C "github.com/sagernet/sing-box/constant"
 	F "github.com/sagernet/sing/common/format"
 )
 
+var (
+	warnUserOnNonLinux = warning.New(
+		func() bool { return !C.IsLinux },
+		"rule item `user` is only supported on Linux",
+	)
+	warnUserOnCGODisabled = warning.New(
+		func() bool { return !C.CGO_ENABLED },
+		"rule item `user` is only supported with CGO enabled, rebuild with CGO_ENABLED=1",
+	)
+)
+
 var _ RuleItem = (*UserItem)(nil)
 
 type UserItem struct {
@@ -15,6 +28,8 @@ type UserItem struct {
 }
 
 func NewUserItem(users []string) *UserItem {
+	warnUserOnNonLinux.Check()
+	warnUserOnCGODisabled.Check()
 	userMap := make(map[string]bool)
 	for _, protocol := range users {
 		userMap[protocol] = true

route/rule_user_id.go

@@ -4,9 +4,16 @@ import (
 	"strings"
 
 	"github.com/sagernet/sing-box/adapter"
+	"github.com/sagernet/sing-box/common/warning"
+	C "github.com/sagernet/sing-box/constant"
 	F "github.com/sagernet/sing/common/format"
 )
 
+var warnUserIDOnNonLinux = warning.New(
+	func() bool { return !C.IsLinux },
+	"rule item `user_id` is only supported on Linux",
+)
+
 var _ RuleItem = (*UserIdItem)(nil)
 
 type UserIdItem struct {
@@ -15,6 +22,7 @@ type UserIdItem struct {
 }
 
 func NewUserIDItem(userIdList []int32) *UserIdItem {
+	warnUserIDOnNonLinux.Check()
 	rule := &UserIdItem{
 		userIds:   userIdList,
 		userIdMap: make(map[int32]bool),