history-museum/Clash.Meta
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[test]

Browse Source
This commit is contained in:
Mazeorz
2021-11-17 16:03:47 +08:00
parent 1f3968bd50
commit 900e852525
115 changed files with 9990 additions and 585 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
rule/base.go
View File

@ -2,6 +2,9 @@ package rules
import (
"errors"
"net"
C "github.com/Dreamacro/clash/constant"
)
var (
@ -18,3 +21,33 @@ func HasNoResolve(params []string) bool {
}
return false
}
func findNetwork(params []string) C.NetWork {
for _, p := range params {
if p == "tcp" {
return C.TCP
} else if p == "udp" {
return C.UDP
}
}
return C.ALLNet
}
func findSourceIPs(params []string) []*net.IPNet {
var ips []*net.IPNet
for _, p := range params {
if p == noResolve || len(p) < 7 {
continue
}
_, ipnet, err := net.ParseCIDR(p)
if err != nil {
continue
}
ips = append(ips, ipnet)
}
if len(ips) > 0 {
return ips
}
return nil
}

16
rule/domain.go
View File

@ -7,8 +7,9 @@ import (
)
type Domain struct {
domain string
adapter string
domain string
adapter string
ruleExtra *C.RuleExtra
}
func (d *Domain) RuleType() C.RuleType {
@ -34,9 +35,14 @@ func (d *Domain) ShouldResolveIP() bool {
return false
}
func NewDomain(domain string, adapter string) *Domain {
func (d *Domain) RuleExtra() *C.RuleExtra {
return d.ruleExtra
}
func NewDomain(domain string, adapter string, ruleExtra *C.RuleExtra) *Domain {
return &Domain{
domain: strings.ToLower(domain),
adapter: adapter,
domain: strings.ToLower(domain),
adapter: adapter,
ruleExtra: ruleExtra,
}
}

16
rule/domain_keyword.go
View File

@ -7,8 +7,9 @@ import (
)
type DomainKeyword struct {
keyword string
adapter string
keyword string
adapter string
ruleExtra *C.RuleExtra
}
func (dk *DomainKeyword) RuleType() C.RuleType {
@ -35,9 +36,14 @@ func (dk *DomainKeyword) ShouldResolveIP() bool {
return false
}
func NewDomainKeyword(keyword string, adapter string) *DomainKeyword {
func (dk *DomainKeyword) RuleExtra() *C.RuleExtra {
return dk.ruleExtra
}
func NewDomainKeyword(keyword string, adapter string, ruleExtra *C.RuleExtra) *DomainKeyword {
return &DomainKeyword{
keyword: strings.ToLower(keyword),
adapter: adapter,
keyword: strings.ToLower(keyword),
adapter: adapter,
ruleExtra: ruleExtra,
}
}

16
rule/domain_suffix.go
View File

@ -7,8 +7,9 @@ import (
)
type DomainSuffix struct {
suffix string
adapter string
suffix string
adapter string
ruleExtra *C.RuleExtra
}
func (ds *DomainSuffix) RuleType() C.RuleType {
@ -35,9 +36,14 @@ func (ds *DomainSuffix) ShouldResolveIP() bool {
return false
}
func NewDomainSuffix(suffix string, adapter string) *DomainSuffix {
func (ds *DomainSuffix) RuleExtra() *C.RuleExtra {
return ds.ruleExtra
}
func NewDomainSuffix(suffix string, adapter string, ruleExtra *C.RuleExtra) *DomainSuffix {
return &DomainSuffix{
suffix: strings.ToLower(suffix),
adapter: adapter,
suffix: strings.ToLower(suffix),
adapter: adapter,
ruleExtra: ruleExtra,
}
}

15
rule/final.go
View File

@ -5,7 +5,8 @@ import (
)
type Match struct {
adapter string
adapter string
ruleExtra *C.RuleExtra
}
func (f *Match) RuleType() C.RuleType {
@ -28,8 +29,16 @@ func (f *Match) ShouldResolveIP() bool {
return false
}
func NewMatch(adapter string) *Match {
func (f *Match) RuleExtra() *C.RuleExtra {
return f.ruleExtra
}
func NewMatch(adapter string, ruleExtra *C.RuleExtra) *Match {
if ruleExtra.SourceIPs == nil {
ruleExtra = nil
}
return &Match{
adapter: adapter,
adapter: adapter,
ruleExtra: ruleExtra,
}
}

16
rule/geoip.go
View File

@ -11,6 +11,7 @@ type GEOIP struct {
country string
adapter string
noResolveIP bool
ruleExtra *C.RuleExtra
}
func (g *GEOIP) RuleType() C.RuleType {
@ -23,7 +24,7 @@ func (g *GEOIP) Match(metadata *C.Metadata) bool {
return false
}
if strings.EqualFold(g.country, "LAN") {
if strings.EqualFold(g.country, "LAN") || C.TunBroadcastAddr.Equal(ip) {
return ip.IsPrivate()
}
record, _ := mmdb.Instance().Country(ip)
@ -42,12 +43,21 @@ func (g *GEOIP) ShouldResolveIP() bool {
return !g.noResolveIP
}
func NewGEOIP(country string, adapter string, noResolveIP bool) *GEOIP {
func (g *GEOIP) RuleExtra() *C.RuleExtra {
return g.ruleExtra
}
func (g *GEOIP) GetCountry() string {
return g.country
}
func NewGEOIP(country string, adapter string, noResolveIP bool, ruleExtra *C.RuleExtra) (*GEOIP, error) {
geoip := &GEOIP{
country: country,
adapter: adapter,
noResolveIP: noResolveIP,
ruleExtra: ruleExtra,
}
return geoip
return geoip, nil
}

70
rule/geosite.go Normal file
View File

@ -0,0 +1,70 @@
package rules
import (
"fmt"
"github.com/Dreamacro/clash/component/geodata"
"github.com/Dreamacro/clash/component/geodata/router"
C "github.com/Dreamacro/clash/constant"
"github.com/Dreamacro/clash/log"
_ "github.com/Dreamacro/clash/component/geodata/standard"
)
type GEOSITE struct {
country string
adapter string
ruleExtra *C.RuleExtra
matcher *router.DomainMatcher
}
func (gs *GEOSITE) RuleType() C.RuleType {
return C.GEOSITE
}
func (gs *GEOSITE) Match(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName {
return false
}
domain := metadata.Host
return gs.matcher.ApplyDomain(domain)
}
func (gs *GEOSITE) Adapter() string {
return gs.adapter
}
func (gs *GEOSITE) Payload() string {
return gs.country
}
func (gs *GEOSITE) ShouldResolveIP() bool {
return false
}
func (gs *GEOSITE) RuleExtra() *C.RuleExtra {
return gs.ruleExtra
}
func (gs *GEOSITE) GetDomainMatcher() *router.DomainMatcher {
return gs.matcher
}
func NewGEOSITE(country string, adapter string, ruleExtra *C.RuleExtra) (*GEOSITE, error) {
matcher, recordsCount, err := geodata.LoadGeoSiteMatcher(country)
if err != nil {
return nil, fmt.Errorf("load GeoSite data error, %s", err.Error())
}
log.Infoln("Start initial GeoSite rule %s => %s, records: %d", country, adapter, recordsCount)
geoSite := &GEOSITE{
country: country,
adapter: adapter,
ruleExtra: ruleExtra,
matcher: matcher,
}
return geoSite, nil
}

12
rule/ipcidr.go
View File

@ -23,6 +23,7 @@ func WithIPCIDRNoResolve(noResolve bool) IPCIDROption {
type IPCIDR struct {
ipnet *net.IPNet
adapter string
ruleExtra *C.RuleExtra
isSourceIP bool
noResolveIP bool
}
@ -54,15 +55,20 @@ func (i *IPCIDR) ShouldResolveIP() bool {
return !i.noResolveIP
}
func NewIPCIDR(s string, adapter string, opts ...IPCIDROption) (*IPCIDR, error) {
func (i *IPCIDR) RuleExtra() *C.RuleExtra {
return i.ruleExtra
}
func NewIPCIDR(s string, adapter string, ruleExtra *C.RuleExtra, opts ...IPCIDROption) (*IPCIDR, error) {
_, ipnet, err := net.ParseCIDR(s)
if err != nil {
return nil, errPayload
}
ipcidr := &IPCIDR{
ipnet: ipnet,
adapter: adapter,
ipnet: ipnet,
adapter: adapter,
ruleExtra: ruleExtra,
}
for _, o := range opts {

29
rule/parser.go
View File

@ -12,29 +12,38 @@ func ParseRule(tp, payload, target string, params []string) (C.Rule, error) {
parsed C.Rule
)
ruleExtra := &C.RuleExtra{
Network: findNetwork(params),
SourceIPs: findSourceIPs(params),
}
switch tp {
case "DOMAIN":
parsed = NewDomain(payload, target)
parsed = NewDomain(payload, target, ruleExtra)
case "DOMAIN-SUFFIX":
parsed = NewDomainSuffix(payload, target)
parsed = NewDomainSuffix(payload, target, ruleExtra)
case "DOMAIN-KEYWORD":
parsed = NewDomainKeyword(payload, target)
parsed = NewDomainKeyword(payload, target, ruleExtra)
case "GEOSITE":
parsed, parseErr = NewGEOSITE(payload, target, ruleExtra)
case "GEOIP":
noResolve := HasNoResolve(params)
parsed = NewGEOIP(payload, target, noResolve)
parsed, parseErr = NewGEOIP(payload, target, noResolve, ruleExtra)
case "IP-CIDR", "IP-CIDR6":
noResolve := HasNoResolve(params)
parsed, parseErr = NewIPCIDR(payload, target, WithIPCIDRNoResolve(noResolve))
parsed, parseErr = NewIPCIDR(payload, target, ruleExtra, WithIPCIDRNoResolve(noResolve))
case "SRC-IP-CIDR":
parsed, parseErr = NewIPCIDR(payload, target, WithIPCIDRSourceIP(true), WithIPCIDRNoResolve(true))
parsed, parseErr = NewIPCIDR(payload, target, ruleExtra, WithIPCIDRSourceIP(true), WithIPCIDRNoResolve(true))
case "SRC-PORT":
parsed, parseErr = NewPort(payload, target, true)
parsed, parseErr = NewPort(payload, target, true, ruleExtra)
case "DST-PORT":
parsed, parseErr = NewPort(payload, target, false)
parsed, parseErr = NewPort(payload, target, false, ruleExtra)
case "PROCESS-NAME":
parsed, parseErr = NewProcess(payload, target)
parsed, parseErr = NewProcess(payload, target, ruleExtra)
case "SCRIPT":
parsed, parseErr = NewScript(payload, target)
case "MATCH":
parsed = NewMatch(target)
parsed = NewMatch(target, ruleExtra)
default:
parseErr = fmt.Errorf("unsupported rule type %s", tp)
}

94
rule/port.go
View File

@ -1,15 +1,24 @@
package rules
import (
"fmt"
"strconv"
"strings"
C "github.com/Dreamacro/clash/constant"
)
type portReal struct {
portStart int
portEnd int
}
type Port struct {
adapter string
port string
isSource bool
adapter string
port string
isSource bool
portList []portReal
ruleExtra *C.RuleExtra
}
func (p *Port) RuleType() C.RuleType {
@ -21,9 +30,9 @@ func (p *Port) RuleType() C.RuleType {
func (p *Port) Match(metadata *C.Metadata) bool {
if p.isSource {
return metadata.SrcPort == p.port
return p.matchPortReal(metadata.SrcPort)
}
return metadata.DstPort == p.port
return p.matchPortReal(metadata.DstPort)
}
func (p *Port) Adapter() string {
@ -38,14 +47,79 @@ func (p *Port) ShouldResolveIP() bool {
return false
}
func NewPort(port string, adapter string, isSource bool) (*Port, error) {
_, err := strconv.ParseUint(port, 10, 16)
func (p *Port) RuleExtra() *C.RuleExtra {
return p.ruleExtra
}
func (p *Port) matchPortReal(portRef string) bool {
port, err := strconv.Atoi(portRef)
if err != nil {
return false
}
var rs bool
for _, pr := range p.portList {
if pr.portEnd == -1 {
rs = port == pr.portStart
} else {
rs = port >= pr.portStart && port <= pr.portEnd
}
if rs {
return true
}
}
return false
}
func NewPort(port string, adapter string, isSource bool, ruleExtra *C.RuleExtra) (*Port, error) {
ports := strings.Split(port, "/")
if len(ports) > 28 {
return nil, fmt.Errorf("%s, too many ports to use, maximum support 28 ports", errPayload.Error())
}
var portList []portReal
for _, p := range ports {
if p == "" {
continue
}
subPorts := strings.Split(p, "-")
subPortsLen := len(subPorts)
if subPortsLen > 2 {
return nil, errPayload
}
portStart, err := strconv.Atoi(strings.Trim(subPorts[0], "[ ]"))
if err != nil || portStart < 0 || portStart > 65535 {
return nil, errPayload
}
if subPortsLen == 1 {
portList = append(portList, portReal{portStart, -1})
} else if subPortsLen == 2 {
portEnd, err1 := strconv.Atoi(strings.Trim(subPorts[1], "[ ]"))
if err1 != nil || portEnd < 0 || portEnd > 65535 {
return nil, errPayload
}
shouldReverse := portStart > portEnd
if shouldReverse {
portList = append(portList, portReal{portEnd, portStart})
} else {
portList = append(portList, portReal{portStart, portEnd})
}
}
}
if len(portList) == 0 {
return nil, errPayload
}
return &Port{
adapter: adapter,
port: port,
isSource: isSource,
adapter: adapter,
port: port,
isSource: isSource,
portList: portList,
ruleExtra: ruleExtra,
}, nil
}

29
rule/process.go
View File

@ -14,8 +14,9 @@ import (
var processCache = cache.NewLRUCache(cache.WithAge(2), cache.WithSize(64))
type Process struct {
adapter string
process string
adapter string
process string
ruleExtra *C.RuleExtra
}
func (ps *Process) RuleType() C.RuleType {
@ -23,6 +24,15 @@ func (ps *Process) RuleType() C.RuleType {
}
func (ps *Process) Match(metadata *C.Metadata) bool {
if metadata.Process != "" {
return strings.EqualFold(metadata.Process, ps.process)
}
// ignore match in proxy type "tproxy"
if metadata.Type == C.TPROXY {
return false
}
key := fmt.Sprintf("%s:%s:%s", metadata.NetWork.String(), metadata.SrcIP.String(), metadata.SrcPort)
cached, hit := processCache.Get(key)
if !hit {
@ -42,7 +52,9 @@ func (ps *Process) Match(metadata *C.Metadata) bool {
cached = name
}
return strings.EqualFold(cached.(string), ps.process)
metadata.Process = cached.(string)
return strings.EqualFold(metadata.Process, ps.process)
}
func (ps *Process) Adapter() string {
@ -57,9 +69,14 @@ func (ps *Process) ShouldResolveIP() bool {
return false
}
func NewProcess(process string, adapter string) (*Process, error) {
func (ps *Process) RuleExtra() *C.RuleExtra {
return ps.ruleExtra
}
func NewProcess(process string, adapter string, ruleExtra *C.RuleExtra) (*Process, error) {
return &Process{
adapter: adapter,
process: process,
adapter: adapter,
process: process,
ruleExtra: ruleExtra,
}, nil
}

73
rule/script.go Normal file
View File

@ -0,0 +1,73 @@
package rules
import (
"fmt"
"runtime"
"strings"
S "github.com/Dreamacro/clash/component/script"
C "github.com/Dreamacro/clash/constant"
"github.com/Dreamacro/clash/log"
)
type Script struct {
shortcut string
adapter string
shortcutFunction *S.PyObject
}
func (s *Script) RuleType() C.RuleType {
return C.Script
}
func (s *Script) Match(metadata *C.Metadata) bool {
rs, err := S.CallPyShortcut(s.shortcutFunction, metadata)
if err != nil {
log.Errorln("[Script] match rule error: %s", err.Error())
return false
}
return rs
}
func (s *Script) Adapter() string {
return s.adapter
}
func (s *Script) Payload() string {
return s.shortcut
}
func (s *Script) ShouldResolveIP() bool {
return false
}
func (s *Script) RuleExtra() *C.RuleExtra {
return nil
}
func NewScript(shortcut string, adapter string) (*Script, error) {
shortcut = strings.ToLower(shortcut)
if !S.Py_IsInitialized() {
return nil, fmt.Errorf("load script shortcut [%s] failure, can't find any shortcuts in the config file", shortcut)
}
shortcutFunction, err := S.LoadShortcutFunction(shortcut)
if err != nil {
return nil, fmt.Errorf("can't find script shortcut [%s] in the config file", shortcut)
}
obj := &Script{
shortcut: shortcut,
adapter: adapter,
shortcutFunction: shortcutFunction,
}
runtime.SetFinalizer(obj, func(s *Script) {
s.shortcutFunction.Clear()
})
log.Infoln("Start initial script shortcut rule %s => %s", shortcut, adapter)
return obj, nil
}