131 lines
2.7 KiB
Go
131 lines
2.7 KiB
Go
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
|
|
}
|