mihomo/config/config.go

425 lines
10 KiB
Go
Raw Normal View History

package config
import (
"fmt"
"io/ioutil"
2018-12-05 21:13:29 +08:00
"net"
"net/url"
"os"
2018-12-20 01:29:13 +08:00
"path/filepath"
"strings"
2018-10-06 13:15:02 +08:00
adapters "github.com/Dreamacro/clash/adapters/outbound"
"github.com/Dreamacro/clash/common/structure"
C "github.com/Dreamacro/clash/constant"
2018-12-05 21:13:29 +08:00
"github.com/Dreamacro/clash/dns"
2018-11-21 13:47:46 +08:00
"github.com/Dreamacro/clash/log"
R "github.com/Dreamacro/clash/rules"
2018-11-21 13:47:46 +08:00
T "github.com/Dreamacro/clash/tunnel"
yaml "gopkg.in/yaml.v2"
)
2018-08-12 02:23:46 +08:00
// General config
type General struct {
2018-11-21 13:47:46 +08:00
Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
AllowLan bool `json:"allow-lan"`
Mode T.Mode `json:"mode"`
LogLevel log.LogLevel `json:"log-level"`
2018-12-21 22:51:37 +08:00
ExternalController string `json:"-"`
ExternalUI string `json:"-"`
Secret string `json:"-"`
2018-08-12 02:23:46 +08:00
}
2018-12-05 21:13:29 +08:00
// DNS config
type DNS struct {
Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []dns.NameServer `yaml:"nameserver"`
Fallback []dns.NameServer `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
}
// Config is clash config manager
type Config struct {
2018-11-21 13:47:46 +08:00
General *General
2018-12-05 21:13:29 +08:00
DNS *DNS
2018-11-21 13:47:46 +08:00
Rules []C.Rule
Proxies map[string]C.Proxy
}
2018-12-05 21:13:29 +08:00
type rawDNS struct {
Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
}
type rawConfig struct {
Port int `yaml:"port"`
SocksPort int `yaml:"socks-port"`
RedirPort int `yaml:"redir-port"`
AllowLan bool `yaml:"allow-lan"`
Mode T.Mode `yaml:"mode"`
LogLevel log.LogLevel `yaml:"log-level"`
ExternalController string `yaml:"external-controller"`
2018-12-20 01:29:13 +08:00
ExternalUI string `yaml:"external-ui"`
2018-12-05 21:13:29 +08:00
Secret string `yaml:"secret"`
DNS rawDNS `yaml:"dns"`
2018-12-05 21:13:29 +08:00
Proxy []map[string]interface{} `yaml:"Proxy"`
ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
Rule []string `yaml:"Rule"`
}
2018-11-21 13:47:46 +08:00
func readConfig(path string) (*rawConfig, error) {
if _, err := os.Stat(path); os.IsNotExist(err) {
return nil, err
}
2018-11-21 13:47:46 +08:00
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
2018-10-14 21:22:58 +08:00
if len(data) == 0 {
return nil, fmt.Errorf("Configuration file %s is empty", C.Path.Config())
}
// config with some default value
2018-11-21 13:47:46 +08:00
rawConfig := &rawConfig{
AllowLan: false,
2018-12-05 21:13:29 +08:00
Mode: T.Rule,
LogLevel: log.INFO,
Rule: []string{},
Proxy: []map[string]interface{}{},
ProxyGroup: []map[string]interface{}{},
DNS: rawDNS{
2018-12-05 21:52:31 +08:00
Enable: false,
},
}
err = yaml.Unmarshal([]byte(data), &rawConfig)
return rawConfig, err
}
// Parse config
2018-11-21 13:47:46 +08:00
func Parse(path string) (*Config, error) {
config := &Config{}
rawCfg, err := readConfig(path)
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, err
}
2018-11-21 13:47:46 +08:00
general, err := parseGeneral(rawCfg)
if err != nil {
return nil, err
}
2018-11-21 13:47:46 +08:00
config.General = general
2018-11-21 13:47:46 +08:00
proxies, err := parseProxies(rawCfg)
if err != nil {
return nil, err
}
2018-11-21 13:47:46 +08:00
config.Proxies = proxies
2018-11-21 13:47:46 +08:00
rules, err := parseRules(rawCfg)
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, err
}
2018-11-21 13:47:46 +08:00
config.Rules = rules
2018-12-05 21:13:29 +08:00
dnsCfg, err := parseDNS(rawCfg.DNS)
if err != nil {
return nil, err
}
config.DNS = dnsCfg
2018-11-21 13:47:46 +08:00
return config, nil
}
2018-11-21 13:47:46 +08:00
func parseGeneral(cfg *rawConfig) (*General, error) {
port := cfg.Port
socksPort := cfg.SocksPort
redirPort := cfg.RedirPort
allowLan := cfg.AllowLan
2018-11-21 13:47:46 +08:00
externalController := cfg.ExternalController
2018-12-20 01:29:13 +08:00
externalUI := cfg.ExternalUI
2018-11-21 13:47:46 +08:00
secret := cfg.Secret
2018-12-05 21:13:29 +08:00
mode := cfg.Mode
logLevel := cfg.LogLevel
2018-12-21 10:55:21 +08:00
if externalUI != "" {
if !filepath.IsAbs(externalUI) {
externalUI = filepath.Join(C.Path.HomeDir(), externalUI)
}
if _, err := os.Stat(externalUI); os.IsNotExist(err) {
return nil, fmt.Errorf("external-ui: %s not exist", externalUI)
}
2018-12-20 01:29:13 +08:00
}
2018-11-21 13:47:46 +08:00
general := &General{
Port: port,
SocksPort: socksPort,
RedirPort: redirPort,
AllowLan: allowLan,
Mode: mode,
LogLevel: logLevel,
ExternalController: externalController,
2018-12-20 01:29:13 +08:00
ExternalUI: externalUI,
2018-11-21 13:47:46 +08:00
Secret: secret,
}
2018-11-21 13:47:46 +08:00
return general, nil
}
2018-11-21 13:47:46 +08:00
func parseProxies(cfg *rawConfig) (map[string]C.Proxy, error) {
proxies := make(map[string]C.Proxy)
proxiesConfig := cfg.Proxy
groupsConfig := cfg.ProxyGroup
decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
proxies["DIRECT"] = adapters.NewDirect()
proxies["REJECT"] = adapters.NewReject()
// parse proxy
for idx, mapping := range proxiesConfig {
proxyType, existType := mapping["type"].(string)
2018-10-27 12:57:56 +08:00
if !existType {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("Proxy %d missing type", idx)
}
var proxy C.Proxy
var err error
switch proxyType {
case "ss":
ssOption := &adapters.ShadowSocksOption{}
err = decoder.Decode(mapping, ssOption)
if err != nil {
break
}
proxy, err = adapters.NewShadowSocks(*ssOption)
2018-08-12 13:50:54 +08:00
case "socks5":
socksOption := &adapters.Socks5Option{}
err = decoder.Decode(mapping, socksOption)
2018-09-06 10:53:29 +08:00
if err != nil {
break
2018-09-06 10:53:29 +08:00
}
proxy = adapters.NewSocks5(*socksOption)
case "http":
httpOption := &adapters.HttpOption{}
err = decoder.Decode(mapping, httpOption)
if err != nil {
break
}
proxy = adapters.NewHttp(*httpOption)
case "vmess":
vmessOption := &adapters.VmessOption{}
err = decoder.Decode(mapping, vmessOption)
2018-09-06 10:53:29 +08:00
if err != nil {
break
2018-09-06 10:53:29 +08:00
}
proxy, err = adapters.NewVmess(*vmessOption)
default:
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("Unsupport proxy type: %s", proxyType)
}
2018-10-27 12:57:56 +08:00
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("Proxy [%d]: %s", idx, err.Error())
2018-10-27 12:57:56 +08:00
}
if _, exist := proxies[proxy.Name()]; exist {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("Proxy %s is the duplicate name", proxy.Name())
}
2018-10-27 12:57:56 +08:00
proxies[proxy.Name()] = proxy
}
// parse proxy group
for idx, mapping := range groupsConfig {
groupType, existType := mapping["type"].(string)
groupName, existName := mapping["name"].(string)
if !existType && existName {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
}
if _, exist := proxies[groupName]; exist {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("ProxyGroup %s: the duplicate name", groupName)
}
var group C.Proxy
var err error
switch groupType {
case "url-test":
urlTestOption := &adapters.URLTestOption{}
err = decoder.Decode(mapping, urlTestOption)
if err != nil {
break
}
ps, err := getProxies(proxies, urlTestOption.Proxies)
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
}
group, err = adapters.NewURLTest(*urlTestOption, ps)
case "select":
selectorOption := &adapters.SelectorOption{}
err = decoder.Decode(mapping, selectorOption)
if err != nil {
break
}
ps, err := getProxies(proxies, selectorOption.Proxies)
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
}
group, err = adapters.NewSelector(selectorOption.Name, ps)
2018-09-26 00:34:15 +08:00
case "fallback":
fallbackOption := &adapters.FallbackOption{}
err = decoder.Decode(mapping, fallbackOption)
if err != nil {
break
2018-09-26 00:34:15 +08:00
}
ps, err := getProxies(proxies, fallbackOption.Proxies)
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
2018-09-26 00:34:15 +08:00
}
group, err = adapters.NewFallback(*fallbackOption, ps)
}
if err != nil {
2018-11-21 13:47:46 +08:00
return nil, fmt.Errorf("Proxy %s: %s", groupName, err.Error())
}
proxies[groupName] = group
}
var ps []C.Proxy
for _, v := range proxies {
ps = append(ps, v)
}
proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", ps)
2018-11-21 13:47:46 +08:00
return proxies, nil
}
2018-11-21 13:47:46 +08:00
func parseRules(cfg *rawConfig) ([]C.Rule, error) {
rules := []C.Rule{}
rulesConfig := cfg.Rule
// parse rules
for idx, line := range rulesConfig {
rule := trimArr(strings.Split(line, ","))
var (
payload string
target string
)
switch len(rule) {
case 2:
target = rule[1]
case 3:
payload = rule[1]
target = rule[2]
default:
return nil, fmt.Errorf("Rules[%d] [- %s] error: format invalid", idx, line)
}
rule = trimArr(rule)
switch rule[0] {
2018-09-09 15:01:46 +08:00
case "DOMAIN":
rules = append(rules, R.NewDomain(payload, target))
case "DOMAIN-SUFFIX":
rules = append(rules, R.NewDomainSuffix(payload, target))
case "DOMAIN-KEYWORD":
rules = append(rules, R.NewDomainKeyword(payload, target))
case "GEOIP":
rules = append(rules, R.NewGEOIP(payload, target))
case "IP-CIDR", "IP-CIDR6":
rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough
case "FINAL":
rules = append(rules, R.NewFinal(target))
}
}
2018-11-21 13:47:46 +08:00
return rules, nil
}
2018-12-05 21:13:29 +08:00
func hostWithDefaultPort(host string, defPort string) (string, error) {
if !strings.Contains(host, ":") {
host += ":"
}
hostname, port, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
if port == "" {
port = defPort
}
return net.JoinHostPort(hostname, port), nil
}
func parseNameServer(servers []string) ([]dns.NameServer, error) {
nameservers := []dns.NameServer{}
for idx, server := range servers {
// parse without scheme .e.g 8.8.8.8:53
if host, err := hostWithDefaultPort(server, "53"); err == nil {
nameservers = append(
nameservers,
dns.NameServer{Addr: host},
)
continue
}
u, err := url.Parse(server)
if err != nil {
return nil, fmt.Errorf("DNS NameServer[%d] format error: %s", idx, err.Error())
}
if u.Scheme != "tls" {
return nil, fmt.Errorf("DNS NameServer[%d] unsupport scheme: %s", idx, u.Scheme)
}
host, err := hostWithDefaultPort(u.Host, "853")
nameservers = append(
nameservers,
dns.NameServer{
Net: "tcp-tls",
Addr: host,
},
)
}
return nameservers, nil
}
func parseDNS(cfg rawDNS) (*DNS, error) {
2018-12-05 21:13:29 +08:00
if cfg.Enable && len(cfg.NameServer) == 0 {
return nil, fmt.Errorf("If DNS configuration is turned on, NameServer cannot be empty")
}
dnsCfg := &DNS{
Enable: cfg.Enable,
Listen: cfg.Listen,
EnhancedMode: cfg.EnhancedMode,
}
if nameserver, err := parseNameServer(cfg.NameServer); err == nil {
dnsCfg.NameServer = nameserver
}
if fallback, err := parseNameServer(cfg.Fallback); err == nil {
dnsCfg.Fallback = fallback
}
return dnsCfg, nil
}