docstring_tokens stringlengths 0 76.5k | code_tokens stringlengths 75 1.81M | label_window listlengths 4 2.12k | html_url stringlengths 74 116 | file_name stringlengths 3 311 |
|---|---|---|---|---|
level, ok := C.LogLevelMapping[req.Level] | <mask> if req.Level == "" {
<mask> req.Level = "info"
<mask> }
<mask>
<mask> mapping := map[string]T.LogLevel{
<mask> "info": T.INFO,
<mask> "debug": T.DEBUG,
<mask> "error": T.ERROR,
<mask> "warning": T.WARNING,
<mask> }
<mask>
<mask> level, ok := mapping[req.Level]
<mask> if !ok {
<mask> w.WriteHeader(http.StatusBadRequest)
<mask> render.JSON(w, r, Error{
<mask> Error: "Level error",
<mask> })
</s> Improve: config convergent and add log-level </s> remove err := tunnel.UpdateConfig()
</s> add err := cfg.UpdateRules() </s> remove _, proxies := tunnel.Config()
</s> add proxies := cfg.Proxies() </s> remove _, proxies := tunnel.Config()
</s> add proxies := cfg.Proxies() </s> remove mode, ok := modeMapping[*general.Mode]
</s> add mode, ok := config.ModeMapping[*general.Mode] </s> remove tunnel.SetMode(mode)
</s> add cfg.SetMode(mode) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | hub/server.go |
"github.com/Dreamacro/clash/config" | <mask> "os"
<mask> "os/signal"
<mask> "syscall"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/hub"
<mask> "github.com/Dreamacro/clash/proxy"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> log "github.com/sirupsen/logrus"
</s> Improve: config convergent and add log-level </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove T "github.com/Dreamacro/clash/tunnel"
</s> add </s> remove
log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | main.go |
tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() | <mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> func main() {
<mask> if err := tunnel.GetInstance().UpdateConfig(); err != nil {
<mask> log.Fatalf("Parse config error: %s", err.Error())
<mask> }
<mask>
<mask> if err := proxy.Instance().Run(); err != nil {
<mask> log.Fatalf("Proxy listen error: %s", err.Error())
<mask> }
<mask>
<mask> // Hub
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> log.Fatalf("Read config error: %s", err.Error())
</s> Improve: config convergent and add log-level </s> remove // Hub
cfg, err := C.GetConfig()
</s> add err := config.Instance().Parse() </s> remove log.Fatalf("Read config error: %s", err.Error())
}
section := cfg.Section("General")
if key, err := section.GetKey("external-controller"); err == nil {
go hub.NewHub(key.Value())
</s> add log.Fatalf("Parse config error: %s", err.Error()) </s> remove log.Fatalf("External controller error: %s", err.Error())
</s> add log.Errorf("External controller error: %s", err.Error()) </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | main.go |
err := config.Instance().Parse() | <mask> if err := proxy.Instance().Run(); err != nil {
<mask> log.Fatalf("Proxy listen error: %s", err.Error())
<mask> }
<mask>
<mask> // Hub
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> log.Fatalf("Read config error: %s", err.Error())
<mask> }
<mask>
<mask> section := cfg.Section("General")
</s> Improve: config convergent and add log-level </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove log.Fatalf("Read config error: %s", err.Error())
}
section := cfg.Section("General")
if key, err := section.GetKey("external-controller"); err == nil {
go hub.NewHub(key.Value())
</s> add log.Fatalf("Parse config error: %s", err.Error()) </s> remove log.Fatalf("External controller error: %s", err.Error())
</s> add log.Errorf("External controller error: %s", err.Error()) </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | main.go |
log.Fatalf("Parse config error: %s", err.Error()) | <mask>
<mask> // Hub
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> log.Fatalf("Read config error: %s", err.Error())
<mask> }
<mask>
<mask> section := cfg.Section("General")
<mask> if key, err := section.GetKey("external-controller"); err == nil {
<mask> go hub.NewHub(key.Value())
<mask> }
<mask>
<mask> sigCh := make(chan os.Signal, 1)
<mask> signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
<mask> <-sigCh
</s> Improve: config convergent and add log-level </s> remove // Hub
cfg, err := C.GetConfig()
</s> add err := config.Instance().Parse() </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove general := cfg.Section("General")
port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
socksPort := general.Key("socks-port").RangeInt(C.DefalutSOCKSPort, 1, 65535)
allowLan := general.Key("allow-lan").MustBool()
</s> add // Run ensure config monitoring
func (l *Listener) Run() {
signal := make(chan struct{})
go l.process(signal)
<-signal
} </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove log.Fatalf("External controller error: %s", err.Error())
</s> add log.Errorf("External controller error: %s", err.Error()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | main.go |
"github.com/Dreamacro/clash/adapters/local" | <mask> "strings"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
</s> Improve: config convergent and add log-level </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove C "github.com/Dreamacro/clash/constant"
</s> add "github.com/Dreamacro/clash/config" </s> remove
log "github.com/sirupsen/logrus"
</s> add </s> remove "gopkg.in/ini.v1"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/http/server.go |
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/riobard/go-shadowsocks2/socks"
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> tun = tunnel.GetInstance()
</s> Improve: config convergent and add log-level </s> remove tun = tunnel.GetInstance()
</s> add tun = tunnel.Instance() </s> remove tun = tunnel.GetInstance()
</s> add tun = tunnel.Instance() </s> remove "strconv"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/http/server.go | |
tun = tunnel.Instance() | <mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> tun = tunnel.GetInstance()
<mask> )
<mask>
<mask> func NewHttpProxy(addr string) (*C.ProxySignal, error) {
<mask> l, err := net.Listen("tcp", addr)
<mask> if err != nil {
</s> Improve: config convergent and add log-level </s> remove tun = tunnel.GetInstance()
</s> add tun = tunnel.Instance() </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove
func GetConfig() (*ini.File, error) {
if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
return nil, err
}
return ini.LoadSources(
ini.LoadOptions{AllowBooleanKeys: true},
ConfigPath,
)
}
</s> add </s> remove const (
ERROR LogLevel = iota
WARNING
INFO
DEBUG
</s> add log "github.com/sirupsen/logrus" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/http/server.go |
req, done := adapters.NewHttp(addr, w, r) | <mask> // padding default port
<mask> if !strings.Contains(addr, ":") {
<mask> addr += ":80"
<mask> }
<mask> req, done := NewHttp(addr, w, r)
<mask> tun.Add(req)
<mask> <-done
<mask> }
<mask>
<mask> func handleTunneling(w http.ResponseWriter, r *http.Request) {
</s> Improve: config convergent and add log-level </s> remove log.Fatalf("External controller error: %s", err.Error())
</s> add log.Errorf("External controller error: %s", err.Error()) </s> remove err := tunnel.UpdateConfig()
</s> add err := cfg.UpdateRules() </s> remove info := listener.Info()
mode := tunnel.GetMode().String()
info.Mode = &mode
render.JSON(w, r, info)
</s> add general := cfg.General()
render.JSON(w, r, configSchema{
Port: *general.Port,
SocketPort: *general.SocketPort,
AllowLan: *general.AllowLan,
Mode: general.Mode.String(),
LogLevel: general.LogLevel.String(),
}) </s> remove _, proxies := tunnel.Config()
</s> add proxies := cfg.Proxies() </s> remove _, rawProxies := tunnel.Config()
</s> add rawProxies := cfg.Proxies() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/http/server.go |
tun.Add(adapters.NewHttps(r.Host, conn)) | <mask> return
<mask> }
<mask> // w.WriteHeader(http.StatusOK) doesn't works in Safari
<mask> conn.Write([]byte("HTTP/1.1 200 OK\r\n\r\n"))
<mask> tun.Add(NewHttps(r.Host, conn))
<mask> }
<mask>
<mask> func parseHttpAddr(target string) *C.Addr {
<mask> host, port, _ := net.SplitHostPort(target)
<mask> ipAddr, err := net.ResolveIPAddr("ip", host)
<mask> var resolveIP *net.IP
<mask> if err == nil {
<mask> resolveIP = &ipAddr.IP
<mask> }
<mask>
<mask> var addType int
<mask> ip := net.ParseIP(host)
<mask> switch {
<mask> case ip == nil:
<mask> addType = socks.AtypDomainName
<mask> case ip.To4() == nil:
<mask> addType = socks.AtypIPv6
<mask> default:
<mask> addType = socks.AtypIPv4
<mask> }
<mask>
<mask> return &C.Addr{
<mask> NetWork: C.TCP,
<mask> AddrType: addType,
<mask> Host: host,
<mask> IP: resolveIP,
<mask> Port: port,
<mask> }
<mask> }
</s> Improve: config convergent and add log-level </s> remove tun.Add(NewSocks(target, conn))
}
type SocksAdapter struct {
conn net.Conn
addr *C.Addr
}
func (s *SocksAdapter) Close() {
s.conn.Close()
}
func (s *SocksAdapter) Addr() *C.Addr {
return s.addr
}
func (s *SocksAdapter) Connect(proxy C.ProxyAdapter) {
go io.Copy(s.conn, proxy.ReadWriter())
io.Copy(proxy.ReadWriter(), s.conn)
}
func parseSocksAddr(target socks.Addr) *C.Addr {
var host, port string
var ip net.IP
switch target[0] {
case socks.AtypDomainName:
host = string(target[2 : 2+target[1]])
port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
ipAddr, err := net.ResolveIPAddr("ip", host)
if err == nil {
ip = ipAddr.IP
}
case socks.AtypIPv4:
ip = net.IP(target[1 : 1+net.IPv4len])
port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
case socks.AtypIPv6:
ip = net.IP(target[1 : 1+net.IPv6len])
port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
}
return &C.Addr{
NetWork: C.TCP,
AddrType: int(target[0]),
Host: host,
IP: &ip,
Port: port,
}
}
func NewSocks(target socks.Addr, conn net.Conn) *SocksAdapter {
return &SocksAdapter{
conn: conn,
addr: parseSocksAddr(target),
}
</s> add tun.Add(adapters.NewSocks(target, conn)) </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/http/server.go |
"github.com/Dreamacro/clash/config" | <mask> "sync"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/proxy/http"
<mask> "github.com/Dreamacro/clash/proxy/socks"
<mask> )
<mask>
<mask> var (
</s> Improve: config convergent and add log-level </s> remove
log "github.com/sirupsen/logrus"
</s> add </s> remove "fmt"
"strconv"
"strings"
</s> add </s> remove R "github.com/Dreamacro/clash/rules"
</s> add </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove "github.com/Dreamacro/clash/adapters"
</s> add LocalAdapter "github.com/Dreamacro/clash/adapters/local"
RemoteAdapter "github.com/Dreamacro/clash/adapters/remote"
cfg "github.com/Dreamacro/clash/config" | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/proxy/http"
<mask> "github.com/Dreamacro/clash/proxy/socks"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> listener *Listener
<mask> once sync.Once
</s> Improve: config convergent and add log-level </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove log "github.com/sirupsen/logrus"
)
</s> add C "github.com/Dreamacro/clash/constant" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go | |
func (l *Listener) Update(base *config.Base) error {
if base.AllowLan != nil {
l.allowLan = *base.AllowLan | <mask> AllowLan: &l.allowLan,
<mask> }
<mask> }
<mask>
<mask> func (l *Listener) Update(allowLan *bool, httpPort *int, socksPort *int) error {
<mask> if allowLan != nil {
<mask> l.allowLan = *allowLan
<mask> }
<mask>
<mask> var socksErr, httpErr error
<mask> if allowLan != nil || httpPort != nil {
<mask> newHTTPPort := l.httpPort
</s> Improve: config convergent and add log-level </s> remove if allowLan != nil || httpPort != nil {
</s> add if base.AllowLan != nil || base.Port != nil { </s> remove if httpPort != nil {
newHTTPPort = *httpPort
</s> add if base.Port != nil {
newHTTPPort = *base.Port </s> remove if allowLan != nil || socksPort != nil {
</s> add if base.AllowLan != nil || base.SocketPort != nil { </s> remove if socksPort != nil {
newSocksPort = *socksPort
</s> add if base.SocketPort != nil {
newSocksPort = *base.SocketPort </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
if base.AllowLan != nil || base.Port != nil { | <mask> l.allowLan = *allowLan
<mask> }
<mask>
<mask> var socksErr, httpErr error
<mask> if allowLan != nil || httpPort != nil {
<mask> newHTTPPort := l.httpPort
<mask> if httpPort != nil {
<mask> newHTTPPort = *httpPort
<mask> }
<mask> httpErr = l.updateHTTP(newHTTPPort)
</s> Improve: config convergent and add log-level </s> remove if httpPort != nil {
newHTTPPort = *httpPort
</s> add if base.Port != nil {
newHTTPPort = *base.Port </s> remove func (l *Listener) Update(allowLan *bool, httpPort *int, socksPort *int) error {
if allowLan != nil {
l.allowLan = *allowLan
</s> add func (l *Listener) Update(base *config.Base) error {
if base.AllowLan != nil {
l.allowLan = *base.AllowLan </s> remove if allowLan != nil || socksPort != nil {
</s> add if base.AllowLan != nil || base.SocketPort != nil { </s> remove if socksPort != nil {
newSocksPort = *socksPort
</s> add if base.SocketPort != nil {
newSocksPort = *base.SocketPort </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
if base.Port != nil {
newHTTPPort = *base.Port | <mask>
<mask> var socksErr, httpErr error
<mask> if allowLan != nil || httpPort != nil {
<mask> newHTTPPort := l.httpPort
<mask> if httpPort != nil {
<mask> newHTTPPort = *httpPort
<mask> }
<mask> httpErr = l.updateHTTP(newHTTPPort)
<mask> }
<mask>
<mask> if allowLan != nil || socksPort != nil {
</s> Improve: config convergent and add log-level </s> remove if allowLan != nil || httpPort != nil {
</s> add if base.AllowLan != nil || base.Port != nil { </s> remove func (l *Listener) Update(allowLan *bool, httpPort *int, socksPort *int) error {
if allowLan != nil {
l.allowLan = *allowLan
</s> add func (l *Listener) Update(base *config.Base) error {
if base.AllowLan != nil {
l.allowLan = *base.AllowLan </s> remove if allowLan != nil || socksPort != nil {
</s> add if base.AllowLan != nil || base.SocketPort != nil { </s> remove if socksPort != nil {
newSocksPort = *socksPort
</s> add if base.SocketPort != nil {
newSocksPort = *base.SocketPort </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
if base.AllowLan != nil || base.SocketPort != nil { | <mask> }
<mask> httpErr = l.updateHTTP(newHTTPPort)
<mask> }
<mask>
<mask> if allowLan != nil || socksPort != nil {
<mask> newSocksPort := l.socksPort
<mask> if socksPort != nil {
<mask> newSocksPort = *socksPort
<mask> }
<mask> socksErr = l.updateSocks(newSocksPort)
</s> Improve: config convergent and add log-level </s> remove if socksPort != nil {
newSocksPort = *socksPort
</s> add if base.SocketPort != nil {
newSocksPort = *base.SocketPort </s> remove if httpPort != nil {
newHTTPPort = *httpPort
</s> add if base.Port != nil {
newHTTPPort = *base.Port </s> remove if allowLan != nil || httpPort != nil {
</s> add if base.AllowLan != nil || base.Port != nil { </s> remove func (l *Listener) Update(allowLan *bool, httpPort *int, socksPort *int) error {
if allowLan != nil {
l.allowLan = *allowLan
</s> add func (l *Listener) Update(base *config.Base) error {
if base.AllowLan != nil {
l.allowLan = *base.AllowLan </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
if base.SocketPort != nil {
newSocksPort = *base.SocketPort | <mask> }
<mask>
<mask> if allowLan != nil || socksPort != nil {
<mask> newSocksPort := l.socksPort
<mask> if socksPort != nil {
<mask> newSocksPort = *socksPort
<mask> }
<mask> socksErr = l.updateSocks(newSocksPort)
<mask> }
<mask>
<mask> if socksErr != nil && httpErr != nil {
</s> Improve: config convergent and add log-level </s> remove if allowLan != nil || socksPort != nil {
</s> add if base.AllowLan != nil || base.SocketPort != nil { </s> remove if httpPort != nil {
newHTTPPort = *httpPort
</s> add if base.Port != nil {
newHTTPPort = *base.Port </s> remove if allowLan != nil || httpPort != nil {
</s> add if base.AllowLan != nil || base.Port != nil { </s> remove func (l *Listener) Update(allowLan *bool, httpPort *int, socksPort *int) error {
if allowLan != nil {
l.allowLan = *allowLan
</s> add func (l *Listener) Update(base *config.Base) error {
if base.AllowLan != nil {
l.allowLan = *base.AllowLan </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} | <mask> }
<mask> return fmt.Sprintf("%s:%d", host, port)
<mask> }
<mask>
<mask> func (l *Listener) Run() error {
<mask> return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
<mask> }
<mask>
<mask> func newListener() *Listener {
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> log.Fatalf("Read config error: %s", err.Error())
<mask> }
<mask>
<mask> general := cfg.Section("General")
<mask>
<mask> port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
</s> Improve: config convergent and add log-level </s> remove general := cfg.Section("General")
port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
socksPort := general.Key("socks-port").RangeInt(C.DefalutSOCKSPort, 1, 65535)
allowLan := general.Key("allow-lan").MustBool()
</s> add // Run ensure config monitoring
func (l *Listener) Run() {
signal := make(chan struct{})
go l.process(signal)
<-signal
} </s> remove // Hub
cfg, err := C.GetConfig()
</s> add err := config.Instance().Parse() </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove log.Fatalf("Read config error: %s", err.Error())
}
section := cfg.Section("General")
if key, err := section.GetKey("external-controller"); err == nil {
go hub.NewHub(key.Value())
</s> add log.Fatalf("Parse config error: %s", err.Error()) </s> remove return &Listener{
httpPort: port,
socksPort: socksPort,
allowLan: allowLan,
}
</s> add func newListener() *Listener {
return &Listener{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
} | <mask> l.Update(&base)
<mask> }
<mask> }
<mask>
<mask> // Run ensure config monitoring
<mask> func (l *Listener) Run() {
<mask> signal := make(chan struct{})
<mask> go l.process(signal)
</s> Improve: config convergent and add log-level </s> remove general := cfg.Section("General")
port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
socksPort := general.Key("socks-port").RangeInt(C.DefalutSOCKSPort, 1, 65535)
allowLan := general.Key("allow-lan").MustBool()
</s> add // Run ensure config monitoring
func (l *Listener) Run() {
signal := make(chan struct{})
go l.process(signal)
<-signal
} </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove log.Fatalf("Read config error: %s", err.Error())
}
section := cfg.Section("General")
if key, err := section.GetKey("external-controller"); err == nil {
go hub.NewHub(key.Value())
</s> add log.Fatalf("Parse config error: %s", err.Error()) </s> remove func (l *Listener) Update(allowLan *bool, httpPort *int, socksPort *int) error {
if allowLan != nil {
l.allowLan = *allowLan
</s> add func (l *Listener) Update(base *config.Base) error {
if base.AllowLan != nil {
l.allowLan = *base.AllowLan | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
// Run ensure config monitoring
func (l *Listener) Run() {
signal := make(chan struct{})
go l.process(signal)
<-signal
} | <mask> if err != nil {
<mask> log.Fatalf("Read config error: %s", err.Error())
<mask> }
<mask>
<mask> general := cfg.Section("General")
<mask>
<mask> port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
<mask> socksPort := general.Key("socks-port").RangeInt(C.DefalutSOCKSPort, 1, 65535)
<mask> allowLan := general.Key("allow-lan").MustBool()
<mask>
<mask> return &Listener{
<mask> httpPort: port,
<mask> socksPort: socksPort,
<mask> allowLan: allowLan,
</s> Improve: config convergent and add log-level </s> remove return &Listener{
httpPort: port,
socksPort: socksPort,
allowLan: allowLan,
}
</s> add func newListener() *Listener {
return &Listener{} </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove // Hub
cfg, err := C.GetConfig()
</s> add err := config.Instance().Parse() </s> remove log.Fatalf("Read config error: %s", err.Error())
}
section := cfg.Section("General")
if key, err := section.GetKey("external-controller"); err == nil {
go hub.NewHub(key.Value())
</s> add log.Fatalf("Parse config error: %s", err.Error()) </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
func newListener() *Listener {
return &Listener{} | <mask> port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
<mask> socksPort := general.Key("socks-port").RangeInt(C.DefalutSOCKSPort, 1, 65535)
<mask> allowLan := general.Key("allow-lan").MustBool()
<mask>
<mask> return &Listener{
<mask> httpPort: port,
<mask> socksPort: socksPort,
<mask> allowLan: allowLan,
<mask> }
<mask> }
<mask>
<mask> func Instance() *Listener {
<mask> once.Do(func() {
<mask> listener = newListener()
</s> Improve: config convergent and add log-level </s> remove general := cfg.Section("General")
port := general.Key("port").RangeInt(C.DefalutHTTPPort, 1, 65535)
socksPort := general.Key("socks-port").RangeInt(C.DefalutSOCKSPort, 1, 65535)
allowLan := general.Key("allow-lan").MustBool()
</s> add // Run ensure config monitoring
func (l *Listener) Run() {
signal := make(chan struct{})
go l.process(signal)
<-signal
} </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { </s> remove if allowLan != nil || socksPort != nil {
</s> add if base.AllowLan != nil || base.SocketPort != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
// Instance return singleton instance of Listener | <mask> return &Listener{}
<mask> }
<mask>
<mask> func Instance() *Listener {
<mask> once.Do(func() {
<mask> listener = newListener()
<mask> })
<mask> return listener
<mask> }
</s> Improve: config convergent and add log-level </s> remove return &Listener{
httpPort: port,
socksPort: socksPort,
allowLan: allowLan,
}
</s> add func newListener() *Listener {
return &Listener{} </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove go tunnel.process()
go tunnel.subscribeLogs()
return tunnel
</s> add </s> remove
log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/listener.go |
<mask> package socks
<mask>
<mask> import (
<mask> "io"
<mask> "net"
<mask> "strconv"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
</s> Improve: config convergent and add log-level </s> remove "strconv"
</s> add </s> remove "io"
</s> add </s> remove "fmt"
"strconv"
"strings"
</s> add </s> remove log "github.com/sirupsen/logrus"
)
</s> add C "github.com/Dreamacro/clash/constant" | [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/socks/tcp.go | |
<mask>
<mask> import (
<mask> "io"
<mask> "net"
<mask> "strconv"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/riobard/go-shadowsocks2/socks"
</s> Improve: config convergent and add log-level </s> remove "io"
</s> add </s> remove "io"
</s> add </s> remove "fmt"
"strconv"
"strings"
</s> add </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/socks/tcp.go | |
"github.com/Dreamacro/clash/adapters/local" | <mask> "net"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/riobard/go-shadowsocks2/socks"
<mask> log "github.com/sirupsen/logrus"
<mask> )
</s> Improve: config convergent and add log-level </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove "strconv"
</s> add </s> remove C "github.com/Dreamacro/clash/constant"
</s> add "github.com/Dreamacro/clash/config" </s> remove "io"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/socks/tcp.go |
tun = tunnel.Instance() | <mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> tun = tunnel.GetInstance()
<mask> )
<mask>
<mask> func NewSocksProxy(addr string) (*C.ProxySignal, error) {
<mask> l, err := net.Listen("tcp", addr)
<mask> if err != nil {
</s> Improve: config convergent and add log-level </s> remove tun = tunnel.GetInstance()
</s> add tun = tunnel.Instance() </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove
func GetConfig() (*ini.File, error) {
if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
return nil, err
}
return ini.LoadSources(
ini.LoadOptions{AllowBooleanKeys: true},
ConfigPath,
)
}
</s> add </s> remove const (
ERROR LogLevel = iota
WARNING
INFO
DEBUG
</s> add log "github.com/sirupsen/logrus" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/socks/tcp.go |
tun.Add(adapters.NewSocks(target, conn)) | <mask> conn.Close()
<mask> return
<mask> }
<mask> conn.(*net.TCPConn).SetKeepAlive(true)
<mask> tun.Add(NewSocks(target, conn))
<mask> }
<mask>
<mask> type SocksAdapter struct {
<mask> conn net.Conn
<mask> addr *C.Addr
<mask> }
<mask>
<mask> func (s *SocksAdapter) Close() {
<mask> s.conn.Close()
<mask> }
<mask>
<mask> func (s *SocksAdapter) Addr() *C.Addr {
<mask> return s.addr
<mask> }
<mask>
<mask> func (s *SocksAdapter) Connect(proxy C.ProxyAdapter) {
<mask> go io.Copy(s.conn, proxy.ReadWriter())
<mask> io.Copy(proxy.ReadWriter(), s.conn)
<mask> }
<mask>
<mask> func parseSocksAddr(target socks.Addr) *C.Addr {
<mask> var host, port string
<mask> var ip net.IP
<mask>
<mask> switch target[0] {
<mask> case socks.AtypDomainName:
<mask> host = string(target[2 : 2+target[1]])
<mask> port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
<mask> ipAddr, err := net.ResolveIPAddr("ip", host)
<mask> if err == nil {
<mask> ip = ipAddr.IP
<mask> }
<mask> case socks.AtypIPv4:
<mask> ip = net.IP(target[1 : 1+net.IPv4len])
<mask> port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
<mask> case socks.AtypIPv6:
<mask> ip = net.IP(target[1 : 1+net.IPv6len])
<mask> port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
<mask> }
<mask>
<mask> return &C.Addr{
<mask> NetWork: C.TCP,
<mask> AddrType: int(target[0]),
<mask> Host: host,
<mask> IP: &ip,
<mask> Port: port,
<mask> }
<mask> }
<mask>
<mask> func NewSocks(target socks.Addr, conn net.Conn) *SocksAdapter {
<mask> return &SocksAdapter{
<mask> conn: conn,
<mask> addr: parseSocksAddr(target),
<mask> }
<mask> }
</s> Improve: config convergent and add log-level </s> remove tun.Add(NewHttps(r.Host, conn))
}
func parseHttpAddr(target string) *C.Addr {
host, port, _ := net.SplitHostPort(target)
ipAddr, err := net.ResolveIPAddr("ip", host)
var resolveIP *net.IP
if err == nil {
resolveIP = &ipAddr.IP
}
var addType int
ip := net.ParseIP(host)
switch {
case ip == nil:
addType = socks.AtypDomainName
case ip.To4() == nil:
addType = socks.AtypIPv6
default:
addType = socks.AtypIPv4
}
return &C.Addr{
NetWork: C.TCP,
AddrType: addType,
Host: host,
IP: resolveIP,
Port: port,
}
</s> add tun.Add(adapters.NewHttps(r.Host, conn)) </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | proxy/socks/tcp.go |
C "github.com/Dreamacro/clash/constant" | <mask>
<mask> import (
<mask> "fmt"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> const (
<mask> ERROR LogLevel = iota
<mask> WARNING
<mask> INFO
</s> Improve: config convergent and add log-level </s> remove const (
ERROR LogLevel = iota
WARNING
INFO
DEBUG
</s> add log "github.com/sirupsen/logrus" </s> remove "gopkg.in/ini.v1"
</s> add </s> remove "io"
</s> add </s> remove A "github.com/Dreamacro/clash/adapters"
</s> add A "github.com/Dreamacro/clash/adapters/remote" </s> remove "fmt"
"strconv"
"strings"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
log "github.com/sirupsen/logrus" | <mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> const (
<mask> ERROR LogLevel = iota
<mask> WARNING
<mask> INFO
<mask> DEBUG
<mask> )
<mask>
<mask> type LogLevel int
<mask>
<mask> type Log struct {
</s> Improve: config convergent and add log-level </s> remove log "github.com/sirupsen/logrus"
)
</s> add C "github.com/Dreamacro/clash/constant" </s> remove type LogLevel int
</s> add </s> remove LogLevel LogLevel
</s> add LogLevel C.LogLevel </s> remove TCP = iota
</s> add TCP NetWork = iota | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
<mask> INFO
<mask> DEBUG
<mask> )
<mask>
<mask> type LogLevel int
<mask>
<mask> type Log struct {
<mask> LogLevel LogLevel
<mask> Payload string
<mask> }
<mask>
</s> Improve: config convergent and add log-level </s> remove LogLevel LogLevel
</s> add LogLevel C.LogLevel </s> remove const (
ERROR LogLevel = iota
WARNING
INFO
DEBUG
</s> add log "github.com/sirupsen/logrus" </s> remove var modeMapping = map[string]T.Mode{
"Global": T.Global,
"Rule": T.Rule,
"Direct": T.Direct,
</s> add type configSchema struct {
Port int `json:"port"`
SocketPort int `json:"socket-port"`
AllowLan bool `json:"allow-lan"`
Mode string `json:"mode"`
LogLevel string `json:"log-level"` </s> remove log "github.com/sirupsen/logrus"
)
</s> add C "github.com/Dreamacro/clash/constant" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go | |
LogLevel C.LogLevel | <mask>
<mask> type LogLevel int
<mask>
<mask> type Log struct {
<mask> LogLevel LogLevel
<mask> Payload string
<mask> }
<mask>
<mask> func (l *Log) Type() string {
<mask> switch l.LogLevel {
</s> Improve: config convergent and add log-level </s> remove type LogLevel int
</s> add </s> remove const (
ERROR LogLevel = iota
WARNING
INFO
DEBUG
</s> add log "github.com/sirupsen/logrus" </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove var modeMapping = map[string]T.Mode{
"Global": T.Global,
"Rule": T.Rule,
"Direct": T.Direct,
</s> add type configSchema struct {
Port int `json:"port"`
SocketPort int `json:"socket-port"`
AllowLan bool `json:"allow-lan"`
Mode string `json:"mode"`
LogLevel string `json:"log-level"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
return l.LogLevel.String() | <mask> Payload string
<mask> }
<mask>
<mask> func (l *Log) Type() string {
<mask> switch l.LogLevel {
<mask> case INFO:
<mask> return "Info"
<mask> case WARNING:
<mask> return "Warning"
<mask> case ERROR:
<mask> return "Error"
<mask> case DEBUG:
<mask> return "Debug"
<mask> default:
<mask> return "Unknow"
<mask> }
<mask> }
<mask>
<mask> func print(data Log) {
<mask> switch data.LogLevel {
<mask> case INFO:
</s> Improve: config convergent and add log-level </s> remove case INFO:
</s> add case C.INFO: </s> remove case WARNING:
</s> add case C.WARNING: </s> remove case ERROR:
</s> add case C.ERROR: </s> remove LogLevel LogLevel
</s> add LogLevel C.LogLevel </s> remove case DEBUG:
</s> add case C.DEBUG: | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
case C.INFO: | <mask> }
<mask>
<mask> func print(data Log) {
<mask> switch data.LogLevel {
<mask> case INFO:
<mask> log.Infoln(data.Payload)
<mask> case WARNING:
<mask> log.Warnln(data.Payload)
<mask> case ERROR:
<mask> log.Errorln(data.Payload)
</s> Improve: config convergent and add log-level </s> remove case WARNING:
</s> add case C.WARNING: </s> remove case ERROR:
</s> add case C.ERROR: </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove case DEBUG:
</s> add case C.DEBUG: </s> remove case Global:
</s> add case cfg.Global: | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
case C.WARNING: | <mask> func print(data Log) {
<mask> switch data.LogLevel {
<mask> case INFO:
<mask> log.Infoln(data.Payload)
<mask> case WARNING:
<mask> log.Warnln(data.Payload)
<mask> case ERROR:
<mask> log.Errorln(data.Payload)
<mask> case DEBUG:
<mask> log.Debugln(data.Payload)
</s> Improve: config convergent and add log-level </s> remove case INFO:
</s> add case C.INFO: </s> remove case ERROR:
</s> add case C.ERROR: </s> remove case DEBUG:
</s> add case C.DEBUG: </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove case Direct:
</s> add case cfg.Direct: | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
case C.ERROR: | <mask> case INFO:
<mask> log.Infoln(data.Payload)
<mask> case WARNING:
<mask> log.Warnln(data.Payload)
<mask> case ERROR:
<mask> log.Errorln(data.Payload)
<mask> case DEBUG:
<mask> log.Debugln(data.Payload)
<mask> }
<mask> }
</s> Improve: config convergent and add log-level </s> remove case WARNING:
</s> add case C.WARNING: </s> remove case DEBUG:
</s> add case C.DEBUG: </s> remove case INFO:
</s> add case C.INFO: </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove case Global:
</s> add case cfg.Global: | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
case C.DEBUG: | <mask> case WARNING:
<mask> log.Warnln(data.Payload)
<mask> case ERROR:
<mask> log.Errorln(data.Payload)
<mask> case DEBUG:
<mask> log.Debugln(data.Payload)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) subscribeLogs() {
</s> Improve: config convergent and add log-level </s> remove case ERROR:
</s> add case C.ERROR: </s> remove case WARNING:
</s> add case C.WARNING: </s> remove case INFO:
</s> add case C.INFO: </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove localConn.Connect(remoConn)
</s> add switch adapter := localConn.(type) {
case *LocalAdapter.HttpAdapter:
t.handleHTTP(adapter, remoConn)
break
case *LocalAdapter.HttpsAdapter:
t.handleHTTPS(adapter, remoConn)
break
case *LocalAdapter.SocksAdapter:
t.handleSOCKS(adapter, remoConn)
break
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
if data.LogLevel <= t.logLevel {
print(data)
} | <mask> log.Fatalf("Can't subscribe tunnel log: %s", err.Error())
<mask> }
<mask> for elm := range sub {
<mask> data := elm.(Log)
<mask> print(data)
<mask> }
<mask> }
<mask>
<mask> func newLog(logLevel LogLevel, format string, v ...interface{}) Log {
<mask> return Log{
</s> Improve: config convergent and add log-level </s> remove func newLog(logLevel LogLevel, format string, v ...interface{}) Log {
</s> add func newLog(logLevel C.LogLevel, format string, v ...interface{}) Log { </s> remove func (l *Listener) Run() error {
return l.Update(&l.allowLan, &l.httpPort, &l.socksPort)
}
func newListener() *Listener {
cfg, err := C.GetConfig()
if err != nil {
log.Fatalf("Read config error: %s", err.Error())
</s> add func (l *Listener) process(signal chan<- struct{}) {
sub := config.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*config.Event)
if event.Type == "base" {
base := event.Payload.(config.Base)
l.Update(&base)
} </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) </s> remove log.Fatalf("External controller error: %s", err.Error())
</s> add log.Errorf("External controller error: %s", err.Error()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
func newLog(logLevel C.LogLevel, format string, v ...interface{}) Log { | <mask> print(data)
<mask> }
<mask> }
<mask>
<mask> func newLog(logLevel LogLevel, format string, v ...interface{}) Log {
<mask> return Log{
<mask> LogLevel: logLevel,
<mask> Payload: fmt.Sprintf(format, v...),
<mask> }
<mask> }
</s> Improve: config convergent and add log-level </s> remove print(data)
</s> add if data.LogLevel <= t.logLevel {
print(data)
} </s> remove func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
return t.rules, t.proxies
}
</s> add // Log return clash log stream </s> remove
func GetConfig() (*ini.File, error) {
if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
return nil, err
}
return ini.LoadSources(
ini.LoadOptions{AllowBooleanKeys: true},
ConfigPath,
)
}
</s> add </s> remove type LogLevel int
</s> add </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/log.go |
<mask> package tunnel
<mask>
<mask> import (
<mask> "fmt"
<mask> "strconv"
<mask> "strings"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Improve: config convergent and add log-level </s> remove "github.com/Dreamacro/clash/adapters"
</s> add LocalAdapter "github.com/Dreamacro/clash/adapters/local"
RemoteAdapter "github.com/Dreamacro/clash/adapters/remote"
cfg "github.com/Dreamacro/clash/config" </s> remove "io"
</s> add </s> remove A "github.com/Dreamacro/clash/adapters"
</s> add A "github.com/Dreamacro/clash/adapters/remote" </s> remove "strconv"
</s> add </s> remove log "github.com/sirupsen/logrus"
)
</s> add C "github.com/Dreamacro/clash/constant" | [
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go | |
LocalAdapter "github.com/Dreamacro/clash/adapters/local"
RemoteAdapter "github.com/Dreamacro/clash/adapters/remote"
cfg "github.com/Dreamacro/clash/config" | <mask> "strings"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
<mask> R "github.com/Dreamacro/clash/rules"
<mask>
<mask> "gopkg.in/eapache/channels.v1"
</s> Improve: config convergent and add log-level </s> remove R "github.com/Dreamacro/clash/rules"
</s> add </s> remove "fmt"
"strconv"
"strings"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
<mask>
<mask> "github.com/Dreamacro/clash/adapters"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
<mask> R "github.com/Dreamacro/clash/rules"
<mask>
<mask> "gopkg.in/eapache/channels.v1"
<mask> )
<mask>
<mask> var (
</s> Improve: config convergent and add log-level </s> remove "github.com/Dreamacro/clash/adapters"
</s> add LocalAdapter "github.com/Dreamacro/clash/adapters/local"
RemoteAdapter "github.com/Dreamacro/clash/adapters/remote"
cfg "github.com/Dreamacro/clash/config" </s> remove A "github.com/Dreamacro/clash/adapters"
</s> add A "github.com/Dreamacro/clash/adapters/remote" </s> remove "fmt"
"strconv"
"strings"
</s> add </s> remove "github.com/riobard/go-shadowsocks2/socks"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go | |
// Tunnel handle proxy socket and HTTP/SOCKS socket | <mask> )
<mask>
<mask> type Tunnel struct {
<mask> queue *channels.InfiniteChannel
<mask> rules []C.Rule
<mask> proxies map[string]C.Proxy
</s> Improve: config convergent and add log-level </s> remove observable *observable.Observable
logCh chan interface{}
</s> add </s> remove type LogLevel int
</s> add </s> remove const (
ERROR LogLevel = iota
WARNING
INFO
DEBUG
</s> add log "github.com/sirupsen/logrus" </s> remove tunnel = T.GetInstance()
</s> add tunnel = T.Instance()
cfg = config.Instance() </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
<mask> type Tunnel struct {
<mask> queue *channels.InfiniteChannel
<mask> rules []C.Rule
<mask> proxies map[string]C.Proxy
<mask> observable *observable.Observable
<mask> logCh chan interface{}
<mask> configLock *sync.RWMutex
<mask> traffic *C.Traffic
<mask> mode Mode
<mask> selector *adapters.Selector
<mask> }
</s> Improve: config convergent and add log-level </s> remove mode Mode
selector *adapters.Selector
</s> add // Outbound Rule
mode cfg.Mode
selector *RemoteAdapter.Selector
// Log
logCh chan interface{}
observable *observable.Observable
logLevel C.LogLevel </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go | |
// Outbound Rule
mode cfg.Mode
selector *RemoteAdapter.Selector
// Log
logCh chan interface{}
observable *observable.Observable
logLevel C.LogLevel | <mask> observable *observable.Observable
<mask> logCh chan interface{}
<mask> configLock *sync.RWMutex
<mask> traffic *C.Traffic
<mask> mode Mode
<mask> selector *adapters.Selector
<mask> }
<mask>
<mask> func (t *Tunnel) Add(req C.ServerAdapter) {
<mask> t.queue.In() <- req
<mask> }
</s> Improve: config convergent and add log-level </s> remove observable *observable.Observable
logCh chan interface{}
</s> add </s> remove func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
return t.rules, t.proxies
}
</s> add // Log return clash log stream </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
// Add request to queue | <mask> }
<mask>
<mask> func (t *Tunnel) Add(req C.ServerAdapter) {
<mask> t.queue.In() <- req
<mask> }
<mask>
<mask> // Traffic return traffic of all connections
<mask> func (t *Tunnel) Traffic() *C.Traffic {
</s> Improve: config convergent and add log-level </s> remove mode Mode
selector *adapters.Selector
</s> add // Outbound Rule
mode cfg.Mode
selector *RemoteAdapter.Selector
// Log
logCh chan interface{}
observable *observable.Observable
logLevel C.LogLevel </s> remove func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
return t.rules, t.proxies
}
</s> add // Log return clash log stream </s> remove case DEBUG:
</s> add case C.DEBUG: </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
// Traffic return traffic of all connections | <mask> }
<mask>
<mask> func (t *Tunnel) Traffic() *C.Traffic {
<mask> return t.traffic
<mask> }
<mask>
</s> Improve: config convergent and add log-level </s> remove func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
return t.rules, t.proxies
}
</s> add // Log return clash log stream </s> remove mode Mode
selector *adapters.Selector
</s> add // Outbound Rule
mode cfg.Mode
selector *RemoteAdapter.Selector
// Log
logCh chan interface{}
observable *observable.Observable
logLevel C.LogLevel </s> remove case DEBUG:
</s> add case C.DEBUG: </s> remove localConn.Connect(remoConn)
</s> add switch adapter := localConn.(type) {
case *LocalAdapter.HttpAdapter:
t.handleHTTP(adapter, remoConn)
break
case *LocalAdapter.HttpsAdapter:
t.handleHTTPS(adapter, remoConn)
break
case *LocalAdapter.SocksAdapter:
t.handleSOCKS(adapter, remoConn)
break
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
// Log return clash log stream | <mask> func (t *Tunnel) Traffic() *C.Traffic {
<mask> return t.traffic
<mask> }
<mask>
<mask> func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
<mask> return t.rules, t.proxies
<mask> }
<mask>
<mask> func (t *Tunnel) Log() *observable.Observable {
<mask> return t.observable
<mask> }
<mask>
<mask> func (t *Tunnel) SetMode(mode Mode) {
</s> Improve: config convergent and add log-level </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) </s> remove case DEBUG:
</s> add case C.DEBUG: </s> remove mode Mode
selector *adapters.Selector
</s> add // Outbound Rule
mode cfg.Mode
selector *RemoteAdapter.Selector
// Log
logCh chan interface{}
observable *observable.Observable
logLevel C.LogLevel | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) | <mask> func (t *Tunnel) Log() *observable.Observable {
<mask> return t.observable
<mask> }
<mask>
<mask> func (t *Tunnel) SetMode(mode Mode) {
<mask> t.mode = mode
<mask> }
<mask>
<mask> func (t *Tunnel) GetMode() Mode {
<mask> return t.mode
<mask> }
<mask>
<mask> func (t *Tunnel) UpdateConfig() (err error) {
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> // empty proxies and rules
<mask> proxies := make(map[string]C.Proxy)
<mask> rules := []C.Rule{}
<mask>
<mask> proxiesConfig := cfg.Section("Proxy")
<mask> rulesConfig := cfg.Section("Rule")
<mask> groupsConfig := cfg.Section("Proxy Group")
<mask>
<mask> // parse proxy
<mask> for _, key := range proxiesConfig.Keys() {
<mask> proxy := key.Strings(",")
<mask> if len(proxy) == 0 {
<mask> continue
<mask> }
<mask> switch proxy[0] {
<mask> // ss, server, port, cipter, password
<mask> case "ss":
<mask> if len(proxy) < 5 {
<mask> continue
<mask> }
<mask> ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
<mask> ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> proxies[key.Name()] = ss
<mask> }
<mask> }
<mask>
<mask> // parse rules
<mask> for _, key := range rulesConfig.Keys() {
<mask> rule := strings.Split(key.Name(), ",")
<mask> if len(rule) < 3 {
<mask> continue
<mask> }
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> rules = append(rules, R.NewFinal(rule[2]))
<mask> }
<mask> }
<mask>
<mask> // parse proxy groups
<mask> for _, key := range groupsConfig.Keys() {
</s> Improve: config convergent and add log-level </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add </s> remove for _, rule := range rulesCfg {
</s> add for _, rule := range rawRules { </s> remove rulesCfg, _ := tunnel.Config()
</s> add rawRules := cfg.Rules() </s> remove func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
return t.rules, t.proxies
}
</s> add // Log return clash log stream </s> remove case Global:
</s> add case cfg.Global: | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
<mask> case "FINAL":
<mask> rules = append(rules, R.NewFinal(rule[2]))
<mask> }
<mask> }
<mask>
<mask> // parse proxy groups
<mask> for _, key := range groupsConfig.Keys() {
<mask> rule := strings.Split(key.Value(), ",")
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "url-test":
<mask> if len(rule) < 4 {
<mask> return fmt.Errorf("URLTest need more than 4 param")
<mask> }
<mask> proxyNames := rule[1 : len(rule)-2]
<mask> delay, _ := strconv.Atoi(rule[len(rule)-1])
<mask> url := rule[len(rule)-2]
<mask> var ps []C.Proxy
<mask> for _, name := range proxyNames {
<mask> if p, ok := proxies[name]; ok {
<mask> ps = append(ps, p)
<mask> }
<mask> }
<mask>
<mask> adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
<mask> if err != nil {
<mask> return fmt.Errorf("Config error: %s", err.Error())
<mask> }
<mask> proxies[key.Name()] = adapter
<mask> case "select":
<mask> if len(rule) < 3 {
<mask> return fmt.Errorf("Selector need more than 3 param")
<mask> }
<mask> proxyNames := rule[1:]
<mask> selectProxy := make(map[string]C.Proxy)
<mask> for _, name := range proxyNames {
<mask> proxy, exist := proxies[name]
<mask> if !exist {
<mask> return fmt.Errorf("Proxy %s not exist", name)
<mask> }
<mask> selectProxy[name] = proxy
<mask> }
<mask> selector, err := adapters.NewSelector(key.Name(), selectProxy)
<mask> if err != nil {
<mask> return fmt.Errorf("Selector create error: %s", err.Error())
<mask> }
<mask> proxies[key.Name()] = selector
<mask> }
<mask> }
<mask>
<mask> // init proxy
<mask> proxies["DIRECT"] = adapters.NewDirect(t.traffic)
<mask> proxies["REJECT"] = adapters.NewReject()
<mask>
<mask> t.configLock.Lock()
<mask> defer t.configLock.Unlock()
<mask>
<mask> // stop url-test
<mask> for _, elm := range t.proxies {
<mask> urlTest, ok := elm.(*adapters.URLTest)
<mask> if ok {
<mask> urlTest.Close()
<mask> }
<mask> }
<mask>
<mask> s, err := adapters.NewSelector("Proxy", proxies)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> t.proxies = proxies
<mask> t.rules = rules
<mask> t.selector = s
<mask>
<mask> return nil
<mask> }
<mask>
<mask> func (t *Tunnel) process() {
<mask> queue := t.queue.Out()
<mask> for {
</s> Improve: config convergent and add log-level </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) </s> remove for _, rule := range rulesCfg {
</s> add for _, rule := range rawRules { </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove // Hub
cfg, err := C.GetConfig()
</s> add err := config.Instance().Parse() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go | |
case cfg.Direct: | <mask> addr := localConn.Addr()
<mask>
<mask> var proxy C.Proxy
<mask> switch t.mode {
<mask> case Direct:
<mask> proxy = t.proxies["DIRECT"]
<mask> case Global:
<mask> proxy = t.selector
<mask> // Rule
<mask> default:
</s> Improve: config convergent and add log-level </s> remove case Global:
</s> add case cfg.Global: </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() </s> remove localConn.Connect(remoConn)
</s> add switch adapter := localConn.(type) {
case *LocalAdapter.HttpAdapter:
t.handleHTTP(adapter, remoConn)
break
case *LocalAdapter.HttpsAdapter:
t.handleHTTPS(adapter, remoConn)
break
case *LocalAdapter.SocksAdapter:
t.handleSOCKS(adapter, remoConn)
break
} </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
case cfg.Global: | <mask> var proxy C.Proxy
<mask> switch t.mode {
<mask> case Direct:
<mask> proxy = t.proxies["DIRECT"]
<mask> case Global:
<mask> proxy = t.selector
<mask> // Rule
<mask> default:
<mask> proxy = t.match(addr)
<mask> }
</s> Improve: config convergent and add log-level </s> remove case Direct:
</s> add case cfg.Direct: </s> remove func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
func (t *Tunnel) GetMode() Mode {
return t.mode
}
func (t *Tunnel) UpdateConfig() (err error) {
cfg, err := C.GetConfig()
if err != nil {
return
}
// empty proxies and rules
proxies := make(map[string]C.Proxy)
rules := []C.Rule{}
proxiesConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule")
groupsConfig := cfg.Section("Proxy Group")
// parse proxy
for _, key := range proxiesConfig.Keys() {
proxy := key.Strings(",")
if len(proxy) == 0 {
continue
}
switch proxy[0] {
// ss, server, port, cipter, password
case "ss":
if len(proxy) < 5 {
continue
}
ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
ss, err := adapters.NewShadowSocks(key.Name(), ssURL, t.traffic)
if err != nil {
return err
}
proxies[key.Name()] = ss
}
}
// parse rules
for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
if len(rule) < 3 {
continue
}
rule = trimArr(rule)
switch rule[0] {
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]))
</s> add func (t *Tunnel) configMonitor(signal chan<- struct{}) {
sub := cfg.Instance().Subscribe()
signal <- struct{}{}
for elm := range sub {
event := elm.(*cfg.Event)
switch event.Type {
case "proxies":
proxies := event.Payload.(map[string]C.Proxy)
t.configLock.Lock()
t.proxies = proxies
t.configLock.Unlock()
case "rules":
rules := event.Payload.([]C.Rule)
t.configLock.Lock()
t.rules = rules
t.configLock.Unlock()
case "mode":
t.mode = event.Payload.(cfg.Mode)
case "log-level":
t.logLevel = event.Payload.(C.LogLevel) </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add </s> remove switch l.LogLevel {
case INFO:
return "Info"
case WARNING:
return "Warning"
case ERROR:
return "Error"
case DEBUG:
return "Debug"
default:
return "Unknow"
}
</s> add return l.LogLevel.String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) | <mask> proxy = t.match(addr)
<mask> }
<mask> remoConn, err := proxy.Generator(addr)
<mask> if err != nil {
<mask> t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
<mask>
<mask> localConn.Connect(remoConn)
</s> Improve: config convergent and add log-level </s> remove if err := tunnel.GetInstance().UpdateConfig(); err != nil {
log.Fatalf("Parse config error: %s", err.Error())
}
if err := proxy.Instance().Run(); err != nil {
log.Fatalf("Proxy listen error: %s", err.Error())
}
</s> add tunnel.Instance().Run()
proxy.Instance().Run()
hub.Run() </s> remove // Hub
cfg, err := C.GetConfig()
</s> add err := config.Instance().Parse() </s> remove log.Fatalf("External controller error: %s", err.Error())
</s> add log.Errorf("External controller error: %s", err.Error()) </s> remove log.Fatalf("Read config error: %s", err.Error())
}
section := cfg.Section("General")
if key, err := section.GetKey("external-controller"); err == nil {
go hub.NewHub(key.Value())
</s> add log.Fatalf("Parse config error: %s", err.Error()) </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
switch adapter := localConn.(type) {
case *LocalAdapter.HttpAdapter:
t.handleHTTP(adapter, remoConn)
break
case *LocalAdapter.HttpsAdapter:
t.handleHTTPS(adapter, remoConn)
break
case *LocalAdapter.SocksAdapter:
t.handleSOCKS(adapter, remoConn)
break
} | <mask> return
<mask> }
<mask> defer remoConn.Close()
<mask>
<mask> localConn.Connect(remoConn)
<mask> }
<mask>
<mask> func (t *Tunnel) match(addr *C.Addr) C.Proxy {
<mask> t.configLock.RLock()
<mask> defer t.configLock.RUnlock()
</s> Improve: config convergent and add log-level </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove func (t *Tunnel) Config() ([]C.Rule, map[string]C.Proxy) {
return t.rules, t.proxies
}
</s> add // Log return clash log stream </s> remove case DEBUG:
</s> add case C.DEBUG: | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter()) | <mask> a, ok := t.proxies[rule.Adapter()]
<mask> if !ok {
<mask> continue
<mask> }
<mask> t.logCh <- newLog(INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
<mask> return a
<mask> }
<mask> }
<mask> t.logCh <- newLog(INFO, "%v doesn't match any rule using DIRECT", addr.String())
<mask> return t.proxies["DIRECT"]
</s> Improve: config convergent and add log-level </s> remove t.logCh <- newLog(INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String()) </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove
// parse proxy groups
for _, key := range groupsConfig.Keys() {
rule := strings.Split(key.Value(), ",")
rule = trimArr(rule)
switch rule[0] {
case "url-test":
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
}
proxyNames := rule[1 : len(rule)-2]
delay, _ := strconv.Atoi(rule[len(rule)-1])
url := rule[len(rule)-2]
var ps []C.Proxy
for _, name := range proxyNames {
if p, ok := proxies[name]; ok {
ps = append(ps, p)
}
}
adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
if err != nil {
return fmt.Errorf("Config error: %s", err.Error())
}
proxies[key.Name()] = adapter
case "select":
if len(rule) < 3 {
return fmt.Errorf("Selector need more than 3 param")
}
proxyNames := rule[1:]
selectProxy := make(map[string]C.Proxy)
for _, name := range proxyNames {
proxy, exist := proxies[name]
if !exist {
return fmt.Errorf("Proxy %s not exist", name)
}
selectProxy[name] = proxy
}
selector, err := adapters.NewSelector(key.Name(), selectProxy)
if err != nil {
return fmt.Errorf("Selector create error: %s", err.Error())
}
proxies[key.Name()] = selector
}
}
// init proxy
proxies["DIRECT"] = adapters.NewDirect(t.traffic)
proxies["REJECT"] = adapters.NewReject()
t.configLock.Lock()
defer t.configLock.Unlock()
// stop url-test
for _, elm := range t.proxies {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
s, err := adapters.NewSelector("Proxy", proxies)
if err != nil {
return err
}
t.proxies = proxies
t.rules = rules
t.selector = s
return nil
</s> add </s> remove tunnel.SetMode(mode)
</s> add cfg.SetMode(mode) </s> remove mode, ok := modeMapping[*general.Mode]
</s> add mode, ok := config.ModeMapping[*general.Mode] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String()) | <mask> t.logCh <- newLog(INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
<mask> return a
<mask> }
<mask> }
<mask> t.logCh <- newLog(INFO, "%v doesn't match any rule using DIRECT", addr.String())
<mask> return t.proxies["DIRECT"]
<mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> logCh := make(chan interface{})
</s> Improve: config convergent and add log-level </s> remove t.logCh <- newLog(INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
</s> add t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter()) </s> remove t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
</s> add t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error()) </s> remove tunnel := &Tunnel{
</s> add return &Tunnel{ </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
// Run initial task
func (t *Tunnel) Run() {
go t.process()
go t.subscribeLogs()
signal := make(chan struct{})
go t.configMonitor(signal)
<-signal
}
| <mask> return t.proxies["DIRECT"]
<mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> logCh := make(chan interface{})
<mask> return &Tunnel{
<mask> queue: channels.NewInfiniteChannel(),
<mask> proxies: make(map[string]C.Proxy),
<mask> observable: observable.NewObservable(logCh),
</s> Improve: config convergent and add log-level </s> remove tunnel := &Tunnel{
</s> add return &Tunnel{ </s> remove t.logCh <- newLog(INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String()) </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { </s> remove go tunnel.process()
go tunnel.subscribeLogs()
return tunnel
</s> add </s> remove mode: Rule,
</s> add mode: cfg.Rule,
logLevel: C.INFO, | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
return &Tunnel{ | <mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> logCh := make(chan interface{})
<mask> tunnel := &Tunnel{
<mask> queue: channels.NewInfiniteChannel(),
<mask> proxies: make(map[string]C.Proxy),
<mask> observable: observable.NewObservable(logCh),
<mask> logCh: logCh,
<mask> configLock: &sync.RWMutex{},
</s> Improve: config convergent and add log-level </s> remove mode: Rule,
</s> add mode: cfg.Rule,
logLevel: C.INFO, </s> remove go tunnel.process()
go tunnel.subscribeLogs()
return tunnel
</s> add </s> remove t.logCh <- newLog(INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String()) </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
mode: cfg.Rule,
logLevel: C.INFO, | <mask> observable: observable.NewObservable(logCh),
<mask> logCh: logCh,
<mask> configLock: &sync.RWMutex{},
<mask> traffic: C.NewTraffic(time.Second),
<mask> mode: Rule,
<mask> }
<mask> go tunnel.process()
<mask> go tunnel.subscribeLogs()
<mask> return tunnel
<mask> }
</s> Improve: config convergent and add log-level </s> remove go tunnel.process()
go tunnel.subscribeLogs()
return tunnel
</s> add </s> remove tunnel := &Tunnel{
</s> add return &Tunnel{ </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
<mask> configLock: &sync.RWMutex{},
<mask> traffic: C.NewTraffic(time.Second),
<mask> mode: Rule,
<mask> }
<mask> go tunnel.process()
<mask> go tunnel.subscribeLogs()
<mask> return tunnel
<mask> }
<mask>
<mask> func GetInstance() *Tunnel {
<mask> once.Do(func() {
<mask> tunnel = newTunnel()
</s> Improve: config convergent and add log-level </s> remove mode: Rule,
</s> add mode: cfg.Rule,
logLevel: C.INFO, </s> remove func GetInstance() *Tunnel {
</s> add // Instance return singleton instance of Tunnel
func Instance() *Tunnel { </s> remove tunnel := &Tunnel{
</s> add return &Tunnel{ </s> remove print(data)
</s> add if data.LogLevel <= t.logLevel {
print(data)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go | |
// Instance return singleton instance of Tunnel
func Instance() *Tunnel { | <mask> go tunnel.subscribeLogs()
<mask> return tunnel
<mask> }
<mask>
<mask> func GetInstance() *Tunnel {
<mask> once.Do(func() {
<mask> tunnel = newTunnel()
<mask> })
<mask> return tunnel
<mask> }
</s> Improve: config convergent and add log-level </s> remove go tunnel.process()
go tunnel.subscribeLogs()
return tunnel
</s> add </s> remove mode: Rule,
</s> add mode: cfg.Rule,
logLevel: C.INFO, </s> remove tunnel := &Tunnel{
</s> add return &Tunnel{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83891503186098418ddca005eda337534eb929c6 | tunnel/tunnel.go |
<mask>
<mask> type URLTest struct {
<mask> *outbound.Base
<mask> tolerance uint16
<mask> lastDelay uint16
<mask> fastNode C.Proxy
<mask> single *singledo.Single
<mask> fastSingle *singledo.Single
<mask> providers []provider.ProxyProvider
<mask> }
</s> Change: adjust tolerance logic (#864) </s> remove // tolerance
if u.tolerance != 0 && u.fastNode != nil {
if u.fastNode.LastDelay() < u.lastDelay+u.tolerance {
return u.fastNode, nil
}
}
</s> add </s> remove u.fastNode = fast
u.lastDelay = fast.LastDelay()
return fast, nil
</s> add // tolerance
if u.fastNode == nil || u.fastNode.LastDelay() > fast.LastDelay() + u.tolerance {
u.fastNode = fast
}
return u.fastNode, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83a684c5516c09d13d4e8d3666c35181be383ab9 | adapters/outboundgroup/urltest.go | |
<mask> }
<mask>
<mask> func (u *URLTest) fast() C.Proxy {
<mask> elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
<mask> // tolerance
<mask> if u.tolerance != 0 && u.fastNode != nil {
<mask> if u.fastNode.LastDelay() < u.lastDelay+u.tolerance {
<mask> return u.fastNode, nil
<mask> }
<mask> }
<mask>
<mask> proxies := u.proxies()
<mask> fast := proxies[0]
<mask> min := fast.LastDelay()
<mask> for _, proxy := range proxies[1:] {
<mask> if !proxy.Alive() {
</s> Change: adjust tolerance logic (#864) </s> remove u.fastNode = fast
u.lastDelay = fast.LastDelay()
return fast, nil
</s> add // tolerance
if u.fastNode == nil || u.fastNode.LastDelay() > fast.LastDelay() + u.tolerance {
u.fastNode = fast
}
return u.fastNode, nil </s> remove lastDelay uint16
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83a684c5516c09d13d4e8d3666c35181be383ab9 | adapters/outboundgroup/urltest.go | |
// tolerance
if u.fastNode == nil || u.fastNode.LastDelay() > fast.LastDelay() + u.tolerance {
u.fastNode = fast
}
return u.fastNode, nil | <mask> min = delay
<mask> }
<mask> }
<mask>
<mask> u.fastNode = fast
<mask> u.lastDelay = fast.LastDelay()
<mask> return fast, nil
<mask> })
<mask>
<mask> return elm.(C.Proxy)
<mask> }
<mask>
</s> Change: adjust tolerance logic (#864) </s> remove // tolerance
if u.tolerance != 0 && u.fastNode != nil {
if u.fastNode.LastDelay() < u.lastDelay+u.tolerance {
return u.fastNode, nil
}
}
</s> add </s> remove lastDelay uint16
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83a684c5516c09d13d4e8d3666c35181be383ab9 | adapters/outboundgroup/urltest.go |
"strings" | <mask> "net"
<mask> "os"
<mask> "path"
<mask> "path/filepath"
<mask> "syscall"
<mask> "unicode"
<mask> "unsafe"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
</s> Fix: should split linux process name with space (#2008) </s> remove for _, s := range s {
if s < '0' || s > '9' {
return false
}
}
return true
</s> add return strings.IndexFunc(s, func(r rune) bool {
return !unicode.IsDigit(r)
}) == -1 </s> remove for i, c := range cmdline {
if c == 0 {
indexOfEndOfString = i
break
}
}
return filepath.Base(string(cmdline[:indexOfEndOfString]))
</s> add return filepath.Base(string(cmdline[:idx])) </s> remove indexOfEndOfString := len(cmdline)
</s> add idx := bytes.IndexFunc(cmdline, func(r rune) bool {
return unicode.IsControl(r) || unicode.IsSpace(r)
}) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83bfe521b1a554a02d0f33fb982cd740339ebd05 | component/process/process_linux.go |
"unicode" | <mask> "strings"
<mask> "syscall"
<mask> "unsafe"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
<mask>
</s> Fix: should split linux process name with space (#2008) </s> remove for _, s := range s {
if s < '0' || s > '9' {
return false
}
}
return true
</s> add return strings.IndexFunc(s, func(r rune) bool {
return !unicode.IsDigit(r)
}) == -1 </s> remove for i, c := range cmdline {
if c == 0 {
indexOfEndOfString = i
break
}
}
return filepath.Base(string(cmdline[:indexOfEndOfString]))
</s> add return filepath.Base(string(cmdline[:idx])) </s> remove indexOfEndOfString := len(cmdline)
</s> add idx := bytes.IndexFunc(cmdline, func(r rune) bool {
return unicode.IsControl(r) || unicode.IsSpace(r)
}) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83bfe521b1a554a02d0f33fb982cd740339ebd05 | component/process/process_linux.go |
idx := bytes.IndexFunc(cmdline, func(r rune) bool {
return unicode.IsControl(r) || unicode.IsSpace(r)
}) | <mask> return "", syscall.ESRCH
<mask> }
<mask>
<mask> func splitCmdline(cmdline []byte) string {
<mask> indexOfEndOfString := len(cmdline)
<mask>
<mask> for i, c := range cmdline {
<mask> if c == 0 {
<mask> indexOfEndOfString = i
<mask> break
</s> Fix: should split linux process name with space (#2008) </s> remove for i, c := range cmdline {
if c == 0 {
indexOfEndOfString = i
break
}
}
return filepath.Base(string(cmdline[:indexOfEndOfString]))
</s> add return filepath.Base(string(cmdline[:idx])) </s> remove for _, s := range s {
if s < '0' || s > '9' {
return false
}
}
return true
</s> add return strings.IndexFunc(s, func(r rune) bool {
return !unicode.IsDigit(r)
}) == -1 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83bfe521b1a554a02d0f33fb982cd740339ebd05 | component/process/process_linux.go |
return filepath.Base(string(cmdline[:idx])) | <mask>
<mask> func splitCmdline(cmdline []byte) string {
<mask> indexOfEndOfString := len(cmdline)
<mask>
<mask> for i, c := range cmdline {
<mask> if c == 0 {
<mask> indexOfEndOfString = i
<mask> break
<mask> }
<mask> }
<mask>
<mask> return filepath.Base(string(cmdline[:indexOfEndOfString]))
<mask> }
<mask>
<mask> func isPid(s string) bool {
<mask> for _, s := range s {
<mask> if s < '0' || s > '9' {
</s> Fix: should split linux process name with space (#2008) </s> remove indexOfEndOfString := len(cmdline)
</s> add idx := bytes.IndexFunc(cmdline, func(r rune) bool {
return unicode.IsControl(r) || unicode.IsSpace(r)
}) </s> remove for _, s := range s {
if s < '0' || s > '9' {
return false
}
}
return true
</s> add return strings.IndexFunc(s, func(r rune) bool {
return !unicode.IsDigit(r)
}) == -1 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83bfe521b1a554a02d0f33fb982cd740339ebd05 | component/process/process_linux.go |
return strings.IndexFunc(s, func(r rune) bool {
return !unicode.IsDigit(r)
}) == -1 | <mask> return filepath.Base(string(cmdline[:indexOfEndOfString]))
<mask> }
<mask>
<mask> func isPid(s string) bool {
<mask> for _, s := range s {
<mask> if s < '0' || s > '9' {
<mask> return false
<mask> }
<mask> }
<mask>
<mask> return true
<mask> }
</s> Fix: should split linux process name with space (#2008) </s> remove for i, c := range cmdline {
if c == 0 {
indexOfEndOfString = i
break
}
}
return filepath.Base(string(cmdline[:indexOfEndOfString]))
</s> add return filepath.Base(string(cmdline[:idx])) </s> remove indexOfEndOfString := len(cmdline)
</s> add idx := bytes.IndexFunc(cmdline, func(r rune) bool {
return unicode.IsControl(r) || unicode.IsSpace(r)
}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/83bfe521b1a554a02d0f33fb982cd740339ebd05 | component/process/process_linux.go |
TProxyPort int `json:"tproxy-port"` | <mask> type Inbound struct {
<mask> Port int `json:"port"`
<mask> SocksPort int `json:"socks-port"`
<mask> RedirPort int `json:"redir-port"`
<mask> MixedPort int `json:"mixed-port"`
<mask> Authentication []string `json:"authentication"`
<mask> AllowLan bool `json:"allow-lan"`
<mask> BindAddress string `json:"bind-address"`
<mask> }
<mask>
</s> Feature: add TCP TPROXY support (#1049) </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` </s> remove socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
mixedMux sync.Mutex
</s> add socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | config/config.go |
TProxyPort int `yaml:"tproxy-port"` | <mask> SocksPort int `yaml:"socks-port"`
<mask> RedirPort int `yaml:"redir-port"`
<mask> MixedPort int `yaml:"mixed-port"`
<mask> Authentication []string `yaml:"authentication"`
<mask> AllowLan bool `yaml:"allow-lan"`
<mask> BindAddress string `yaml:"bind-address"`
<mask> Mode T.TunnelMode `yaml:"mode"`
</s> Feature: add TCP TPROXY support (#1049) </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` </s> remove socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
mixedMux sync.Mutex
</s> add socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | config/config.go |
TProxyPort: cfg.TProxyPort, | <mask> Port: cfg.Port,
<mask> SocksPort: cfg.SocksPort,
<mask> RedirPort: cfg.RedirPort,
<mask> MixedPort: cfg.MixedPort,
<mask> AllowLan: cfg.AllowLan,
<mask> BindAddress: cfg.BindAddress,
<mask> },
<mask> Controller: Controller{
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | config/config.go |
TPROXY | <mask> HTTPCONNECT
<mask> SOCKS
<mask> REDIR
<mask> )
<mask>
<mask> type NetWork int
<mask>
<mask> func (n NetWork) String() string {
<mask> if n == TCP {
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` </s> remove socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
mixedMux sync.Mutex
</s> add socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | constant/metadata.go |
case TPROXY:
return "TProxy" | <mask> case REDIR:
<mask> return "Redir"
<mask> default:
<mask> return "Unknown"
<mask> }
<mask> }
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | constant/metadata.go |
TProxyPort: ports.TProxyPort, | <mask> SocksPort: ports.SocksPort,
<mask> RedirPort: ports.RedirPort,
<mask> MixedPort: ports.MixedPort,
<mask> Authentication: authenticator,
<mask> AllowLan: P.AllowLan(),
<mask> BindAddress: P.BindAddress(),
<mask> },
<mask> Mode: tunnel.Mode(),
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | hub/executor/executor.go |
if err := P.ReCreateTProxy(general.TProxyPort); err != nil {
log.Errorln("Start TProxy server error: %s", err.Error())
}
| <mask> log.Errorln("Start Redir server error: %s", err.Error())
<mask> }
<mask>
<mask> if err := P.ReCreateMixed(general.MixedPort); err != nil {
<mask> log.Errorln("Start Mixed(http and socks5) server error: %s", err.Error())
<mask> }
<mask> }
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | hub/executor/executor.go |
TProxyPort *int `json:"tproxy-port"` | <mask> SocksPort *int `json:"socks-port"`
<mask> RedirPort *int `json:"redir-port"`
<mask> MixedPort *int `json:"mixed-port"`
<mask> AllowLan *bool `json:"allow-lan"`
<mask> BindAddress *string `json:"bind-address"`
<mask> Mode *tunnel.TunnelMode `json:"mode"`
</s> Feature: add TCP TPROXY support (#1049) </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` </s> remove socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
mixedMux sync.Mutex
</s> add socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | hub/route/configs.go |
P.ReCreateTProxy(pointerOrDefault(general.TProxyPort, ports.TProxyPort)) | <mask> P.ReCreateHTTP(pointerOrDefault(general.Port, ports.Port))
<mask> P.ReCreateSocks(pointerOrDefault(general.SocksPort, ports.SocksPort))
<mask> P.ReCreateRedir(pointerOrDefault(general.RedirPort, ports.RedirPort))
<mask> P.ReCreateMixed(pointerOrDefault(general.MixedPort, ports.MixedPort))
<mask>
<mask> if general.Mode != nil {
<mask> tunnel.SetMode(*general.Mode)
<mask> }
<mask>
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | hub/route/configs.go |
socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
redirUDPListener *redir.RedirUDPListener
tproxyListener *redir.TProxyListener
tproxyUDPListener *redir.RedirUDPListener
mixedListener *mixed.MixedListener
mixedUDPLister *socks.SockUDPListener | <mask> var (
<mask> allowLan = false
<mask> bindAddress = "*"
<mask>
<mask> socksListener *socks.SockListener
<mask> socksUDPListener *socks.SockUDPListener
<mask> httpListener *http.HttpListener
<mask> redirListener *redir.RedirListener
<mask> redirUDPListener *redir.RedirUDPListener
<mask> mixedListener *mixed.MixedListener
<mask> mixedUDPLister *socks.SockUDPListener
<mask>
<mask> // lock for recreate function
<mask> socksMux sync.Mutex
<mask> httpMux sync.Mutex
<mask> redirMux sync.Mutex
</s> Feature: add TCP TPROXY support (#1049) </s> remove socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
mixedMux sync.Mutex
</s> add socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/listener.go |
socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex | <mask> mixedListener *mixed.MixedListener
<mask> mixedUDPLister *socks.SockUDPListener
<mask>
<mask> // lock for recreate function
<mask> socksMux sync.Mutex
<mask> httpMux sync.Mutex
<mask> redirMux sync.Mutex
<mask> mixedMux sync.Mutex
<mask> )
<mask>
<mask> type Ports struct {
<mask> Port int `json:"port"`
<mask> SocksPort int `json:"socks-port"`
</s> Feature: add TCP TPROXY support (#1049) </s> remove socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
redirUDPListener *redir.RedirUDPListener
mixedListener *mixed.MixedListener
mixedUDPLister *socks.SockUDPListener
</s> add socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
redirUDPListener *redir.RedirUDPListener
tproxyListener *redir.TProxyListener
tproxyUDPListener *redir.RedirUDPListener
mixedListener *mixed.MixedListener
mixedUDPLister *socks.SockUDPListener </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/listener.go |
Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` | <mask> mixedMux sync.Mutex
<mask> )
<mask>
<mask> type Ports struct {
<mask> Port int `json:"port"`
<mask> SocksPort int `json:"socks-port"`
<mask> RedirPort int `json:"redir-port"`
<mask> MixedPort int `json:"mixed-port"`
<mask> }
<mask>
<mask> func AllowLan() bool {
<mask> return allowLan
<mask> }
</s> Feature: add TCP TPROXY support (#1049) </s> remove socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
mixedMux sync.Mutex
</s> add socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/listener.go |
if tproxyListener != nil {
_, portStr, _ := net.SplitHostPort(tproxyListener.Address())
port, _ := strconv.Atoi(portStr)
ports.TProxyPort = port
}
| <mask> port, _ := strconv.Atoi(portStr)
<mask> ports.RedirPort = port
<mask> }
<mask>
<mask> if mixedListener != nil {
<mask> _, portStr, _ := net.SplitHostPort(mixedListener.Address())
<mask> port, _ := strconv.Atoi(portStr)
<mask> ports.MixedPort = port
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) </s> remove socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
redirUDPListener *redir.RedirUDPListener
mixedListener *mixed.MixedListener
mixedUDPLister *socks.SockUDPListener
</s> add socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
redirUDPListener *redir.RedirUDPListener
tproxyListener *redir.TProxyListener
tproxyUDPListener *redir.RedirUDPListener
mixedListener *mixed.MixedListener
mixedUDPLister *socks.SockUDPListener | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/listener.go |
rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) | <mask> rl := &RedirUDPListener{l, addr, false}
<mask>
<mask> c := l.(*net.UDPConn)
<mask>
<mask> err = setsockopt(c, addr)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> go func() {
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/redir/udp.go |
<mask> IPV6_TRANSPARENT = 0x4b
<mask> IPV6_RECVORIGDSTADDR = 0x4a
<mask> )
<mask>
<mask> func setsockopt(c *net.UDPConn, addr string) error {
<mask> isIPv6 := true
<mask> host, _, err := net.SplitHostPort(addr)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> ip := net.ParseIP(host)
<mask> if ip != nil && ip.To4() != nil {
<mask> isIPv6 = false
<mask> }
<mask>
<mask> rc, err := c.SyscallConn()
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> rc.Control(func(fd uintptr) {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
<mask>
<mask> if err == nil {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
<mask> }
<mask> if err == nil && isIPv6 {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
<mask> }
<mask>
<mask> if err == nil {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
<mask> }
<mask> if err == nil && isIPv6 {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
<mask> }
<mask> })
<mask>
<mask> return err
<mask> }
<mask>
<mask> func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
<mask> msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Feature: add TCP TPROXY support (#1049) </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
return errors.New("UDP redir not supported on current platform")
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/redir/udp_linux.go | |
<mask> "errors"
<mask> "net"
<mask> )
<mask>
<mask> func setsockopt(c *net.UDPConn, addr string) error {
<mask> return errors.New("UDP redir not supported on current platform")
<mask> }
<mask>
<mask> func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
<mask> return nil, errors.New("UDP redir not supported on current platform")
<mask> }
</s> Feature: add TCP TPROXY support (#1049) </s> remove func setsockopt(c *net.UDPConn, addr string) error {
isIPv6 := true
host, _, err := net.SplitHostPort(addr)
if err != nil {
return err
}
ip := net.ParseIP(host)
if ip != nil && ip.To4() != nil {
isIPv6 = false
}
rc, err := c.SyscallConn()
if err != nil {
return err
}
rc.Control(func(fd uintptr) {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
}
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
}
if err == nil && isIPv6 {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
}
})
return err
}
</s> add </s> remove err = setsockopt(c, addr)
</s> add rc, err := c.SyscallConn()
if err != nil {
return nil, err
}
err = setsockopt(rc, addr) </s> remove Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
MixedPort int `json:"mixed-port"`
</s> add Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/83efe2ae57ccae2b4b8626c2f88bfb5a391f73f2 | proxy/redir/udp_other.go | |
func Verify() bool {
instance, err := geoip2.Open(C.Path.MMDB())
if err == nil {
instance.Close()
}
return err == nil
}
| <mask> })
<mask> }
<mask>
<mask> func Instance() *geoip2.Reader {
<mask> once.Do(func() {
<mask> var err error
<mask> mmdb, err = geoip2.Open(C.Path.MMDB())
<mask> if err != nil {
<mask> log.Fatalln("Can't load mmdb: %s", err.Error())
</s> Feature: verify mmdb on initial </s> remove if _, err := os.Stat(C.Path.MMDB()); os.IsNotExist(err) {
log.Infoln("Can't find MMDB, start download")
if err := downloadMMDB(C.Path.MMDB()); err != nil {
return fmt.Errorf("Can't download MMDB: %s", err.Error())
}
</s> add if err := initMMDB(); err != nil {
return fmt.Errorf("Can't initial MMDB: %w", err) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/84f627f302cda03f8be509f5bba2e69e5fe4ccf9 | component/mmdb/mmdb.go |
"github.com/Dreamacro/clash/component/mmdb" | <mask> "os"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/log"
<mask> )
<mask>
<mask> func downloadMMDB(path string) (err error) {
</s> Feature: verify mmdb on initial </s> remove if _, err := os.Stat(C.Path.MMDB()); os.IsNotExist(err) {
log.Infoln("Can't find MMDB, start download")
if err := downloadMMDB(C.Path.MMDB()); err != nil {
return fmt.Errorf("Can't download MMDB: %s", err.Error())
}
</s> add if err := initMMDB(); err != nil {
return fmt.Errorf("Can't initial MMDB: %w", err) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/84f627f302cda03f8be509f5bba2e69e5fe4ccf9 | config/initial.go |
if err := initMMDB(); err != nil {
return fmt.Errorf("Can't initial MMDB: %w", err) | <mask> f.Close()
<mask> }
<mask>
<mask> // initial mmdb
<mask> if _, err := os.Stat(C.Path.MMDB()); os.IsNotExist(err) {
<mask> log.Infoln("Can't find MMDB, start download")
<mask> if err := downloadMMDB(C.Path.MMDB()); err != nil {
<mask> return fmt.Errorf("Can't download MMDB: %s", err.Error())
<mask> }
<mask> }
<mask> return nil
<mask> }
</s> Feature: verify mmdb on initial | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/84f627f302cda03f8be509f5bba2e69e5fe4ccf9 | config/initial.go |
"net/http" | <mask>
<mask> import (
<mask> "crypto/tls"
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/component/vmess"
<mask> )
<mask>
<mask> // WebsocketOption is options of websocket obfs
</s> Fix(vmess): set current server name in tls </s> remove Headers map[string]string
</s> add Headers http.Header </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/v2ray-plugin/websocket.go |
header := http.Header{}
for k, v := range option.Headers {
header.Add(k, v)
}
| <mask>
<mask> // NewWebsocketObfs return a HTTPObfs
<mask> func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
<mask> config := &vmess.WebsocketConfig{
<mask> Host: option.Host,
<mask> Path: option.Path,
<mask> TLS: option.TLSConfig != nil,
</s> Fix(vmess): set current server name in tls </s> remove Headers: option.Headers,
</s> add Headers: header, </s> remove var reason string
</s> add reason := err.Error() </s> remove Headers: config.WebSocketHeaders,
</s> add Headers: header, </s> remove Headers map[string]string
</s> add Headers http.Header </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/v2ray-plugin/websocket.go |
Headers: header, | <mask> config := &vmess.WebsocketConfig{
<mask> Host: option.Host,
<mask> Path: option.Path,
<mask> TLS: option.TLSConfig != nil,
<mask> Headers: option.Headers,
<mask> TLSConfig: option.TLSConfig,
<mask> }
<mask>
<mask> var err error
<mask> conn, err = vmess.NewWebsocketConn(conn, config)
</s> Fix(vmess): set current server name in tls </s> remove Headers: config.WebSocketHeaders,
</s> add Headers: header, </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/v2ray-plugin/websocket.go |
"net/http" | <mask> "math/rand"
<mask> "net"
<mask> "runtime"
<mask> "sync"
<mask>
<mask> "github.com/gofrs/uuid"
<mask> )
</s> Fix(vmess): set current server name in tls </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) </s> remove Headers map[string]string
</s> add Headers http.Header </s> remove Headers: config.WebSocketHeaders,
</s> add Headers: header, | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/vmess.go |
header := http.Header{}
for k, v := range config.WebSocketHeaders {
header.Add(k, v)
}
| <mask> }
<mask>
<mask> host := net.JoinHostPort(config.HostName, config.Port)
<mask>
<mask> var tlsConfig *tls.Config
<mask> if config.TLS {
</s> Fix(vmess): set current server name in tls </s> remove Headers map[string]string
</s> add Headers http.Header </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/vmess.go |
if host := header.Get("Host"); host != "" {
tlsConfig.ServerName = host
} | <mask> }
<mask> if tlsConfig.ClientSessionCache == nil {
<mask> tlsConfig.ClientSessionCache = getClientSessionCache()
<mask> }
<mask> }
<mask>
<mask> var wsConfig *WebsocketConfig
<mask> if config.NetWork == "ws" {
<mask> wsConfig = &WebsocketConfig{
<mask> Host: host,
</s> Fix(vmess): set current server name in tls </s> remove Headers: config.WebSocketHeaders,
</s> add Headers: header, </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) </s> remove Headers: option.Headers,
</s> add Headers: header, | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/vmess.go |
Headers: header, | <mask> if config.NetWork == "ws" {
<mask> wsConfig = &WebsocketConfig{
<mask> Host: host,
<mask> Path: config.WebSocketPath,
<mask> Headers: config.WebSocketHeaders,
<mask> TLS: config.TLS,
<mask> TLSConfig: tlsConfig,
<mask> }
<mask> }
<mask>
</s> Fix(vmess): set current server name in tls </s> remove Headers: option.Headers,
</s> add Headers: header, </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/vmess.go |
Headers http.Header | <mask>
<mask> type WebsocketConfig struct {
<mask> Host string
<mask> Path string
<mask> Headers map[string]string
<mask> TLS bool
<mask> TLSConfig *tls.Config
<mask> }
<mask>
<mask> // Read implements net.Conn.Read()
</s> Fix(vmess): set current server name in tls </s> remove var reason string
</s> add reason := err.Error() </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/websocket.go |
for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) | <mask> }
<mask>
<mask> headers := http.Header{}
<mask> if c.Headers != nil {
<mask> for k, v := range c.Headers {
<mask> headers.Set(k, v)
<mask> }
<mask> }
<mask>
<mask> wsConn, resp, err := dialer.Dial(uri.String(), headers)
<mask> if err != nil {
</s> Fix(vmess): set current server name in tls </s> remove var reason string
</s> add reason := err.Error() </s> remove Headers: option.Headers,
</s> add Headers: header, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/websocket.go |
reason := err.Error() | <mask> }
<mask>
<mask> wsConn, resp, err := dialer.Dial(uri.String(), headers)
<mask> if err != nil {
<mask> var reason string
<mask> if resp != nil {
<mask> reason = resp.Status
<mask> }
<mask> return nil, fmt.Errorf("Dial %s error: %s", host, reason)
<mask> }
</s> Fix(vmess): set current server name in tls </s> remove for k, v := range c.Headers {
headers.Set(k, v)
</s> add for k := range c.Headers {
headers.Add(k, c.Headers.Get(k)) </s> remove Headers: option.Headers,
</s> add Headers: header, </s> remove Headers map[string]string
</s> add Headers http.Header | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/85128a634d99dd038571d04a09dce81c1e78ab4b | component/vmess/websocket.go |
port, _ := strconv.ParseUint(metadata.DstPort, 10, 16) | <mask>
<mask> // StreamConn implements C.ProxyAdapter
<mask> func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption})
<mask> port, _ := strconv.ParseInt(metadata.DstPort, 10, 16)
<mask> err := snell.WriteHeader(c, metadata.String(), uint(port), s.version)
<mask> return c, err
<mask> }
<mask>
<mask> // DialContext implements C.ProxyAdapter
</s> Fix: multiple port string parsing overflow (#1868)
Ports in TCP and UDP should be parsed as an unsigned integer,
otherwise ports > 32767 get truncated to 32767. As this is
the case with Metadata.UDPAddr(), this fundamentally breaks
UDP connections where demand for high port numbers is high.
This commit fixes all known cases where ParseInt is used for ports,
and has been verified to fix Discord voice connections on port
50001~50004.
Fixes: d40e5e4fe6c11311ee1de82779a985c3ca47d03a
Co-authored-by: Hamster Tian <haotia@gmail.com> </s> remove local, _ := strconv.ParseInt(port, 10, 16)
</s> add local, _ := strconv.ParseUint(port, 10, 16) </s> remove port, _ := strconv.ParseInt(m.DstPort, 10, 16)
</s> add port, _ := strconv.ParseUint(m.DstPort, 10, 16) </s> remove local, _ = strconv.ParseInt(port, 10, 16)
</s> add local, _ = strconv.ParseUint(port, 10, 16) </s> remove local := int64(0)
</s> add local := uint64(0) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/8679968ab0a3112cfe4368118626e879609bfe67 | adapter/outbound/snell.go |
local := uint64(0) | <mask> if !destination.IsGlobalUnicast() {
<mask> return nil
<mask> }
<mask>
<mask> local := int64(0)
<mask> if dialer.LocalAddr != nil {
<mask> _, port, err := net.SplitHostPort(dialer.LocalAddr.String())
<mask> if err == nil {
<mask> local, _ = strconv.ParseInt(port, 10, 16)
<mask> }
</s> Fix: multiple port string parsing overflow (#1868)
Ports in TCP and UDP should be parsed as an unsigned integer,
otherwise ports > 32767 get truncated to 32767. As this is
the case with Metadata.UDPAddr(), this fundamentally breaks
UDP connections where demand for high port numbers is high.
This commit fixes all known cases where ParseInt is used for ports,
and has been verified to fix Discord voice connections on port
50001~50004.
Fixes: d40e5e4fe6c11311ee1de82779a985c3ca47d03a
Co-authored-by: Hamster Tian <haotia@gmail.com> </s> remove local, _ = strconv.ParseInt(port, 10, 16)
</s> add local, _ = strconv.ParseUint(port, 10, 16) </s> remove local, _ := strconv.ParseInt(port, 10, 16)
</s> add local, _ := strconv.ParseUint(port, 10, 16) </s> remove port, _ := strconv.ParseInt(m.DstPort, 10, 16)
</s> add port, _ := strconv.ParseUint(m.DstPort, 10, 16) </s> remove port, _ := strconv.ParseInt(metadata.DstPort, 10, 16)
</s> add port, _ := strconv.ParseUint(metadata.DstPort, 10, 16) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/8679968ab0a3112cfe4368118626e879609bfe67 | component/dialer/bind_others.go |
local, _ = strconv.ParseUint(port, 10, 16) | <mask> local := int64(0)
<mask> if dialer.LocalAddr != nil {
<mask> _, port, err := net.SplitHostPort(dialer.LocalAddr.String())
<mask> if err == nil {
<mask> local, _ = strconv.ParseInt(port, 10, 16)
<mask> }
<mask> }
<mask>
<mask> addr, err := lookupLocalAddr(ifaceName, network, destination, int(local))
<mask> if err != nil {
</s> Fix: multiple port string parsing overflow (#1868)
Ports in TCP and UDP should be parsed as an unsigned integer,
otherwise ports > 32767 get truncated to 32767. As this is
the case with Metadata.UDPAddr(), this fundamentally breaks
UDP connections where demand for high port numbers is high.
This commit fixes all known cases where ParseInt is used for ports,
and has been verified to fix Discord voice connections on port
50001~50004.
Fixes: d40e5e4fe6c11311ee1de82779a985c3ca47d03a
Co-authored-by: Hamster Tian <haotia@gmail.com> </s> remove local := int64(0)
</s> add local := uint64(0) </s> remove local, _ := strconv.ParseInt(port, 10, 16)
</s> add local, _ := strconv.ParseUint(port, 10, 16) </s> remove port, _ := strconv.ParseInt(m.DstPort, 10, 16)
</s> add port, _ := strconv.ParseUint(m.DstPort, 10, 16) </s> remove port, _ := strconv.ParseInt(metadata.DstPort, 10, 16)
</s> add port, _ := strconv.ParseUint(metadata.DstPort, 10, 16) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/8679968ab0a3112cfe4368118626e879609bfe67 | component/dialer/bind_others.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.