Invalid config check

option/config.go

@@ -1,5 +1,7 @@
 package option
 
+import "github.com/sagernet/sing/common"
+
 type Options struct {
 	Log       *LogOption    `json:"log"`
 	Inbounds  []Inbound     `json:"inbounds,omitempty"`
@@ -7,6 +9,13 @@ type Options struct {
 	Route     *RouteOptions `json:"route,omitempty"`
 }
 
+func (o Options) Equals(other Options) bool {
+	return common.ComparablePtrEquals(o.Log, other.Log) &&
+		common.SliceEquals(o.Inbounds, other.Inbounds) &&
+		common.ComparableSliceEquals(o.Outbounds, other.Outbounds) &&
+		common.PtrEquals(o.Route, other.Route)
+}
+
 type LogOption struct {
 	Disabled bool   `json:"disabled,omitempty"`
 	Level    string `json:"level,omitempty"`

option/inbound.go

@@ -3,52 +3,50 @@ package option
 import (
 	"encoding/json"
 
+	"github.com/sagernet/sing/common"
 	"github.com/sagernet/sing/common/auth"
 	E "github.com/sagernet/sing/common/exceptions"
 )
 
-var ErrUnknownInboundType = E.New("unknown inbound type")
-
 type _Inbound struct {
-	Tag                string                     `json:"tag,omitempty"`
-	Type               string                     `json:"type,omitempty"`
-	DirectOptions      *DirectInboundOptions      `json:"directOptions,omitempty"`
-	SocksOptions       *SimpleInboundOptions      `json:"socksOptions,omitempty"`
-	HTTPOptions        *SimpleInboundOptions      `json:"httpOptions,omitempty"`
-	MixedOptions       *SimpleInboundOptions      `json:"mixedOptions,omitempty"`
-	ShadowsocksOptions *ShadowsocksInboundOptions `json:"shadowsocksOptions,omitempty"`
+	Tag                string                    `json:"tag,omitempty"`
+	Type               string                    `json:"type"`
+	DirectOptions      DirectInboundOptions      `json:"-"`
+	SocksOptions       SimpleInboundOptions      `json:"-"`
+	HTTPOptions        SimpleInboundOptions      `json:"-"`
+	MixedOptions       SimpleInboundOptions      `json:"-"`
+	ShadowsocksOptions ShadowsocksInboundOptions `json:"-"`
 }
 
 type Inbound _Inbound
 
+func (i Inbound) Equals(other Inbound) bool {
+	return i.Type == other.Type &&
+		i.Tag == other.Tag &&
+		common.Equals(i.DirectOptions, other.DirectOptions) &&
+		common.Equals(i.SocksOptions, other.SocksOptions) &&
+		common.Equals(i.HTTPOptions, other.HTTPOptions) &&
+		common.Equals(i.MixedOptions, other.MixedOptions) &&
+		common.Equals(i.ShadowsocksOptions, other.ShadowsocksOptions)
+}
+
 func (i *Inbound) MarshalJSON() ([]byte, error) {
-	var options []byte
-	var err error
+	var v any
 	switch i.Type {
 	case "direct":
-		options, err = json.Marshal(i.DirectOptions)
+		v = i.DirectOptions
 	case "socks":
-		options, err = json.Marshal(i.SocksOptions)
+		v = i.SocksOptions
 	case "http":
-		options, err = json.Marshal(i.HTTPOptions)
+		v = i.HTTPOptions
 	case "mixed":
-		options, err = json.Marshal(i.MixedOptions)
+		v = i.MixedOptions
 	case "shadowsocks":
-		options, err = json.Marshal(i.ShadowsocksOptions)
+		v = i.ShadowsocksOptions
 	default:
-		return nil, E.Extend(ErrUnknownInboundType, i.Type)
+		return nil, E.New("unknown inbound type: ", i.Type)
 	}
-	if err != nil {
-		return nil, err
-	}
-	var content map[string]any
-	err = json.Unmarshal(options, &content)
-	if err != nil {
-		return nil, err
-	}
-	content["tag"] = i.Tag
-	content["type"] = i.Type
-	return json.Marshal(content)
+	return MarshallObjects(i, v)
 }
 
 func (i *Inbound) UnmarshalJSON(bytes []byte) error {
@@ -56,43 +54,29 @@ func (i *Inbound) UnmarshalJSON(bytes []byte) error {
 	if err != nil {
 		return err
 	}
+	var v any
 	switch i.Type {
 	case "direct":
-		if i.DirectOptions != nil {
-			break
-		}
-		err = json.Unmarshal(bytes, &i.DirectOptions)
+		v = &i.DirectOptions
 	case "socks":
-		if i.SocksOptions != nil {
-			break
-		}
-		err = json.Unmarshal(bytes, &i.SocksOptions)
+		v = &i.SocksOptions
 	case "http":
-		if i.HTTPOptions != nil {
-			break
-		}
-		err = json.Unmarshal(bytes, &i.HTTPOptions)
+		v = &i.HTTPOptions
 	case "mixed":
-		if i.MixedOptions != nil {
-			break
-		}
-		err = json.Unmarshal(bytes, &i.MixedOptions)
+		v = &i.MixedOptions
 	case "shadowsocks":
-		if i.ShadowsocksOptions != nil {
-			break
-		}
-		err = json.Unmarshal(bytes, &i.ShadowsocksOptions)
+		v = &i.ShadowsocksOptions
 	default:
-		return E.Extend(ErrUnknownInboundType, i.Type)
+		return nil
 	}
-	return err
+	return json.Unmarshal(bytes, v)
 }
 
 type ListenOptions struct {
 	Listen      ListenAddress `json:"listen"`
 	Port        uint16        `json:"listen_port"`
-	TCPFastOpen bool          `json:"tcpFastOpen,omitempty"`
-	UDPTimeout  int64         `json:"udpTimeout,omitempty"`
+	TCPFastOpen bool          `json:"tcp_fast_open,omitempty"`
+	UDPTimeout  int64         `json:"udp_timeout,omitempty"`
 }
 
 type SimpleInboundOptions struct {
@@ -100,11 +84,23 @@ type SimpleInboundOptions struct {
 	Users []auth.User `json:"users,omitempty"`
 }
 
+func (o SimpleInboundOptions) Equals(other SimpleInboundOptions) bool {
+	return o.ListenOptions == other.ListenOptions &&
+		common.ComparableSliceEquals(o.Users, other.Users)
+}
+
 type DirectInboundOptions struct {
 	ListenOptions
 	Network         NetworkList `json:"network,omitempty"`
-	OverrideAddress string      `json:"overrideAddress,omitempty"`
-	OverridePort    uint16      `json:"overridePort,omitempty"`
+	OverrideAddress string      `json:"override_address,omitempty"`
+	OverridePort    uint16      `json:"override_port,omitempty"`
+}
+
+func (o DirectInboundOptions) Equals(other DirectInboundOptions) bool {
+	return o.ListenOptions == other.ListenOptions &&
+		common.ComparableSliceEquals(o.Network, other.Network) &&
+		o.OverrideAddress == other.OverrideAddress &&
+		o.OverridePort == other.OverridePort
 }
 
 type ShadowsocksInboundOptions struct {
@@ -113,3 +109,10 @@ type ShadowsocksInboundOptions struct {
 	Method   string      `json:"method"`
 	Password string      `json:"password"`
 }
+
+func (o ShadowsocksInboundOptions) Equals(other ShadowsocksInboundOptions) bool {
+	return o.ListenOptions == other.ListenOptions &&
+		common.ComparableSliceEquals(o.Network, other.Network) &&
+		o.Method == other.Method &&
+		o.Password == other.Password
+}

option/json.go

@@ -0,0 +1,40 @@
+package option
+
+import (
+	"encoding/json"
+)
+
+func ToMap(v any) (map[string]any, error) {
+	bytes, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+	var content map[string]any
+	err = json.Unmarshal(bytes, &content)
+	if err != nil {
+		return nil, err
+	}
+	return content, nil
+}
+
+func MergeObjects(objects ...any) (map[string]any, error) {
+	content := make(map[string]any)
+	for _, object := range objects {
+		objectMap, err := ToMap(object)
+		if err != nil {
+			return nil, err
+		}
+		for k, v := range objectMap {
+			content[k] = v
+		}
+	}
+	return content, nil
+}
+
+func MarshallObjects(objects ...any) ([]byte, error) {
+	content, err := MergeObjects(objects...)
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(content)
+}

option/listable.go

@@ -2,7 +2,7 @@ package option
 
 import "encoding/json"
 
-type Listable[T any] []T
+type Listable[T comparable] []T
 
 func (l *Listable[T]) MarshalJSON() ([]byte, error) {
 	arrayList := []T(*l)

option/outbound.go

@@ -7,64 +7,43 @@ import (
 	M "github.com/sagernet/sing/common/metadata"
 )
 
-var ErrUnknownOutboundType = E.New("unknown outbound type")
-
 type _Outbound struct {
-	Tag                string                      `json:"tag,omitempty"`
-	Type               string                      `json:"type,omitempty"`
-	DirectOptions      *DirectOutboundOptions      `json:"directOptions,omitempty"`
-	ShadowsocksOptions *ShadowsocksOutboundOptions `json:"shadowsocksOptions,omitempty"`
+	Tag                string                     `json:"tag,omitempty"`
+	Type               string                     `json:"type,omitempty"`
+	DirectOptions      DirectOutboundOptions      `json:"-"`
+	ShadowsocksOptions ShadowsocksOutboundOptions `json:"-"`
 }
 
 type Outbound _Outbound
 
 func (i *Outbound) MarshalJSON() ([]byte, error) {
-	var options []byte
-	var err error
+	var v any
 	switch i.Type {
 	case "direct":
-		options, err = json.Marshal(i.DirectOptions)
+		v = i.DirectOptions
 	case "shadowsocks":
-		options, err = json.Marshal(i.ShadowsocksOptions)
+		v = i.ShadowsocksOptions
 	default:
-		return nil, E.Extend(ErrUnknownOutboundType, i.Type)
+		return nil, E.New("unknown outbound type: ", i.Type)
 	}
-	if err != nil {
-		return nil, err
-	}
-	var content map[string]any
-	err = json.Unmarshal(options, &content)
-	if err != nil {
-		return nil, err
-	}
-	content["tag"] = i.Tag
-	content["type"] = i.Type
-	return json.Marshal(content)
+	return MarshallObjects(i, v)
 }
 
 func (i *Outbound) UnmarshalJSON(bytes []byte) error {
-	if err := json.Unmarshal(bytes, (*_Outbound)(i)); err != nil {
+	err := json.Unmarshal(bytes, (*_Outbound)(i))
+	if err != nil {
 		return err
 	}
+	var v any
 	switch i.Type {
 	case "direct":
-		if i.DirectOptions != nil {
-			break
-		}
-		if err := json.Unmarshal(bytes, &i.DirectOptions); err != nil {
-			return err
-		}
+		v = &i.DirectOptions
 	case "shadowsocks":
-		if i.ShadowsocksOptions != nil {
-			break
-		}
-		if err := json.Unmarshal(bytes, &i.ShadowsocksOptions); err != nil {
-			return err
-		}
+		v = &i.ShadowsocksOptions
 	default:
-		return E.Extend(ErrUnknownOutboundType, i.Type)
+		return nil
 	}
-	return nil
+	return json.Unmarshal(bytes, v)
 }
 
 type DialerOptions struct {

option/route.go

@@ -4,16 +4,20 @@ import (
 	"encoding/json"
 
 	C "github.com/sagernet/sing-box/constant"
+	"github.com/sagernet/sing/common"
 	E "github.com/sagernet/sing/common/exceptions"
 )
 
-var ErrUnknownRuleType = E.New("unknown rule type")
-
 type RouteOptions struct {
 	GeoIP *GeoIPOptions `json:"geoip,omitempty"`
 	Rules []Rule        `json:"rules,omitempty"`
 }
 
+func (o RouteOptions) Equals(other RouteOptions) bool {
+	return common.ComparablePtrEquals(o.GeoIP, other.GeoIP) &&
+		common.SliceEquals(o.Rules, other.Rules)
+}
+
 type GeoIPOptions struct {
 	Path           string `json:"path,omitempty"`
 	DownloadURL    string `json:"download_url,omitempty"`
@@ -28,25 +32,23 @@ type _Rule struct {
 
 type Rule _Rule
 
+func (r Rule) Equals(other Rule) bool {
+	return r.Type == other.Type &&
+		common.PtrEquals(r.DefaultOptions, other.DefaultOptions) &&
+		common.PtrEquals(r.LogicalOptions, other.LogicalOptions)
+}
+
 func (r *Rule) MarshalJSON() ([]byte, error) {
-	var content map[string]any
+	var v any
 	switch r.Type {
-	case "", C.RuleTypeDefault:
-		return json.Marshal(r.DefaultOptions)
+	case C.RuleTypeDefault:
+		v = r.DefaultOptions
 	case C.RuleTypeLogical:
-		options, err := json.Marshal(r.LogicalOptions)
-		if err != nil {
-			return nil, err
-		}
-		err = json.Unmarshal(options, &content)
-		if err != nil {
-			return nil, err
-		}
-		content["type"] = r.Type
-		return json.Marshal(content)
+		v = r.LogicalOptions
 	default:
-		return nil, E.Extend(ErrUnknownRuleType, r.Type)
+		return nil, E.New("unknown rule type: " + r.Type)
 	}
+	return MarshallObjects(r, v)
 }
 
 func (r *Rule) UnmarshalJSON(bytes []byte) error {
@@ -54,21 +56,19 @@ func (r *Rule) UnmarshalJSON(bytes []byte) error {
 	if err != nil {
 		return err
 	}
-	switch r.Type {
-	case "", C.RuleTypeDefault:
-		if r.DefaultOptions == nil {
-			break
-		}
-		err = json.Unmarshal(bytes, r.DefaultOptions)
-	case C.RuleTypeLogical:
-		if r.LogicalOptions == nil {
-			break
-		}
-		err = json.Unmarshal(bytes, r.LogicalOptions)
-	default:
-		err = E.Extend(ErrUnknownRuleType, r.Type)
+	if r.Type == "" {
+		r.Type = C.RuleTypeDefault
 	}
-	return err
+	var v any
+	switch r.Type {
+	case C.RuleTypeDefault:
+		v = &r.DefaultOptions
+	case C.RuleTypeLogical:
+		v = &r.LogicalOptions
+	default:
+		return E.New("unknown rule type: " + r.Type)
+	}
+	return json.Unmarshal(bytes, v)
 }
 
 type DefaultRule struct {
@@ -90,8 +90,41 @@ type DefaultRule struct {
 	Outbound string `json:"outbound,omitempty"`
 }
 
+func (r DefaultRule) IsValid() bool {
+	var defaultValue DefaultRule
+	defaultValue.Outbound = r.Outbound
+	return !r.Equals(defaultValue)
+}
+
+func (r DefaultRule) Equals(other DefaultRule) bool {
+	return common.ComparableSliceEquals(r.Inbound, other.Inbound) &&
+		r.IPVersion == other.IPVersion &&
+		r.Network == other.Network &&
+		common.ComparableSliceEquals(r.Protocol, other.Protocol) &&
+		common.ComparableSliceEquals(r.Domain, other.Domain) &&
+		common.ComparableSliceEquals(r.DomainSuffix, other.DomainSuffix) &&
+		common.ComparableSliceEquals(r.DomainKeyword, other.DomainKeyword) &&
+		common.ComparableSliceEquals(r.SourceGeoIP, other.SourceGeoIP) &&
+		common.ComparableSliceEquals(r.GeoIP, other.GeoIP) &&
+		common.ComparableSliceEquals(r.SourceIPCIDR, other.SourceIPCIDR) &&
+		common.ComparableSliceEquals(r.IPCIDR, other.IPCIDR) &&
+		common.ComparableSliceEquals(r.SourcePort, other.SourcePort) &&
+		common.ComparableSliceEquals(r.Port, other.Port) &&
+		r.Outbound == other.Outbound
+}
+
 type LogicalRule struct {
 	Mode     string        `json:"mode"`
 	Rules    []DefaultRule `json:"rules,omitempty"`
 	Outbound string        `json:"outbound,omitempty"`
 }
+
+func (r LogicalRule) IsValid() bool {
+	return len(r.Rules) > 0 && common.All(r.Rules, DefaultRule.IsValid)
+}
+
+func (r LogicalRule) Equals(other LogicalRule) bool {
+	return r.Mode == other.Mode &&
+		common.SliceEquals(r.Rules, other.Rules) &&
+		r.Outbound == other.Outbound
+}