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

[fix]code

Browse Source
This commit is contained in:
Maze.tsz
2021-12-02 03:39:37 +08:00
parent c7b257b188
commit 0431969a73
14 changed files with 798 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
adapter/provider/fetcher.go
View File

@ -26,7 +26,7 @@ type fetcher struct {
done chan struct{}
hash [16]byte
parser parser
onUpdate func(interface{})
onUpdate func(interface{}) error
}
func (f *fetcher) Name() string {
@ -167,7 +167,7 @@ func safeWrite(path string, buf []byte) error {
return os.WriteFile(path, buf, fileMode)
}
func newFetcher(name string, interval time.Duration, vehicle types.Vehicle, parser parser, onUpdate func(interface{})) *fetcher {
func newFetcher(name string, interval time.Duration, vehicle types.Vehicle, parser parser, onUpdate func(interface{}) error) *fetcher {
var ticker *time.Ticker
if interval != 0 {
ticker = time.NewTicker(interval)

41
adapter/provider/parser.go
View File

@ -60,3 +60,44 @@ func ParseProxyProvider(name string, mapping map[string]interface{}) (types.Prox
interval := time.Duration(uint(schema.Interval)) * time.Second
return NewProxySetProvider(name, interval, vehicle, hc), nil
}
type ruleProviderSchema struct {
Type string `provider:"type"`
Behavior string `provider:"behavior"`
Path string `provider:"path"`
URL string `provider:"url,omitempty"`
Interval int `provider:"interval,omitempty"`
}
func ParseRuleProvider(name string, mapping map[string]interface{}) (types.RuleProvider, error) {
schema := &ruleProviderSchema{}
decoder := structure.NewDecoder(structure.Option{TagName: "provider", WeaklyTypedInput: true})
if err := decoder.Decode(mapping, schema); err != nil {
return nil, err
}
var behavior Behavior
switch schema.Behavior {
case "domain":
behavior = Domain
case "ipcidr":
behavior = IPCIDR
case "classical":
behavior = Classical
default:
return nil, fmt.Errorf("unsupported behavior type: %s", schema.Behavior)
}
path := C.Path.Resolve(schema.Path)
var vehicle types.Vehicle
switch schema.Type {
case "file":
vehicle = NewFileVehicle(path)
case "http":
vehicle = NewHTTPVehicle(schema.URL, path)
default:
return nil, fmt.Errorf("unsupported vehicle type: %s", schema.Type)
}
interval := time.Duration(uint(schema.Interval)) * time.Second
return NewRuleSetProvider(name, behavior, interval, vehicle), nil
}

280
adapter/provider/provider.go
View File

@ -4,7 +4,9 @@ import (
"encoding/json"
"errors"
"fmt"
"github.com/Dreamacro/clash/component/trie"
"runtime"
"strings"
"time"
"github.com/Dreamacro/clash/adapter"
@ -132,9 +134,10 @@ func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehi
healthCheck: hc,
}
onUpdate := func(elm interface{}) {
onUpdate := func(elm interface{}) error {
ret := elm.([]C.Proxy)
pd.setProxies(ret)
return nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
@ -221,3 +224,278 @@ func NewCompatibleProvider(name string, proxies []C.Proxy, hc *HealthCheck) (*Co
runtime.SetFinalizer(wrapper, stopCompatibleProvider)
return wrapper, nil
}
// Rule
type Behavior int
var (
parse = func(ruleType, rule string, params []string) (C.Rule, error) {
return nil, errors.New("unimplemented function")
}
ruleProviders = map[string]types.RuleProvider{}
)
func SetClassicalRuleParser(function func(ruleType, rule string, params []string) (C.Rule, error)) {
parse = function
}
func RuleProviders() map[string]types.RuleProvider {
return ruleProviders
}
func SetRuleProvider(ruleProvider types.RuleProvider) {
if ruleProvider != nil {
ruleProviders[(ruleProvider).Name()] = ruleProvider
}
}
type ruleSetProvider struct {
*fetcher
behavior Behavior
count int
DomainRules *trie.DomainTrie
IPCIDRRules *trie.IpCidrTrie
ClassicalRules []C.Rule
}
type RuleSetProvider struct {
*ruleSetProvider
}
func (r RuleSetProvider) Behavior() types.RuleType {
//TODO implement me
panic("implement me")
}
func (r RuleSetProvider) ShouldResolveIP() bool {
//TODO implement me
panic("implement me")
}
func (r RuleSetProvider) AsRule(adaptor string) C.Rule {
//TODO implement me
panic("implement me")
}
func NewRuleSetProvider(name string, behavior Behavior, interval time.Duration, vehicle types.Vehicle) *RuleSetProvider {
rp := &ruleSetProvider{
behavior: behavior,
}
onUpdate := func(elm interface{}) error {
rulesRaw := elm.([]string)
rp.count = len(rulesRaw)
rules, err := constructRules(rp.behavior, rulesRaw)
if err != nil {
return err
}
rp.setRules(rules)
return nil
}
fetcher := newFetcher(name, interval, vehicle, rulesParse, onUpdate)
rp.fetcher = fetcher
wrapper := &RuleSetProvider{
rp,
}
runtime.SetFinalizer(wrapper, stopRuleSetProvider)
return wrapper
}
func (rp *ruleSetProvider) Name() string {
return rp.name
}
func (rp *ruleSetProvider) RuleCount() int {
return rp.count
}
const (
Domain = iota
IPCIDR
Classical
)
// RuleType defined
func (b Behavior) String() string {
switch b {
case Domain:
return "Domain"
case IPCIDR:
return "IPCIDR"
case Classical:
return "Classical"
default:
return ""
}
}
func (rp *ruleSetProvider) Match(metadata *C.Metadata) bool {
switch rp.behavior {
case Domain:
return rp.DomainRules.Search(metadata.Host) != nil
case IPCIDR:
return rp.IPCIDRRules.IsContain(metadata.DstIP)
case Classical:
for _, rule := range rp.ClassicalRules {
if rule.Match(metadata) {
return true
}
}
return false
default:
return false
}
}
func (rp *ruleSetProvider) Behavior() Behavior {
return rp.behavior
}
func (rp *ruleSetProvider) VehicleType() types.VehicleType {
return rp.vehicle.Type()
}
func (rp *ruleSetProvider) Type() types.ProviderType {
return types.Rule
}
func (rp *ruleSetProvider) Initial() error {
elm, err := rp.fetcher.Initial()
if err != nil {
return err
}
return rp.fetcher.onUpdate(elm)
}
func (rp *ruleSetProvider) Update() error {
elm, same, err := rp.fetcher.Update()
if err == nil && !same {
return rp.fetcher.onUpdate(elm)
}
return err
}
func (rp *ruleSetProvider) setRules(rules interface{}) {
switch rp.behavior {
case Domain:
rp.DomainRules = rules.(*trie.DomainTrie)
case Classical:
rp.ClassicalRules = rules.([]C.Rule)
case IPCIDR:
rp.IPCIDRRules = rules.(*trie.IpCidrTrie)
default:
}
}
func (rp *ruleSetProvider) MarshalJSON() ([]byte, error) {
return json.Marshal(
map[string]interface{}{
"behavior": rp.behavior.String(),
"name": rp.Name(),
"ruleCount": rp.RuleCount(),
"type": rp.Type().String(),
"updatedAt": rp.updatedAt,
"vehicleType": rp.VehicleType().String(),
})
}
type RulePayload struct {
/**
key: Domain or IP Cidr
value: Rule type or is empty
*/
Rules []string `yaml:"payload"`
}
func rulesParse(buf []byte) (interface{}, error) {
rulePayload := RulePayload{}
err := yaml.Unmarshal(buf, &rulePayload)
if err != nil {
return nil, err
}
return rulePayload.Rules, nil
}
func constructRules(behavior Behavior, rules []string) (interface{}, error) {
switch behavior {
case Domain:
return handleDomainRules(rules)
case IPCIDR:
return handleIpCidrRules(rules)
case Classical:
return handleClassicalRules(rules)
default:
return nil, errors.New("unknown behavior type")
}
}
func handleDomainRules(rules []string) (interface{}, error) {
domainRules := trie.New()
for _, rawRule := range rules {
ruleType, rule, _ := ruleParse(rawRule)
if ruleType != "" {
return nil, errors.New("error format of domain")
}
if err := domainRules.Insert(rule, ""); err != nil {
return nil, err
}
}
return domainRules, nil
}
func handleIpCidrRules(rules []string) (interface{}, error) {
ipCidrRules := trie.NewIpCidrTrie()
for _, rawRule := range rules {
ruleType, rule, _ := ruleParse(rawRule)
if ruleType != "" {
return nil, errors.New("error format of ip-cidr")
}
if err := ipCidrRules.AddIpCidrForString(rule); err != nil {
return nil, err
}
}
return ipCidrRules, nil
}
func handleClassicalRules(rules []string) (interface{}, error) {
var classicalRules []C.Rule
for _, rawRule := range rules {
ruleType, rule, params := ruleParse(rawRule)
if ruleType == "RULE-SET" {
return nil, errors.New("error rule type")
}
r, err := parse(ruleType, rule, params)
if err != nil {
return nil, err
}
classicalRules = append(classicalRules, r)
}
return classicalRules, nil
}
func ruleParse(ruleRaw string) (string, string, []string) {
item := strings.Split(ruleRaw, ",")
if len(item) == 1 {
return "", item[0], nil
} else if len(item) == 2 {
return item[0], item[1], nil
} else if len(item) > 2 {
return item[0], item[1], item[2:]
}
return "", "", nil
}
func stopRuleSetProvider(rp *RuleSetProvider) {
rp.fetcher.Destroy()
}

58
adapter/provider/provider_test.go Normal file
View File

@ -0,0 +1,58 @@
package provider
import (
"github.com/Dreamacro/clash/constant"
rules "github.com/Dreamacro/clash/rule"
"github.com/stretchr/testify/assert"
"net"
"testing"
"time"
)
func setup() {
SetClassicalRuleParser(func(ruleType, rule string, params []string) (constant.Rule, error) {
if params == nil {
params = make([]string, 0)
}
return rules.ParseRule(ruleType, rule, "", params)
})
}
func TestDomain(t *testing.T) {
setup()
domainProvider := NewRuleSetProvider("test", Domain,
time.Duration(uint(100000)), NewFileVehicle("./domain.txt"))
assert.Nil(t, domainProvider.Initial())
assert.True(t, domainProvider.Match(&constant.Metadata{Host: "youtube.com"}))
assert.True(t, domainProvider.Match(&constant.Metadata{Host: "www.youtube.com"}))
assert.True(t, domainProvider.Match(&constant.Metadata{Host: "test.youtube.com"}))
assert.True(t, domainProvider.Match(&constant.Metadata{Host: "bcovlive-a.akamaihd.net"}))
assert.False(t, domainProvider.Match(&constant.Metadata{Host: "baidu.com"}))
}
func TestClassical(t *testing.T) {
setup()
classicalProvider := NewRuleSetProvider("test", Classical,
time.Duration(uint(100000)), NewFileVehicle("./classical.txt"))
assert.Nil(t, classicalProvider.Initial())
assert.True(t, classicalProvider.Match(&constant.Metadata{Host: "www.10010.com", AddrType: constant.AtypDomainName}))
assert.False(t, classicalProvider.Match(&constant.Metadata{Host: "google.com", AddrType: constant.AtypDomainName}))
assert.True(t, classicalProvider.Match(&constant.Metadata{Host: "analytics.strava.com", AddrType: constant.AtypDomainName}))
assert.True(t, classicalProvider.Match(&constant.Metadata{DstIP: net.ParseIP("2a0b:b580::1")}))
assert.False(t, classicalProvider.Match(&constant.Metadata{DstIP: net.ParseIP("2a0b:c582::1")}))
assert.True(t, classicalProvider.Match(&constant.Metadata{DstIP: net.ParseIP("1.255.62.34")}))
assert.False(t, classicalProvider.Match(&constant.Metadata{DstIP: net.ParseIP("103.65.41.199")}))
}
func TestIpCidr(t *testing.T) {
setup()
domainProvider := NewRuleSetProvider("test", IPCIDR,
time.Duration(uint(100000)), NewFileVehicle("./ipcidr.txt"))
assert.Nil(t, domainProvider.Initial())
assert.True(t, domainProvider.Match(&constant.Metadata{DstIP: net.ParseIP("91.108.22.10")}))
assert.False(t, domainProvider.Match(&constant.Metadata{DstIP: net.ParseIP("149.190.220.251")}))
assert.True(t, domainProvider.Match(&constant.Metadata{DstIP: net.ParseIP("2001:b28:f23f:f005::a")}))
assert.False(t, domainProvider.Match(&constant.Metadata{DstIP: net.ParseIP("2006:b28:f23f:f005::a")}))
}