Style: code style

rule/base.go

@@ -0,0 +1,20 @@
+package rules
+
+import (
+	"errors"
+)
+
+var (
+	errPayload = errors.New("payload error")
+
+	noResolve = "no-resolve"
+)
+
+func HasNoResolve(params []string) bool {
+	for _, p := range params {
+		if p == noResolve {
+			return true
+		}
+	}
+	return false
+}

rule/domain.go

@@ -0,0 +1,42 @@
+package rules
+
+import (
+	"strings"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Domain struct {
+	domain  string
+	adapter string
+}
+
+func (d *Domain) RuleType() C.RuleType {
+	return C.Domain
+}
+
+func (d *Domain) Match(metadata *C.Metadata) bool {
+	if metadata.AddrType != C.AtypDomainName {
+		return false
+	}
+	return metadata.Host == d.domain
+}
+
+func (d *Domain) Adapter() string {
+	return d.adapter
+}
+
+func (d *Domain) Payload() string {
+	return d.domain
+}
+
+func (d *Domain) ShouldResolveIP() bool {
+	return false
+}
+
+func NewDomain(domain string, adapter string) *Domain {
+	return &Domain{
+		domain:  strings.ToLower(domain),
+		adapter: adapter,
+	}
+}

rule/domain_keyword.go

@@ -0,0 +1,43 @@
+package rules
+
+import (
+	"strings"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type DomainKeyword struct {
+	keyword string
+	adapter string
+}
+
+func (dk *DomainKeyword) RuleType() C.RuleType {
+	return C.DomainKeyword
+}
+
+func (dk *DomainKeyword) Match(metadata *C.Metadata) bool {
+	if metadata.AddrType != C.AtypDomainName {
+		return false
+	}
+	domain := metadata.Host
+	return strings.Contains(domain, dk.keyword)
+}
+
+func (dk *DomainKeyword) Adapter() string {
+	return dk.adapter
+}
+
+func (dk *DomainKeyword) Payload() string {
+	return dk.keyword
+}
+
+func (dk *DomainKeyword) ShouldResolveIP() bool {
+	return false
+}
+
+func NewDomainKeyword(keyword string, adapter string) *DomainKeyword {
+	return &DomainKeyword{
+		keyword: strings.ToLower(keyword),
+		adapter: adapter,
+	}
+}

rule/domain_suffix.go

@@ -0,0 +1,43 @@
+package rules
+
+import (
+	"strings"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type DomainSuffix struct {
+	suffix  string
+	adapter string
+}
+
+func (ds *DomainSuffix) RuleType() C.RuleType {
+	return C.DomainSuffix
+}
+
+func (ds *DomainSuffix) Match(metadata *C.Metadata) bool {
+	if metadata.AddrType != C.AtypDomainName {
+		return false
+	}
+	domain := metadata.Host
+	return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix
+}
+
+func (ds *DomainSuffix) Adapter() string {
+	return ds.adapter
+}
+
+func (ds *DomainSuffix) Payload() string {
+	return ds.suffix
+}
+
+func (ds *DomainSuffix) ShouldResolveIP() bool {
+	return false
+}
+
+func NewDomainSuffix(suffix string, adapter string) *DomainSuffix {
+	return &DomainSuffix{
+		suffix:  strings.ToLower(suffix),
+		adapter: adapter,
+	}
+}

rule/final.go

@@ -0,0 +1,35 @@
+package rules
+
+import (
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Match struct {
+	adapter string
+}
+
+func (f *Match) RuleType() C.RuleType {
+	return C.MATCH
+}
+
+func (f *Match) Match(metadata *C.Metadata) bool {
+	return true
+}
+
+func (f *Match) Adapter() string {
+	return f.adapter
+}
+
+func (f *Match) Payload() string {
+	return ""
+}
+
+func (f *Match) ShouldResolveIP() bool {
+	return false
+}
+
+func NewMatch(adapter string) *Match {
+	return &Match{
+		adapter: adapter,
+	}
+}

rule/geoip.go

@@ -0,0 +1,47 @@
+package rules
+
+import (
+	"github.com/Dreamacro/clash/component/mmdb"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type GEOIP struct {
+	country     string
+	adapter     string
+	noResolveIP bool
+}
+
+func (g *GEOIP) RuleType() C.RuleType {
+	return C.GEOIP
+}
+
+func (g *GEOIP) Match(metadata *C.Metadata) bool {
+	ip := metadata.DstIP
+	if ip == nil {
+		return false
+	}
+	record, _ := mmdb.Instance().Country(ip)
+	return record.Country.IsoCode == g.country
+}
+
+func (g *GEOIP) Adapter() string {
+	return g.adapter
+}
+
+func (g *GEOIP) Payload() string {
+	return g.country
+}
+
+func (g *GEOIP) ShouldResolveIP() bool {
+	return !g.noResolveIP
+}
+
+func NewGEOIP(country string, adapter string, noResolveIP bool) *GEOIP {
+	geoip := &GEOIP{
+		country:     country,
+		adapter:     adapter,
+		noResolveIP: noResolveIP,
+	}
+
+	return geoip
+}

rule/ipcidr.go

@@ -0,0 +1,73 @@
+package rules
+
+import (
+	"net"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type IPCIDROption func(*IPCIDR)
+
+func WithIPCIDRSourceIP(b bool) IPCIDROption {
+	return func(i *IPCIDR) {
+		i.isSourceIP = b
+	}
+}
+
+func WithIPCIDRNoResolve(noResolve bool) IPCIDROption {
+	return func(i *IPCIDR) {
+		i.noResolveIP = noResolve
+	}
+}
+
+type IPCIDR struct {
+	ipnet       *net.IPNet
+	adapter     string
+	isSourceIP  bool
+	noResolveIP bool
+}
+
+func (i *IPCIDR) RuleType() C.RuleType {
+	if i.isSourceIP {
+		return C.SrcIPCIDR
+	}
+	return C.IPCIDR
+}
+
+func (i *IPCIDR) Match(metadata *C.Metadata) bool {
+	ip := metadata.DstIP
+	if i.isSourceIP {
+		ip = metadata.SrcIP
+	}
+	return ip != nil && i.ipnet.Contains(ip)
+}
+
+func (i *IPCIDR) Adapter() string {
+	return i.adapter
+}
+
+func (i *IPCIDR) Payload() string {
+	return i.ipnet.String()
+}
+
+func (i *IPCIDR) ShouldResolveIP() bool {
+	return !i.noResolveIP
+}
+
+func NewIPCIDR(s string, adapter string, opts ...IPCIDROption) (*IPCIDR, error) {
+	_, ipnet, err := net.ParseCIDR(s)
+	if err != nil {
+		return nil, errPayload
+	}
+
+	ipcidr := &IPCIDR{
+		ipnet:   ipnet,
+		adapter: adapter,
+	}
+
+	for _, o := range opts {
+		o(ipcidr)
+	}
+
+	return ipcidr, nil
+}

rule/parser.go

@@ -0,0 +1,43 @@
+package rules
+
+import (
+	"fmt"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+func ParseRule(tp, payload, target string, params []string) (C.Rule, error) {
+	var (
+		parseErr error
+		parsed   C.Rule
+	)
+
+	switch tp {
+	case "DOMAIN":
+		parsed = NewDomain(payload, target)
+	case "DOMAIN-SUFFIX":
+		parsed = NewDomainSuffix(payload, target)
+	case "DOMAIN-KEYWORD":
+		parsed = NewDomainKeyword(payload, target)
+	case "GEOIP":
+		noResolve := HasNoResolve(params)
+		parsed = NewGEOIP(payload, target, noResolve)
+	case "IP-CIDR", "IP-CIDR6":
+		noResolve := HasNoResolve(params)
+		parsed, parseErr = NewIPCIDR(payload, target, WithIPCIDRNoResolve(noResolve))
+	case "SRC-IP-CIDR":
+		parsed, parseErr = NewIPCIDR(payload, target, WithIPCIDRSourceIP(true), WithIPCIDRNoResolve(true))
+	case "SRC-PORT":
+		parsed, parseErr = NewPort(payload, target, true)
+	case "DST-PORT":
+		parsed, parseErr = NewPort(payload, target, false)
+	case "PROCESS-NAME":
+		parsed, parseErr = NewProcess(payload, target)
+	case "MATCH":
+		parsed = NewMatch(target)
+	default:
+		parseErr = fmt.Errorf("unsupported rule type %s", tp)
+	}
+
+	return parsed, parseErr
+}

rule/port.go

@@ -0,0 +1,51 @@
+package rules
+
+import (
+	"strconv"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Port struct {
+	adapter  string
+	port     string
+	isSource bool
+}
+
+func (p *Port) RuleType() C.RuleType {
+	if p.isSource {
+		return C.SrcPort
+	}
+	return C.DstPort
+}
+
+func (p *Port) Match(metadata *C.Metadata) bool {
+	if p.isSource {
+		return metadata.SrcPort == p.port
+	}
+	return metadata.DstPort == p.port
+}
+
+func (p *Port) Adapter() string {
+	return p.adapter
+}
+
+func (p *Port) Payload() string {
+	return p.port
+}
+
+func (p *Port) ShouldResolveIP() bool {
+	return false
+}
+
+func NewPort(port string, adapter string, isSource bool) (*Port, error) {
+	_, err := strconv.Atoi(port)
+	if err != nil {
+		return nil, errPayload
+	}
+	return &Port{
+		adapter:  adapter,
+		port:     port,
+		isSource: isSource,
+	}, nil
+}

rule/process.go

@@ -0,0 +1,65 @@
+package rules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/Dreamacro/clash/common/cache"
+	"github.com/Dreamacro/clash/component/process"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+)
+
+var processCache = cache.NewLRUCache(cache.WithAge(2), cache.WithSize(64))
+
+type Process struct {
+	adapter string
+	process string
+}
+
+func (ps *Process) RuleType() C.RuleType {
+	return C.Process
+}
+
+func (ps *Process) Match(metadata *C.Metadata) bool {
+	key := fmt.Sprintf("%s:%s:%s", metadata.NetWork.String(), metadata.SrcIP.String(), metadata.SrcPort)
+	cached, hit := processCache.Get(key)
+	if !hit {
+		srcPort, err := strconv.Atoi(metadata.SrcPort)
+		if err != nil {
+			processCache.Set(key, "")
+			return false
+		}
+
+		name, err := process.FindProcessName(metadata.NetWork.String(), metadata.SrcIP, srcPort)
+		if err != nil {
+			log.Debugln("[Rule] find process name %s error: %s", C.Process.String(), err.Error())
+		}
+
+		processCache.Set(key, name)
+
+		cached = name
+	}
+
+	return strings.EqualFold(cached.(string), ps.process)
+}
+
+func (ps *Process) Adapter() string {
+	return ps.adapter
+}
+
+func (ps *Process) Payload() string {
+	return ps.process
+}
+
+func (ps *Process) ShouldResolveIP() bool {
+	return false
+}
+
+func NewProcess(process string, adapter string) (*Process, error) {
+	return &Process{
+		adapter: adapter,
+		process: process,
+	}, nil
+}