package config import ( "fmt" "io/ioutil" "os" "strings" "sync" "time" adapters "github.com/Dreamacro/clash/adapters/outbound" "github.com/Dreamacro/clash/common/observable" "github.com/Dreamacro/clash/common/structure" C "github.com/Dreamacro/clash/constant" R "github.com/Dreamacro/clash/rules" log "github.com/sirupsen/logrus" yaml "gopkg.in/yaml.v2" ) var ( config *Config once sync.Once ) // General config type General struct { Port int SocksPort int RedirPort int AllowLan bool Mode Mode LogLevel C.LogLevel } // ProxyConfig is update proxy schema type ProxyConfig struct { Port *int SocksPort *int RedirPort *int AllowLan *bool } // RawConfig is raw config struct type RawConfig struct { Port int `yaml:"port"` SocksPort int `yaml:"socks-port"` RedirPort int `yaml:"redir-port"` AllowLan bool `yaml:"allow-lan"` Mode string `yaml:"mode"` LogLevel string `yaml:"log-level"` ExternalController string `yaml:"external-controller"` Secret string `yaml:"secret"` Proxy []map[string]interface{} `yaml:"Proxy"` ProxyGroup []map[string]interface{} `yaml:"Proxy Group"` Rule []string `yaml:"Rule"` } // Config is clash config manager type Config struct { general *General rules []C.Rule proxies map[string]C.Proxy lastUpdate time.Time event chan<- interface{} reportCh chan interface{} observable *observable.Observable } // Event is event of clash config type Event struct { Type string Payload interface{} } // Subscribe config stream func (c *Config) Subscribe() observable.Subscription { sub, _ := c.observable.Subscribe() return sub } // Report return a channel for collecting report message func (c *Config) Report() chan<- interface{} { return c.reportCh } func (c *Config) readConfig() (*RawConfig, error) { if _, err := os.Stat(C.Path.Config()); os.IsNotExist(err) { return nil, err } data, err := ioutil.ReadFile(C.Path.Config()) if err != nil { return nil, err } if len(data) == 0 { return nil, fmt.Errorf("Configuration file %s is empty", C.Path.Config()) } // config with some default value rawConfig := &RawConfig{ AllowLan: false, Mode: Rule.String(), LogLevel: C.INFO.String(), Rule: []string{}, Proxy: []map[string]interface{}{}, ProxyGroup: []map[string]interface{}{}, } err = yaml.Unmarshal([]byte(data), &rawConfig) return rawConfig, err } // Parse config func (c *Config) Parse() error { cfg, err := c.readConfig() if err != nil { return err } if err := c.parseGeneral(cfg); err != nil { return err } if err := c.parseProxies(cfg); err != nil { return err } return c.parseRules(cfg) } // Proxies return proxies of clash func (c *Config) Proxies() map[string]C.Proxy { return c.proxies } // Rules return rules of clash func (c *Config) Rules() []C.Rule { return c.rules } // SetMode change mode of clash func (c *Config) SetMode(mode Mode) { c.general.Mode = mode c.event <- &Event{Type: "mode", Payload: mode} } // SetLogLevel change log level of clash func (c *Config) SetLogLevel(level C.LogLevel) { c.general.LogLevel = level c.event <- &Event{Type: "log-level", Payload: level} } // General return clash general config func (c *Config) General() General { return *c.general } // UpdateRules is a function for hot reload rules func (c *Config) UpdateRules() error { cfg, err := c.readConfig() if err != nil { return err } return c.parseRules(cfg) } func (c *Config) parseGeneral(cfg *RawConfig) error { port := cfg.Port socksPort := cfg.SocksPort redirPort := cfg.RedirPort allowLan := cfg.AllowLan logLevelString := cfg.LogLevel modeString := cfg.Mode mode, exist := ModeMapping[modeString] if !exist { return fmt.Errorf("General.mode value invalid") } logLevel, exist := C.LogLevelMapping[logLevelString] if !exist { return fmt.Errorf("General.log-level value invalid") } c.general = &General{ Port: port, SocksPort: socksPort, RedirPort: redirPort, AllowLan: allowLan, Mode: mode, LogLevel: logLevel, } if restAddr := cfg.ExternalController; restAddr != "" { c.event <- &Event{Type: "external-controller", Payload: restAddr} c.event <- &Event{Type: "secret", Payload: cfg.Secret} } c.UpdateGeneral(*c.general) return nil } // UpdateGeneral dispatch update event func (c *Config) UpdateGeneral(general General) { c.UpdateProxy(ProxyConfig{ Port: &general.Port, SocksPort: &general.SocksPort, RedirPort: &general.RedirPort, AllowLan: &general.AllowLan, }) c.event <- &Event{Type: "mode", Payload: general.Mode} c.event <- &Event{Type: "log-level", Payload: general.LogLevel} } // UpdateProxy dispatch update proxy event func (c *Config) UpdateProxy(pc ProxyConfig) { if pc.AllowLan != nil { c.general.AllowLan = *pc.AllowLan } c.general.Port = *or(pc.Port, &c.general.Port) if c.general.Port != 0 && (pc.AllowLan != nil || pc.Port != nil) { c.event <- &Event{Type: "http-addr", Payload: genAddr(c.general.Port, c.general.AllowLan)} } c.general.SocksPort = *or(pc.SocksPort, &c.general.SocksPort) if c.general.SocksPort != 0 && (pc.AllowLan != nil || pc.SocksPort != nil) { c.event <- &Event{Type: "socks-addr", Payload: genAddr(c.general.SocksPort, c.general.AllowLan)} } c.general.RedirPort = *or(pc.RedirPort, &c.general.RedirPort) if c.general.RedirPort != 0 && (pc.AllowLan != nil || pc.RedirPort != nil) { c.event <- &Event{Type: "redir-addr", Payload: genAddr(c.general.RedirPort, c.general.AllowLan)} } } func (c *Config) parseProxies(cfg *RawConfig) 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) if !existType { return 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) case "socks5": socksOption := &adapters.Socks5Option{} err = decoder.Decode(mapping, socksOption) if err != nil { break } proxy = adapters.NewSocks5(*socksOption) case "vmess": vmessOption := &adapters.VmessOption{} err = decoder.Decode(mapping, vmessOption) if err != nil { break } proxy, err = adapters.NewVmess(*vmessOption) default: return fmt.Errorf("Unsupport proxy type: %s", proxyType) } if err != nil { return fmt.Errorf("Proxy [%d]: %s", idx, err.Error()) } if _, exist := proxies[proxy.Name()]; exist { return fmt.Errorf("Proxy %s is the duplicate name", proxy.Name()) } 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 { return fmt.Errorf("ProxyGroup %d: missing type or name", idx) } if _, exist := proxies[groupName]; exist { return 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 { return 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 { return fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error()) } group, err = adapters.NewSelector(selectorOption.Name, ps) case "fallback": fallbackOption := &adapters.FallbackOption{} err = decoder.Decode(mapping, fallbackOption) if err != nil { break } ps, err := getProxies(proxies, fallbackOption.Proxies) if err != nil { return fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error()) } group, err = adapters.NewFallback(*fallbackOption, ps) } if err != nil { return 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) // close old goroutine for _, proxy := range c.proxies { switch raw := proxy.(type) { case *adapters.URLTest: raw.Close() case *adapters.Fallback: raw.Close() } } c.proxies = proxies c.event <- &Event{Type: "proxies", Payload: proxies} return nil } func (c *Config) parseRules(cfg *RawConfig) error { rules := []C.Rule{} rulesConfig := cfg.Rule // parse rules for _, line := range rulesConfig { rule := strings.Split(line, ",") if len(rule) < 3 { continue } rule = trimArr(rule) switch rule[0] { case "DOMAIN": rules = append(rules, R.NewDomain(rule[1], rule[2])) case "DOMAIN-SUFFIX": rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) case "DOMAIN-KEYWORD": rules = append(rules, R.NewDomainKeyword(rule[1], rule[2])) case "GEOIP": rules = append(rules, R.NewGEOIP(rule[1], rule[2])) case "IP-CIDR", "IP-CIDR6": rules = append(rules, R.NewIPCIDR(rule[1], rule[2])) case "FINAL": rules = append(rules, R.NewFinal(rule[2])) } } c.rules = rules c.event <- &Event{Type: "rules", Payload: rules} return nil } func (c *Config) handleResponseMessage() { for elm := range c.reportCh { event := elm.(*Event) switch event.Type { case "http-addr": if event.Payload.(bool) == false { log.Errorf("Listening HTTP proxy at %d error", c.general.Port) c.general.Port = 0 } case "socks-addr": if event.Payload.(bool) == false { log.Errorf("Listening SOCKS proxy at %d error", c.general.SocksPort) c.general.SocksPort = 0 } case "redir-addr": if event.Payload.(bool) == false { log.Errorf("Listening Redir proxy at %d error", c.general.RedirPort) c.general.RedirPort = 0 } } } } func newConfig() *Config { event := make(chan interface{}) reportCh := make(chan interface{}) config := &Config{ general: &General{}, proxies: make(map[string]C.Proxy), rules: []C.Rule{}, lastUpdate: time.Now(), event: event, reportCh: reportCh, observable: observable.NewObservable(event), } go config.handleResponseMessage() return config } // Instance return singleton instance of Config func Instance() *Config { once.Do(func() { config = newConfig() }) return config }