mahasona/clash
1
0
Fork 0
mirror of https://github.com/MetaCubeX/mihomo.git synced 2024-07-02 19:09:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/Alpha' into Alpha

Browse source
This commit is contained in:
adlyq 2022-04-28 11:51:57 +08:00
commit b23a333acf
10 changed files with 49 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
adapter/inbound/socket.go
View file

@ -33,15 +33,10 @@ func NewInner(conn net.Conn, dst string, host string) *context.ConnContext {
metadata.Host = host
metadata.AddrType = C.AtypDomainName
metadata.Process = C.ClashName
if ip, port, err := parseAddr(dst); err == nil {
if h, port, err := net.SplitHostPort(dst); err == nil {
metadata.DstPort = port
if host == "" {
metadata.DstIP = ip
if ip.Is4() {
metadata.AddrType = C.AtypIPv6
} else {
metadata.AddrType = C.AtypIPv4
}
metadata.Host = h
}
}

5
adapter/provider/vehicle.go
View file

@ -2,7 +2,6 @@ package provider
import (
"context"
"github.com/Dreamacro/clash/component/dialer"
"github.com/Dreamacro/clash/listener/inner"
"io"
"net"
@ -86,10 +85,6 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
client := http.Client{Transport: transport}
resp, err := client.Do(req)
if err != nil {
transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
return dialer.DialContext(ctx, network, address)
}
resp, err = client.Do(req)
if err != nil {
return nil, err
}

8
config/config.go
View file

@ -151,7 +151,7 @@ type Config struct {
Users []auth.AuthUser
Proxies map[string]C.Proxy
Providers map[string]providerTypes.ProxyProvider
RuleProviders map[string]*providerTypes.RuleProvider
RuleProviders map[string]providerTypes.RuleProvider
Sniffer *Sniffer
}
@ -523,8 +523,8 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
return proxies, providersMap, nil
}
func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[string]*providerTypes.RuleProvider, error) {
ruleProviders := map[string]*providerTypes.RuleProvider{}
func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[string]providerTypes.RuleProvider, error) {
ruleProviders := map[string]providerTypes.RuleProvider{}
log.Infoln("Geodata Loader mode: %s", geodata.LoaderName())
// parse rule provider
for name, mapping := range cfg.RuleProvider {
@ -533,7 +533,7 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin
return nil, nil, err
}
ruleProviders[name] = &rp
ruleProviders[name] = rp
RP.SetRuleProvider(rp)
}

53
hub/executor/executor.go
View file

@ -82,8 +82,9 @@ func ApplyConfig(cfg *config.Config, force bool) {
updateTun(cfg.Tun, cfg.DNS)
updateExperimental(cfg)
updateHosts(cfg.Hosts)
loadProvider(cfg.RuleProviders, cfg.Providers)
loadProxyProvider(cfg.Providers)
updateProfile(cfg)
loadRuleProvider(cfg.RuleProviders)
log.SetLevel(cfg.General.LogLevel)
}
@ -181,39 +182,41 @@ func updateProxies(proxies map[string]C.Proxy, providers map[string]provider.Pro
tunnel.UpdateProxies(proxies, providers)
}
func updateRules(rules []C.Rule, ruleProviders map[string]*provider.RuleProvider) {
func updateRules(rules []C.Rule, ruleProviders map[string]provider.RuleProvider) {
tunnel.UpdateRules(rules, ruleProviders)
}
func loadProvider(ruleProviders map[string]*provider.RuleProvider, proxyProviders map[string]provider.ProxyProvider) {
load := func(pv provider.Provider) {
if pv.VehicleType() == provider.Compatible {
log.Infoln("Start initial compatible provider %s", pv.Name())
} else {
log.Infoln("Start initial provider %s", (pv).Name())
}
if err := (pv).Initial(); err != nil {
switch pv.Type() {
case provider.Proxy:
{
log.Warnln("initial proxy provider %s error: %v", (pv).Name(), err)
}
case provider.Rule:
{
log.Warnln("initial rule provider %s error: %v", (pv).Name(), err)
}
func loadProvider(pv provider.Provider) {
if pv.VehicleType() == provider.Compatible {
log.Infoln("Start initial compatible provider %s", pv.Name())
} else {
log.Infoln("Start initial provider %s", (pv).Name())
}
if err := (pv).Initial(); err != nil {
switch pv.Type() {
case provider.Proxy:
{
log.Warnln("initial proxy provider %s error: %v", (pv).Name(), err)
}
case provider.Rule:
{
log.Warnln("initial rule provider %s error: %v", (pv).Name(), err)
}
}
}
}
for _, proxyProvider := range proxyProviders {
load(proxyProvider)
}
func loadRuleProvider(ruleProviders map[string]provider.RuleProvider) {
for _, ruleProvider := range ruleProviders {
load(*ruleProvider)
loadProvider(ruleProvider)
}
}
func loadProxyProvider(ruleProviders map[string]provider.ProxyProvider) {
for _, ruleProvider := range ruleProviders {
loadProvider(ruleProvider)
}
}

2
listener/tun/ipstack/system/mars/nat/nat.go
View file

@ -1,6 +1,7 @@
package nat
import (
log "github.com/sirupsen/logrus"
"io"
"net"
"net/netip"
@ -43,6 +44,7 @@ func Start(device io.ReadWriter, gateway, portal, broadcast netip.Addr) (*TCP, *
for {
n, err := device.Read(buf)
if err != nil {
log.Warnln("system error:%s", err.Error())
continue
}

4
rule/provider/classical_strategy.go
View file

@ -32,6 +32,7 @@ func (c *classicalStrategy) ShouldResolveIP() bool {
func (c *classicalStrategy) OnUpdate(rules []string) {
var classicalRules []C.Rule
shouldResolveIP := false
count := 0
for _, rawRule := range rules {
ruleType, rule, params := ruleParse(rawRule)
r, err := parseRule(ruleType, rule, "", params)
@ -43,11 +44,12 @@ func (c *classicalStrategy) OnUpdate(rules []string) {
}
classicalRules = append(classicalRules, r)
c.count++
count++
}
}
c.rules = classicalRules
c.count = count
}
func NewClassicalStrategy() *classicalStrategy {

4
rule/provider/domain_strategy.go
View file

@ -27,16 +27,18 @@ func (d *domainStrategy) ShouldResolveIP() bool {
func (d *domainStrategy) OnUpdate(rules []string) {
domainTrie := trie.New[bool]()
count := 0
for _, rule := range rules {
err := domainTrie.Insert(rule, true)
if err != nil {
log.Warnln("invalid domain:[%s]", rule)
} else {
d.count++
count++
}
}
d.domainRules = domainTrie
d.count = count
}
func ruleParse(ruleRaw string) (string, string, []string) {

1
rule/provider/fetcher.go
View file

@ -100,6 +100,7 @@ func (f *fetcher) Update() (interface{}, bool, error) {
hash := md5.Sum(buf)
if bytes.Equal(f.hash[:], hash[:]) {
f.updatedAt = &now
os.Chtimes(f.vehicle.Path(), now, now)
return nil, true, nil
}

4
rule/provider/ipcidr_strategy.go
View file

@ -26,16 +26,18 @@ func (i *ipcidrStrategy) ShouldResolveIP() bool {
func (i *ipcidrStrategy) OnUpdate(rules []string) {
ipCidrTrie := trie.NewIpCidrTrie()
count := 0
for _, rule := range rules {
err := ipCidrTrie.AddIpCidrForString(rule)
if err != nil {
log.Warnln("invalid Ipcidr:[%s]", rule)
} else {
i.count++
count++
}
}
i.trie = ipCidrTrie
i.count = count
i.shouldResolveIP = i.count > 0
}

6
tunnel/tunnel.go
View file

@ -30,7 +30,7 @@ var (
rules []C.Rule
proxies = make(map[string]C.Proxy)
providers map[string]provider.ProxyProvider
ruleProviders map[string]*provider.RuleProvider
ruleProviders map[string]provider.RuleProvider
configMux sync.RWMutex
// Outbound Rule
@ -62,7 +62,7 @@ func Rules() []C.Rule {
}
// UpdateRules handle update rules
func UpdateRules(newRules []C.Rule, rp map[string]*provider.RuleProvider) {
func UpdateRules(newRules []C.Rule, rp map[string]provider.RuleProvider) {
configMux.Lock()
rules = newRules
ruleProviders = rp
@ -80,7 +80,7 @@ func Providers() map[string]provider.ProxyProvider {
}
// RuleProviders return all loaded rule providers
func RuleProviders() map[string]*provider.RuleProvider {
func RuleProviders() map[string]provider.RuleProvider {
return ruleProviders
}