chore: 调整目录与包名一致

rules/logic/and.go

@@ -0,0 +1,67 @@
+package logic
+
+import (
+	"fmt"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/rules/common"
+	"strings"
+)
+
+type AND struct {
+	*common.Base
+	rules   []C.Rule
+	payload string
+	adapter string
+	needIP  bool
+}
+
+func (A *AND) ShouldFindProcess() bool {
+	return false
+}
+
+func NewAND(payload string, adapter string) (*AND, error) {
+	and := &AND{Base: &common.Base{}, payload: payload, adapter: adapter}
+	rules, err := parseRuleByPayload(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	and.rules = rules
+	payloads := make([]string, 0, len(rules))
+	for _, rule := range rules {
+		payloads = append(payloads, fmt.Sprintf("(%s,%s)", rule.RuleType().String(), rule.Payload()))
+		if rule.ShouldResolveIP() {
+			and.needIP = true
+			break
+		}
+	}
+
+	and.payload = fmt.Sprintf("(%s)", strings.Join(payloads, " && "))
+	return and, nil
+}
+
+func (A *AND) RuleType() C.RuleType {
+	return C.AND
+}
+
+func (A *AND) Match(metadata *C.Metadata) bool {
+	for _, rule := range A.rules {
+		if !rule.Match(metadata) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (A *AND) Adapter() string {
+	return A.adapter
+}
+
+func (A *AND) Payload() string {
+	return A.payload
+}
+
+func (A *AND) ShouldResolveIP() bool {
+	return A.needIP
+}

rules/logic/common.go

@@ -0,0 +1,131 @@
+package logic
+
+import (
+	"fmt"
+	"github.com/Dreamacro/clash/common/collections"
+	C "github.com/Dreamacro/clash/constant"
+	"regexp"
+	"strings"
+	_ "unsafe"
+)
+
+//go:linkname parseRule github.com/Dreamacro/clash/rules.ParseRule
+func parseRule(tp, payload, target string, params []string) (parsed C.Rule, parseErr error)
+
+func parseRuleByPayload(payload string) ([]C.Rule, error) {
+	regex, err := regexp.Compile("\\(.*\\)")
+	if err != nil {
+		return nil, err
+	}
+
+	if regex.MatchString(payload) {
+		subAllRanges, err := format(payload)
+		if err != nil {
+			return nil, err
+		}
+		rules := make([]C.Rule, 0, len(subAllRanges))
+
+		subRanges := findSubRuleRange(payload, subAllRanges)
+		for _, subRange := range subRanges {
+			subPayload := payload[subRange.start+1 : subRange.end]
+
+			rule, err := payloadToRule(subPayload)
+			if err != nil {
+				return nil, err
+			}
+
+			rules = append(rules, rule)
+		}
+
+		return rules, nil
+	}
+
+	return nil, fmt.Errorf("payload format error")
+}
+
+func containRange(r Range, preStart, preEnd int) bool {
+	return preStart < r.start && preEnd > r.end
+}
+
+func payloadToRule(subPayload string) (C.Rule, error) {
+	splitStr := strings.SplitN(subPayload, ",", 2)
+	if len(splitStr) < 2 {
+		return nil, fmt.Errorf("[%s] format is error", subPayload)
+	}
+
+	tp := splitStr[0]
+	payload := splitStr[1]
+	if tp == "NOT" || tp == "OR" || tp == "AND" {
+		return parseRule(tp, payload, "", nil)
+	}
+	param := strings.Split(payload, ",")
+	return parseRule(tp, param[0], "", param[1:])
+}
+
+type Range struct {
+	start int
+	end   int
+	index int
+}
+
+func format(payload string) ([]Range, error) {
+	stack := collections.NewStack()
+	num := 0
+	subRanges := make([]Range, 0)
+	for i, c := range payload {
+		if c == '(' {
+			sr := Range{
+				start: i,
+				index: num,
+			}
+
+			num++
+			stack.Push(sr)
+		} else if c == ')' {
+			if stack.Len() == 0 {
+				return nil, fmt.Errorf("missing '('")
+			}
+
+			sr := stack.Pop().(Range)
+			sr.end = i
+			subRanges = append(subRanges, sr)
+		}
+	}
+
+	if stack.Len() != 0 {
+		return nil, fmt.Errorf("format error is missing )")
+	}
+
+	sortResult := make([]Range, len(subRanges))
+	for _, sr := range subRanges {
+		sortResult[sr.index] = sr
+	}
+
+	return sortResult, nil
+}
+
+func findSubRuleRange(payload string, ruleRanges []Range) []Range {
+	payloadLen := len(payload)
+	subRuleRange := make([]Range, 0)
+	for _, rr := range ruleRanges {
+		if rr.start == 0 && rr.end == payloadLen-1 {
+			// 最大范围跳过
+			continue
+		}
+
+		containInSub := false
+		for _, r := range subRuleRange {
+			if containRange(rr, r.start, r.end) {
+				// The subRuleRange contains a range of rr, which is the next level node of the tree
+				containInSub = true
+				break
+			}
+		}
+
+		if !containInSub {
+			subRuleRange = append(subRuleRange, rr)
+		}
+	}
+
+	return subRuleRange
+}

rules/logic/logic_test.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"github.com/Dreamacro/clash/constant"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestAND(t *testing.T) {
+	and, err := NewAND("((DOMAIN,baidu.com),(NETWORK,TCP),(DST-PORT,10001-65535))", "DIRECT")
+	assert.Equal(t, nil, err)
+	assert.Equal(t, "DIRECT", and.adapter)
+	assert.Equal(t, false, and.ShouldResolveIP())
+	assert.Equal(t, true, and.Match(&constant.Metadata{
+		Host:     "baidu.com",
+		AddrType: constant.AtypDomainName,
+		NetWork:  constant.TCP,
+		DstPort:  "20000",
+	}))
+
+	and, err = NewAND("(DOMAIN,baidu.com),(NETWORK,TCP),(DST-PORT,10001-65535))", "DIRECT")
+	assert.NotEqual(t, nil, err)
+
+	and, err = NewAND("((AND,(DOMAIN,baidu.com),(NETWORK,TCP)),(NETWORK,TCP),(DST-PORT,10001-65535))", "DIRECT")
+	assert.Equal(t, nil, err)
+}
+
+func TestNOT(t *testing.T) {
+	not, err := NewNOT("((DST-PORT,6000-6500))", "REJECT")
+	assert.Equal(t, nil, err)
+	assert.Equal(t, false, not.Match(&constant.Metadata{
+		DstPort: "6100",
+	}))
+
+	_, err = NewNOT("((DST-PORT,5600-6666),(DOMAIN,baidu.com))", "DIRECT")
+	assert.NotEqual(t, nil, err)
+
+	_, err = NewNOT("(())", "DIRECT")
+	assert.NotEqual(t, nil, err)
+}
+
+func TestOR(t *testing.T) {
+	or, err := NewOR("((DOMAIN,baidu.com),(NETWORK,TCP),(DST-PORT,10001-65535))", "DIRECT")
+	assert.Equal(t, nil, err)
+	assert.Equal(t, true, or.Match(&constant.Metadata{
+		NetWork: constant.TCP,
+	}))
+	assert.Equal(t, false, or.ShouldResolveIP())
+}

rules/logic/not.go

@@ -0,0 +1,55 @@
+package logic
+
+import (
+	"fmt"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/rules/common"
+)
+
+type NOT struct {
+	*common.Base
+	rule    C.Rule
+	payload string
+	adapter string
+}
+
+func (not *NOT) ShouldFindProcess() bool {
+	return false
+}
+
+func NewNOT(payload string, adapter string) (*NOT, error) {
+	not := &NOT{Base: &common.Base{}, adapter: adapter}
+	rule, err := parseRuleByPayload(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(rule) != 1 {
+		return nil, fmt.Errorf("not rule must contain one rule")
+	}
+
+	not.rule = rule[0]
+	not.payload = fmt.Sprintf("(!(%s,%s))", rule[0].RuleType(), rule[0].Payload())
+
+	return not, nil
+}
+
+func (not *NOT) RuleType() C.RuleType {
+	return C.NOT
+}
+
+func (not *NOT) Match(metadata *C.Metadata) bool {
+	return not.rule == nil || !not.rule.Match(metadata)
+}
+
+func (not *NOT) Adapter() string {
+	return not.adapter
+}
+
+func (not *NOT) Payload() string {
+	return not.payload
+}
+
+func (not *NOT) ShouldResolveIP() bool {
+	return not.rule != nil && not.rule.ShouldResolveIP()
+}

rules/logic/or.go

@@ -0,0 +1,67 @@
+package logic
+
+import (
+	"fmt"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/rules/common"
+	"strings"
+)
+
+type OR struct {
+	*common.Base
+	rules   []C.Rule
+	payload string
+	adapter string
+	needIP  bool
+}
+
+func (or *OR) ShouldFindProcess() bool {
+	return false
+}
+
+func (or *OR) RuleType() C.RuleType {
+	return C.OR
+}
+
+func (or *OR) Match(metadata *C.Metadata) bool {
+	for _, rule := range or.rules {
+		if rule.Match(metadata) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (or *OR) Adapter() string {
+	return or.adapter
+}
+
+func (or *OR) Payload() string {
+	return or.payload
+}
+
+func (or *OR) ShouldResolveIP() bool {
+	return or.needIP
+}
+
+func NewOR(payload string, adapter string) (*OR, error) {
+	or := &OR{Base: &common.Base{}, payload: payload, adapter: adapter}
+	rules, err := parseRuleByPayload(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	or.rules = rules
+	payloads := make([]string, 0, len(rules))
+	for _, rule := range rules {
+		payloads = append(payloads, fmt.Sprintf("(%s,%s)", rule.RuleType(), rule.Payload()))
+		if rule.ShouldResolveIP() {
+			or.needIP = true
+			break
+		}
+	}
+
+	or.payload = fmt.Sprintf("(%s)", strings.Join(payloads, " || "))
+	return or, nil
+}