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 |
|---|---|---|---|---|
mixedPort := cfg.MixedPort | <mask> func parseGeneral(cfg *RawConfig) (*General, error) {
<mask> port := cfg.Port
<mask> socksPort := cfg.SocksPort
<mask> redirPort := cfg.RedirPort
<mask> allowLan := cfg.AllowLan
<mask> bindAddress := cfg.BindAddress
<mask> externalController := cfg.ExternalController
<mask> externalUI := cfg.ExternalUI
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove func handleConn(conn net.Conn, cache *cache.Cache) {
</s> add func HandleConn(conn net.Conn, cache *cache.Cache) { </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | config/config.go |
MixedPort: mixedPort, | <mask> Port: port,
<mask> SocksPort: socksPort,
<mask> RedirPort: redirPort,
<mask> AllowLan: allowLan,
<mask> BindAddress: bindAddress,
<mask> Mode: mode,
<mask> LogLevel: logLevel,
<mask> ExternalController: externalController,
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | config/config.go |
MixedPort: ports.MixedPort, | <mask> SocksPort: ports.SocksPort,
<mask> RedirPort: ports.RedirPort,
<mask> Authentication: authenticator,
<mask> AllowLan: P.AllowLan(),
<mask> BindAddress: P.BindAddress(),
<mask> Mode: tunnel.Mode(),
<mask> LogLevel: log.Level(),
<mask> }
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove go handleSocks(c)
</s> add go HandleSocks(c) </s> remove go handleConn(c, hl.cache)
</s> add go HandleConn(c, hl.cache) </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | hub/executor/executor.go |
if err := P.ReCreateMixed(general.MixedPort); err != nil {
log.Errorln("Start Mixed(http and socks5) server error: %s", err.Error())
} | <mask>
<mask> if err := P.ReCreateRedir(general.RedirPort); err != nil {
<mask> log.Errorln("Start Redir server error: %s", err.Error())
<mask> }
<mask> }
<mask>
<mask> func updateUsers(users []auth.AuthUser) {
<mask> authenticator := auth.NewAuthenticator(users)
<mask> authStore.SetAuthenticator(authenticator)
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { </s> remove func handleConn(conn net.Conn, cache *cache.Cache) {
</s> add func HandleConn(conn net.Conn, cache *cache.Cache) { </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | hub/executor/executor.go |
MixedPort *int `json:"mixed-port"` | <mask> Port *int `json:"port"`
<mask> SocksPort *int `json:"socks-port"`
<mask> RedirPort *int `json:"redir-port"`
<mask> AllowLan *bool `json:"allow-lan"`
<mask> BindAddress *string `json:"bind-address"`
<mask> Mode *tunnel.TunnelMode `json:"mode"`
<mask> LogLevel *log.LogLevel `json:"log-level"`
<mask> }
<mask>
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove go handleSocks(c)
</s> add go HandleSocks(c) </s> remove go handleConn(c, hl.cache)
</s> add go HandleConn(c, hl.cache) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | hub/route/configs.go |
P.ReCreateMixed(pointerOrDefault(general.MixedPort, ports.MixedPort)) | <mask> P.ReCreateSocks(pointerOrDefault(general.SocksPort, ports.SocksPort))
<mask> P.ReCreateRedir(pointerOrDefault(general.RedirPort, ports.RedirPort))
<mask>
<mask> if general.Mode != nil {
<mask> tunnel.SetMode(*general.Mode)
<mask> }
<mask>
<mask> if general.LogLevel != nil {
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { </s> remove func handleConn(conn net.Conn, cache *cache.Cache) {
</s> add func HandleConn(conn net.Conn, cache *cache.Cache) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | hub/route/configs.go |
go HandleConn(c, hl.cache) | <mask> break
<mask> }
<mask> continue
<mask> }
<mask> go handleConn(c, hl.cache)
<mask> }
<mask> }()
<mask>
<mask> return hl, nil
<mask> }
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove go handleSocks(c)
</s> add go HandleSocks(c) </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/http/server.go |
func HandleConn(conn net.Conn, cache *cache.Cache) { | <mask> cache.Put(loginStr, ret, time.Minute)
<mask> return
<mask> }
<mask>
<mask> func handleConn(conn net.Conn, cache *cache.Cache) {
<mask> br := bufio.NewReader(conn)
<mask> request, err := http.ReadRequest(br)
<mask> if err != nil || request.URL.Host == "" {
<mask> conn.Close()
<mask> return
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/http/server.go |
"github.com/Dreamacro/clash/proxy/mixed" | <mask> "github.com/Dreamacro/clash/log"
<mask> "github.com/Dreamacro/clash/proxy/http"
<mask> "github.com/Dreamacro/clash/proxy/redir"
<mask> "github.com/Dreamacro/clash/proxy/socks"
<mask> )
<mask>
<mask> var (
</s> Feature: add Mixed(http+socks5) proxy listening (#685) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/listener.go |
mixedListener *mixed.MixedListener
mixedUDPLister *socks.SockUDPListener | <mask> redirListener *redir.RedirListener
<mask> redirUDPListener *redir.RedirUDPListener
<mask> )
<mask>
<mask> type listener interface {
<mask> Close()
</s> Feature: add Mixed(http+socks5) proxy listening (#685) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/listener.go |
MixedPort int `json:"mixed-port"` | <mask> Port int `json:"port"`
<mask> SocksPort int `json:"socks-port"`
<mask> RedirPort int `json:"redir-port"`
<mask> }
<mask>
<mask> func AllowLan() bool {
<mask> return allowLan
<mask> }
<mask>
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/listener.go |
if mixedListener != nil {
_, portStr, _ := net.SplitHostPort(mixedListener.Address())
port, _ := strconv.Atoi(portStr)
ports.MixedPort = port
}
| <mask> ports.RedirPort = port
<mask> }
<mask>
<mask> return ports
<mask> }
<mask>
<mask> func portIsZero(addr string) bool {
<mask> _, port, err := net.SplitHostPort(addr)
<mask> if port == "0" || port == "" || err != nil {
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove func handleConn(conn net.Conn, cache *cache.Cache) {
</s> add func HandleConn(conn net.Conn, cache *cache.Cache) { </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/listener.go |
go HandleSocks(c) | <mask> break
<mask> }
<mask> continue
<mask> }
<mask> go handleSocks(c)
<mask> }
<mask> }()
<mask>
<mask> return sl, nil
<mask> }
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove go handleConn(c, hl.cache)
</s> add go HandleConn(c, hl.cache) </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/socks/tcp.go |
func HandleSocks(conn net.Conn) { | <mask> func (l *SockListener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handleSocks(conn net.Conn) {
<mask> target, command, err := socks5.ServerHandshake(conn, authStore.Authenticator())
<mask> if err != nil {
<mask> conn.Close()
<mask> return
<mask> }
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove func handleConn(conn net.Conn, cache *cache.Cache) {
</s> add func HandleConn(conn net.Conn, cache *cache.Cache) { </s> remove conn.(*net.TCPConn).SetKeepAlive(true)
</s> add if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/socks/tcp.go |
if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
} | <mask> if err != nil {
<mask> conn.Close()
<mask> return
<mask> }
<mask> conn.(*net.TCPConn).SetKeepAlive(true)
<mask> if command == socks5.CmdUDPAssociate {
<mask> defer conn.Close()
<mask> io.Copy(ioutil.Discard, conn)
<mask> return
<mask> }
</s> Feature: add Mixed(http+socks5) proxy listening (#685) </s> remove func handleConn(conn net.Conn, cache *cache.Cache) {
</s> add func HandleConn(conn net.Conn, cache *cache.Cache) { </s> remove func handleSocks(conn net.Conn) {
</s> add func HandleSocks(conn net.Conn) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3a27cfc4a13050a06c254b08acbc010eda045920 | proxy/socks/tcp.go |
SearchDomains []string | <mask> DefaultNameserver []dns.NameServer `yaml:"default-nameserver"`
<mask> FakeIPRange *fakeip.Pool
<mask> Hosts *trie.DomainTrie
<mask> NameServerPolicy map[string]dns.NameServer
<mask> }
<mask>
<mask> // FallbackFilter config
<mask> type FallbackFilter struct {
<mask> GeoIP bool `yaml:"geoip"`
</s> Feature: add support for dns search domains (#2597) </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | config/config.go |
SearchDomains []string `yaml:"search-domains"` | <mask> FakeIPRange string `yaml:"fake-ip-range"`
<mask> FakeIPFilter []string `yaml:"fake-ip-filter"`
<mask> DefaultNameserver []string `yaml:"default-nameserver"`
<mask> NameServerPolicy map[string]string `yaml:"nameserver-policy"`
<mask> }
<mask>
<mask> type RawFallbackFilter struct {
<mask> GeoIP bool `yaml:"geoip"`
</s> Feature: add support for dns search domains (#2597) </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | config/config.go |
if len(cfg.SearchDomains) != 0 {
for _, domain := range cfg.SearchDomains {
if strings.HasPrefix(domain, ".") || strings.HasSuffix(domain, ".") {
return nil, errors.New("search domains should not start or end with '.'")
}
if strings.Contains(domain, ":") {
return nil, errors.New("search domains are for ipv4 only and should not contain ports")
}
}
dnsCfg.SearchDomains = cfg.SearchDomains
}
| <mask> if cfg.UseHosts {
<mask> dnsCfg.Hosts = hosts
<mask> }
<mask>
<mask> return dnsCfg, nil
<mask> }
<mask>
<mask> func parseAuthentication(rawRecords []string) []auth.AuthUser {
</s> Feature: add support for dns search domains (#2597) </s> remove if len(ips) == 0 {
</s> add if len(ips) != 0 {
return ips, nil
} else if len(r.searchDomains) == 0 { </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound </s> remove ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
</s> add ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
searchDomains: config.SearchDomains, </s> remove msg, err := r.Exchange(query)
</s> add msg, err := r.ExchangeContext(ctx, query) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | config/config.go |
searchDomains []string | <mask> lruCache *cache.LruCache
<mask> policy *trie.DomainTrie
<mask> }
<mask>
<mask> // LookupIP request with TypeA and TypeAAAA, priority return TypeA
<mask> func (r *Resolver) LookupIP(ctx context.Context, host string) (ip []net.IP, err error) {
<mask> ctx, cancel := context.WithCancel(ctx)
<mask> defer cancel()
</s> Feature: add support for dns search domains (#2597) </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound </s> remove msg, err := r.Exchange(query)
</s> add msg, err := r.ExchangeContext(ctx, query) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | dns/resolver.go |
msg, err := r.ExchangeContext(ctx, query) | <mask>
<mask> query := &D.Msg{}
<mask> query.SetQuestion(D.Fqdn(host), dnsType)
<mask>
<mask> msg, err := r.Exchange(query)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> ips := msgToIP(msg)
</s> Feature: add support for dns search domains (#2597) </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound </s> remove if len(ips) == 0 {
</s> add if len(ips) != 0 {
return ips, nil
} else if len(r.searchDomains) == 0 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | dns/resolver.go |
if len(ips) != 0 {
return ips, nil
} else if len(r.searchDomains) == 0 { | <mask> return nil, err
<mask> }
<mask>
<mask> ips := msgToIP(msg)
<mask> if len(ips) == 0 {
<mask> return nil, resolver.ErrIPNotFound
<mask> }
<mask> return ips, nil
<mask> }
<mask>
</s> Feature: add support for dns search domains (#2597) </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound </s> remove msg, err := r.Exchange(query)
</s> add msg, err := r.ExchangeContext(ctx, query) </s> remove ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
</s> add ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
searchDomains: config.SearchDomains, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | dns/resolver.go |
// query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound | <mask> ips := msgToIP(msg)
<mask> if len(ips) == 0 {
<mask> return nil, resolver.ErrIPNotFound
<mask> }
<mask> return ips, nil
<mask> }
<mask>
<mask> func (r *Resolver) msgToDomain(msg *D.Msg) string {
<mask> if len(msg.Question) > 0 {
<mask> return strings.TrimRight(msg.Question[0].Name, ".")
</s> Feature: add support for dns search domains (#2597) </s> remove if len(ips) == 0 {
</s> add if len(ips) != 0 {
return ips, nil
} else if len(r.searchDomains) == 0 { </s> remove msg, err := r.Exchange(query)
</s> add msg, err := r.ExchangeContext(ctx, query) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | dns/resolver.go |
SearchDomains []string | <mask> Hosts *trie.DomainTrie
<mask> Policy map[string]NameServer
<mask> }
<mask>
<mask> func NewResolver(config Config) *Resolver {
<mask> defaultResolver := &Resolver{
</s> Feature: add support for dns search domains (#2597) </s> remove ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
</s> add ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
searchDomains: config.SearchDomains, </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | dns/resolver.go |
ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
searchDomains: config.SearchDomains, | <mask> lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
<mask> }
<mask>
<mask> r := &Resolver{
<mask> ipv6: config.IPv6,
<mask> main: transform(config.Main, defaultResolver),
<mask> lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
<mask> hosts: config.Hosts,
<mask> }
<mask>
<mask> if len(config.Fallback) != 0 {
<mask> r.fallback = transform(config.Fallback, defaultResolver)
<mask> }
</s> Feature: add support for dns search domains (#2597) </s> remove if len(ips) == 0 {
</s> add if len(ips) != 0 {
return ips, nil
} else if len(r.searchDomains) == 0 { </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound </s> remove Default: c.DefaultNameserver,
Policy: c.NameServerPolicy,
</s> add Default: c.DefaultNameserver,
Policy: c.NameServerPolicy,
SearchDomains: c.SearchDomains, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | dns/resolver.go |
Default: c.DefaultNameserver,
Policy: c.NameServerPolicy,
SearchDomains: c.SearchDomains, | <mask> GeoIPCode: c.FallbackFilter.GeoIPCode,
<mask> IPCIDR: c.FallbackFilter.IPCIDR,
<mask> Domain: c.FallbackFilter.Domain,
<mask> },
<mask> Default: c.DefaultNameserver,
<mask> Policy: c.NameServerPolicy,
<mask> }
<mask>
<mask> r := dns.NewResolver(cfg)
<mask> m := dns.NewEnhancer(cfg)
<mask>
</s> Feature: add support for dns search domains (#2597) </s> remove ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
</s> add ipv6: config.IPv6,
main: transform(config.Main, defaultResolver),
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)),
hosts: config.Hosts,
searchDomains: config.SearchDomains, </s> remove msg, err := r.Exchange(query)
</s> add msg, err := r.ExchangeContext(ctx, query) </s> remove return ips, nil
</s> add // query provided search domains serially
for _, domain := range r.searchDomains {
q := &D.Msg{}
q.SetQuestion(D.Fqdn(fmt.Sprintf("%s.%s", host, domain)), dnsType)
msg, err := r.ExchangeContext(ctx, q)
if err != nil {
return nil, err
}
ips := msgToIP(msg)
if len(ips) != 0 {
return ips, nil
}
}
return nil, resolver.ErrIPNotFound </s> remove if len(ips) == 0 {
</s> add if len(ips) != 0 {
return ips, nil
} else if len(r.searchDomains) == 0 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3b1d319820793fd9b7e4aa9a36125c39a8693d58 | hub/executor/executor.go |
n := t.search(t.root, parts) | <mask> if !valid || parts[0] == "" {
<mask> return nil
<mask> }
<mask>
<mask> n := t.root
<mask> var dotWildcardNode *Node
<mask> var wildcardNode *Node
<mask> for i := len(parts) - 1; i >= 0; i-- {
<mask> part := parts[i]
<mask>
<mask> if node := n.getChild(dotWildcard); node != nil {
<mask> dotWildcardNode = node
<mask> }
<mask>
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove if node := n.getChild(dotWildcard); node != nil {
dotWildcardNode = node
}
</s> add if n.Data == nil {
return nil
} </s> remove child := n.getChild(part)
if child == nil && wildcardNode != nil {
child = wildcardNode.getChild(part)
}
wildcardNode = n.getChild(wildcard)
</s> add return n
} </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
if n.Data == nil {
return nil
} | <mask> var wildcardNode *Node
<mask> for i := len(parts) - 1; i >= 0; i-- {
<mask> part := parts[i]
<mask>
<mask> if node := n.getChild(dotWildcard); node != nil {
<mask> dotWildcardNode = node
<mask> }
<mask>
<mask> child := n.getChild(part)
<mask> if child == nil && wildcardNode != nil {
<mask> child = wildcardNode.getChild(part)
<mask> }
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove n := t.root
var dotWildcardNode *Node
var wildcardNode *Node
for i := len(parts) - 1; i >= 0; i-- {
part := parts[i]
</s> add n := t.search(t.root, parts) </s> remove child := n.getChild(part)
if child == nil && wildcardNode != nil {
child = wildcardNode.getChild(part)
}
wildcardNode = n.getChild(wildcard)
</s> add return n
} </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
return n
} | <mask> if node := n.getChild(dotWildcard); node != nil {
<mask> dotWildcardNode = node
<mask> }
<mask>
<mask> child := n.getChild(part)
<mask> if child == nil && wildcardNode != nil {
<mask> child = wildcardNode.getChild(part)
<mask> }
<mask> wildcardNode = n.getChild(wildcard)
<mask>
<mask> n = child
<mask> if n == nil {
<mask> n = wildcardNode
<mask> wildcardNode = nil
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove if node := n.getChild(dotWildcard); node != nil {
dotWildcardNode = node
}
</s> add if n.Data == nil {
return nil
} </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove n := t.root
var dotWildcardNode *Node
var wildcardNode *Node
for i := len(parts) - 1; i >= 0; i-- {
part := parts[i]
</s> add n := t.search(t.root, parts) </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} | <mask> child = wildcardNode.getChild(part)
<mask> }
<mask> wildcardNode = n.getChild(wildcard)
<mask>
<mask> n = child
<mask> if n == nil {
<mask> n = wildcardNode
<mask> wildcardNode = nil
<mask> }
<mask>
<mask> if n == nil {
<mask> break
<mask> }
<mask> }
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove child := n.getChild(part)
if child == nil && wildcardNode != nil {
child = wildcardNode.getChild(part)
}
wildcardNode = n.getChild(wildcard)
</s> add return n
} </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if node := n.getChild(dotWildcard); node != nil {
dotWildcardNode = node
}
</s> add if n.Data == nil {
return nil
} </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove return nil
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | <mask> n = wildcardNode
<mask> wildcardNode = nil
<mask> }
<mask>
<mask> if n == nil {
<mask> break
<mask> }
<mask> }
<mask>
<mask> if n == nil {
<mask> if dotWildcardNode != nil {
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove child := n.getChild(part)
if child == nil && wildcardNode != nil {
child = wildcardNode.getChild(part)
}
wildcardNode = n.getChild(wildcard)
</s> add return n
} </s> remove return nil
</s> add </s> remove if n.Data == nil {
return nil
</s> add if c := node.getChild(dotWildcard); c != nil {
return c | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | <mask> break
<mask> }
<mask> }
<mask>
<mask> if n == nil {
<mask> if dotWildcardNode != nil {
<mask> return dotWildcardNode
<mask> }
<mask> return nil
<mask> }
<mask>
<mask> if n.Data == nil {
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove return nil
</s> add </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n.Data == nil {
return nil
</s> add if c := node.getChild(dotWildcard); c != nil {
return c </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove child := n.getChild(part)
if child == nil && wildcardNode != nil {
child = wildcardNode.getChild(part)
}
wildcardNode = n.getChild(wildcard)
</s> add return n
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
<mask> if n == nil {
<mask> if dotWildcardNode != nil {
<mask> return dotWildcardNode
<mask> }
<mask> return nil
<mask> }
<mask>
<mask> if n.Data == nil {
<mask> return nil
<mask> }
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n.Data == nil {
return nil
</s> add if c := node.getChild(dotWildcard); c != nil {
return c </s> remove child := n.getChild(part)
if child == nil && wildcardNode != nil {
child = wildcardNode.getChild(part)
}
wildcardNode = n.getChild(wildcard)
</s> add return n
} </s> remove return n
</s> add return nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go | |
if c := node.getChild(dotWildcard); c != nil {
return c | <mask> }
<mask> return nil
<mask> }
<mask>
<mask> if n.Data == nil {
<mask> return nil
<mask> }
<mask>
<mask> return n
<mask> }
<mask>
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove return nil
</s> add </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove return n
</s> add return nil </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
return nil | <mask> if n.Data == nil {
<mask> return nil
<mask> }
<mask>
<mask> return n
<mask> }
<mask>
<mask> // New returns a new, empty Trie.
<mask> func New() *DomainTrie {
<mask> return &DomainTrie{root: newNode(nil)}
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove return nil
</s> add </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n.Data == nil {
return nil
</s> add if c := node.getChild(dotWildcard); c != nil {
return c </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain.go |
"+.stun.*.*",
"+.stun.*.*.*",
"+.stun.*.*.*.*",
"stun.l.google.com", | <mask> ".org",
<mask> ".example.net",
<mask> ".apple.*",
<mask> "+.foo.com",
<mask> }
<mask>
<mask> for _, domain := range domains {
<mask> tree.Insert(domain, localIP)
<mask> }
<mask>
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove if node := n.getChild(dotWildcard); node != nil {
dotWildcardNode = node
}
</s> add if n.Data == nil {
return nil
} </s> remove n := t.root
var dotWildcardNode *Node
var wildcardNode *Node
for i := len(parts) - 1; i >= 0; i-- {
part := parts[i]
</s> add n := t.search(t.root, parts) </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n </s> remove if n.Data == nil {
return nil
</s> add if c := node.getChild(dotWildcard); c != nil {
return c </s> remove if n == nil {
break
</s> add if c := node.getChild(parts[len(parts)-1]); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain_test.go |
assert.NotNil(t, tree.Search("global.stun.website.com")) | <mask> assert.NotNil(t, tree.Search("test.example.net"))
<mask> assert.NotNil(t, tree.Search("test.apple.com"))
<mask> assert.NotNil(t, tree.Search("test.foo.com"))
<mask> assert.NotNil(t, tree.Search("foo.com"))
<mask> assert.Nil(t, tree.Search("foo.sub.example.com"))
<mask> assert.Nil(t, tree.Search("foo.example.dev"))
<mask> assert.Nil(t, tree.Search("example.com"))
<mask> }
</s> Fix: domain trie should backtrack to parent if match fail (#758) </s> remove if n.Data == nil {
return nil
</s> add if c := node.getChild(dotWildcard); c != nil {
return c </s> remove n = child
if n == nil {
n = wildcardNode
wildcardNode = nil
}
</s> add func (t *DomainTrie) search(node *Node, parts []string) *Node {
if len(parts) == 0 {
return node
} </s> remove return nil
</s> add </s> remove if n == nil {
if dotWildcardNode != nil {
return dotWildcardNode
</s> add if c := node.getChild(wildcard); c != nil {
if n := t.search(c, parts[:len(parts)-1]); n != nil {
return n | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/3dfff84cc3d0aa2ee6fedb5ad535a7b75706b309 | component/trie/domain_test.go |
// forward compatibility before 1.0
func readRawConfig(path string) ([]byte, error) {
data, err := ioutil.ReadFile(path)
if err == nil && len(data) != 0 {
return data, nil
}
if filepath.Ext(path) != ".yaml" {
return nil, err
}
path = path[:len(path)-5] + ".yml"
return ioutil.ReadFile(path)
}
| <mask> ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
<mask> Rule []string `yaml:"Rule"`
<mask> }
<mask>
<mask> func readConfig(path string) (*rawConfig, error) {
<mask> if _, err := os.Stat(path); os.IsNotExist(err) {
<mask> return nil, err
<mask> }
<mask> data, err := readRawConfig(path)
</s> Standardized: use recommend extension & forward compatibility before 1.0 </s> remove data, err := ioutil.ReadFile(path)
</s> add data, err := readRawConfig(path) </s> remove // initial config.yml
</s> add // initial config.yaml </s> remove return P.Join(p.homedir, "config.yml")
</s> add return P.Join(p.homedir, "config.yaml") | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/407de7388cbb76296b26a364b450a810fb443854 | config/config.go |
data, err := readRawConfig(path) | <mask> func readConfig(path string) (*rawConfig, error) {
<mask> if _, err := os.Stat(path); os.IsNotExist(err) {
<mask> return nil, err
<mask> }
<mask> data, err := ioutil.ReadFile(path)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> if len(data) == 0 {
</s> Standardized: use recommend extension & forward compatibility before 1.0 </s> remove // initial config.yml
</s> add // initial config.yaml </s> remove return P.Join(p.homedir, "config.yml")
</s> add return P.Join(p.homedir, "config.yaml") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/407de7388cbb76296b26a364b450a810fb443854 | config/config.go |
// initial config.yaml | <mask> return fmt.Errorf("Can't create config directory %s: %s", dir, err.Error())
<mask> }
<mask> }
<mask>
<mask> // initial config.yml
<mask> if _, err := os.Stat(C.Path.Config()); os.IsNotExist(err) {
<mask> log.Info("Can't find config, create an empty file")
<mask> os.OpenFile(C.Path.Config(), os.O_CREATE|os.O_WRONLY, 0644)
<mask> }
<mask>
</s> Standardized: use recommend extension & forward compatibility before 1.0 </s> remove data, err := ioutil.ReadFile(path)
</s> add data, err := readRawConfig(path) </s> remove return P.Join(p.homedir, "config.yml")
</s> add return P.Join(p.homedir, "config.yaml") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/407de7388cbb76296b26a364b450a810fb443854 | config/initial.go |
return P.Join(p.homedir, "config.yaml") | <mask> return p.homedir
<mask> }
<mask>
<mask> func (p *path) Config() string {
<mask> return P.Join(p.homedir, "config.yml")
<mask> }
<mask>
<mask> func (p *path) MMDB() string {
<mask> return P.Join(p.homedir, "Country.mmdb")
<mask> }
</s> Standardized: use recommend extension & forward compatibility before 1.0 </s> remove data, err := ioutil.ReadFile(path)
</s> add data, err := readRawConfig(path) </s> remove // initial config.yml
</s> add // initial config.yaml | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/407de7388cbb76296b26a364b450a810fb443854 | constant/path.go |
name string
proxies []*proxy
rawURL string
interval time.Duration
done chan struct{} | <mask> Valid bool
<mask> }
<mask>
<mask> type Fallback struct {
<mask> name string
<mask> proxies []*proxy
<mask> rawURL string
<mask> delay time.Duration
<mask> done chan struct{}
<mask> }
<mask>
<mask> type FallbackOption struct {
<mask> Name string `proxy:"name"`
<mask> Proxies []string `proxy:"proxies"`
</s> Fix: rename delay --> interval </s> remove name string
proxies []C.Proxy
rawURL string
fast C.Proxy
delay time.Duration
done chan struct{}
</s> add name string
proxies []C.Proxy
rawURL string
fast C.Proxy
interval time.Duration
done chan struct{} </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
interval: interval,
done: make(chan struct{}), </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/fallback.go |
Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` | <mask> done chan struct{}
<mask> }
<mask>
<mask> type FallbackOption struct {
<mask> Name string `proxy:"name"`
<mask> Proxies []string `proxy:"proxies"`
<mask> URL string `proxy:"url"`
<mask> Delay int `proxy:"delay"`
<mask> }
<mask>
<mask> func (f *Fallback) Name() string {
<mask> return f.name
<mask> }
</s> Fix: rename delay --> interval </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove name string
proxies []*proxy
rawURL string
delay time.Duration
done chan struct{}
</s> add name string
proxies []*proxy
rawURL string
interval time.Duration
done chan struct{} </s> remove name string
proxies []C.Proxy
rawURL string
fast C.Proxy
delay time.Duration
done chan struct{}
</s> add name string
proxies []C.Proxy
rawURL string
fast C.Proxy
interval time.Duration
done chan struct{} </s> remove tick := time.NewTicker(f.delay)
</s> add tick := time.NewTicker(f.interval) </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/fallback.go |
tick := time.NewTicker(f.interval) | <mask> f.done <- struct{}{}
<mask> }
<mask>
<mask> func (f *Fallback) loop() {
<mask> tick := time.NewTicker(f.delay)
<mask> go f.validTest()
<mask> Loop:
<mask> for {
<mask> select {
<mask> case <-tick.C:
</s> Fix: rename delay --> interval </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/fallback.go |
interval := time.Duration(option.Interval) * time.Second | <mask> if len(proxies) < 1 {
<mask> return nil, errors.New("The number of proxies cannot be 0")
<mask> }
<mask>
<mask> delay := time.Duration(option.Delay) * time.Second
<mask> warpperProxies := make([]*proxy, len(proxies))
<mask> for idx := range proxies {
<mask> warpperProxies[idx] = &proxy{
<mask> RawProxy: proxies[idx],
<mask> Valid: true,
</s> Fix: rename delay --> interval </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
interval: interval,
done: make(chan struct{}), </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) </s> remove tick := time.NewTicker(f.delay)
</s> add tick := time.NewTicker(f.interval) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/fallback.go |
name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
interval: interval,
done: make(chan struct{}), | <mask> }
<mask> }
<mask>
<mask> Fallback := &Fallback{
<mask> name: option.Name,
<mask> proxies: warpperProxies,
<mask> rawURL: option.URL,
<mask> delay: delay,
<mask> done: make(chan struct{}),
<mask> }
<mask> go Fallback.loop()
<mask> return Fallback, nil
<mask> }
</s> Fix: rename delay --> interval </s> remove name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
interval: interval,
done: make(chan struct{}), </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove name string
proxies []*proxy
rawURL string
delay time.Duration
done chan struct{}
</s> add name string
proxies []*proxy
rawURL string
interval time.Duration
done chan struct{} </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/fallback.go |
name string
proxies []C.Proxy
rawURL string
fast C.Proxy
interval time.Duration
done chan struct{} | <mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type URLTest struct {
<mask> name string
<mask> proxies []C.Proxy
<mask> rawURL string
<mask> fast C.Proxy
<mask> delay time.Duration
<mask> done chan struct{}
<mask> }
<mask>
<mask> type URLTestOption struct {
<mask> Name string `proxy:"name"`
<mask> Proxies []string `proxy:"proxies"`
</s> Fix: rename delay --> interval </s> remove name string
proxies []*proxy
rawURL string
delay time.Duration
done chan struct{}
</s> add name string
proxies []*proxy
rawURL string
interval time.Duration
done chan struct{} </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/urltest.go |
Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` | <mask> done chan struct{}
<mask> }
<mask>
<mask> type URLTestOption struct {
<mask> Name string `proxy:"name"`
<mask> Proxies []string `proxy:"proxies"`
<mask> URL string `proxy:"url"`
<mask> Delay int `proxy:"delay"`
<mask> }
<mask>
<mask> func (u *URLTest) Name() string {
<mask> return u.name
<mask> }
</s> Fix: rename delay --> interval </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove name string
proxies []C.Proxy
rawURL string
fast C.Proxy
delay time.Duration
done chan struct{}
</s> add name string
proxies []C.Proxy
rawURL string
fast C.Proxy
interval time.Duration
done chan struct{} </s> remove name string
proxies []*proxy
rawURL string
delay time.Duration
done chan struct{}
</s> add name string
proxies []*proxy
rawURL string
interval time.Duration
done chan struct{} </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) </s> remove tick := time.NewTicker(f.delay)
</s> add tick := time.NewTicker(f.interval) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/urltest.go |
tick := time.NewTicker(u.interval) | <mask> u.done <- struct{}{}
<mask> }
<mask>
<mask> func (u *URLTest) loop() {
<mask> tick := time.NewTicker(u.delay)
<mask> go u.speedTest()
<mask> Loop:
<mask> for {
<mask> select {
<mask> case <-tick.C:
</s> Fix: rename delay --> interval </s> remove tick := time.NewTicker(f.delay)
</s> add tick := time.NewTicker(f.interval) </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Delay int `proxy:"delay"`
</s> add Name string `proxy:"name"`
Proxies []string `proxy:"proxies"`
URL string `proxy:"url"`
Interval int `proxy:"interval"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/urltest.go |
timer := time.NewTimer(u.interval) | <mask> wg := sync.WaitGroup{}
<mask> wg.Add(len(u.proxies))
<mask> c := make(chan interface{})
<mask> fast := selectFast(c)
<mask> timer := time.NewTimer(u.delay)
<mask>
<mask> for _, p := range u.proxies {
<mask> go func(p C.Proxy) {
<mask> _, err := DelayTest(p, u.rawURL)
<mask> if err == nil {
</s> Fix: rename delay --> interval </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) </s> remove tick := time.NewTicker(f.delay)
</s> add tick := time.NewTicker(f.interval) </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
interval: interval,
done: make(chan struct{}), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/urltest.go |
interval := time.Duration(option.Interval) * time.Second | <mask> if len(proxies) < 1 {
<mask> return nil, errors.New("The number of proxies cannot be 0")
<mask> }
<mask>
<mask> delay := time.Duration(option.Delay) * time.Second
<mask> urlTest := &URLTest{
<mask> name: option.Name,
<mask> proxies: proxies[:],
<mask> rawURL: option.URL,
<mask> fast: proxies[0],
</s> Fix: rename delay --> interval </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
interval: interval,
done: make(chan struct{}), </s> remove name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
interval: interval,
done: make(chan struct{}), </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/urltest.go |
name: option.Name,
proxies: proxies[:],
rawURL: option.URL,
fast: proxies[0],
interval: interval,
done: make(chan struct{}), | <mask> }
<mask>
<mask> delay := time.Duration(option.Delay) * time.Second
<mask> urlTest := &URLTest{
<mask> name: option.Name,
<mask> proxies: proxies[:],
<mask> rawURL: option.URL,
<mask> fast: proxies[0],
<mask> delay: delay,
<mask> done: make(chan struct{}),
<mask> }
<mask> go urlTest.loop()
<mask> return urlTest, nil
<mask> }
</s> Fix: rename delay --> interval </s> remove name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
delay: delay,
done: make(chan struct{}),
</s> add name: option.Name,
proxies: warpperProxies,
rawURL: option.URL,
interval: interval,
done: make(chan struct{}), </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove delay := time.Duration(option.Delay) * time.Second
</s> add interval := time.Duration(option.Interval) * time.Second </s> remove timer := time.NewTimer(u.delay)
</s> add timer := time.NewTimer(u.interval) </s> remove tick := time.NewTicker(u.delay)
</s> add tick := time.NewTicker(u.interval) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/40a94be2089dc75da45088bae218fe672f4ab1da | adapters/outbound/urltest.go |
"github.com/Dreamacro/clash/config" | <mask> import (
<mask> "github.com/Dreamacro/clash/hub/executor"
<mask> "github.com/Dreamacro/clash/hub/route"
<mask> )
<mask>
<mask> type Option func(*config.Config)
<mask>
<mask> func WithExternalUI(externalUI string) Option {
<mask> return func(cfg *config.Config) {
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove func Parse() error {
</s> add func Parse(options ...Option) error { </s> remove version bool
testConfig bool
homeDir string
configFile string
</s> add flagset map[string]bool
version bool
testConfig bool
homeDir string
configFile string
externalUI string
externalController string
secret string </s> remove if err := hub.Parse(); err != nil {
</s> add var options []hub.Option
if flagset["ext-ui"] {
options = append(options, hub.WithExternalUI(externalUI))
}
if flagset["ext-ctl"] {
options = append(options, hub.WithExternalController(externalController))
}
if flagset["secret"] {
options = append(options, hub.WithSecret(secret))
}
if err := hub.Parse(options...); err != nil { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | hub/hub.go |
func Parse(options ...Option) error { | <mask> "github.com/Dreamacro/clash/hub/route"
<mask> )
<mask>
<mask> // Parse call at the beginning of clash
<mask> func Parse() error {
<mask> cfg, err := executor.Parse()
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove if err := hub.Parse(); err != nil {
</s> add var options []hub.Option
if flagset["ext-ui"] {
options = append(options, hub.WithExternalUI(externalUI))
}
if flagset["ext-ctl"] {
options = append(options, hub.WithExternalController(externalController))
}
if flagset["secret"] {
options = append(options, hub.WithSecret(secret))
}
if err := hub.Parse(options...); err != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | hub/hub.go |
for _, option := range options {
option(cfg)
}
| <mask> return err
<mask> }
<mask>
<mask> if cfg.General.ExternalUI != "" {
<mask> route.SetUIPath(cfg.General.ExternalUI)
<mask> }
<mask>
<mask> if cfg.General.ExternalController != "" {
<mask> go route.Start(cfg.General.ExternalController, cfg.General.Secret)
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove if err := hub.Parse(); err != nil {
</s> add var options []hub.Option
if flagset["ext-ui"] {
options = append(options, hub.WithExternalUI(externalUI))
}
if flagset["ext-ctl"] {
options = append(options, hub.WithExternalController(externalController))
}
if flagset["secret"] {
options = append(options, hub.WithSecret(secret))
}
if err := hub.Parse(options...); err != nil { </s> remove func Parse() error {
</s> add func Parse(options ...Option) error { </s> remove version bool
testConfig bool
homeDir string
configFile string
</s> add flagset map[string]bool
version bool
testConfig bool
homeDir string
configFile string
externalUI string
externalController string
secret string | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | hub/hub.go |
flagset map[string]bool
version bool
testConfig bool
homeDir string
configFile string
externalUI string
externalController string
secret string | <mask> "github.com/Dreamacro/clash/log"
<mask> )
<mask>
<mask> var (
<mask> version bool
<mask> testConfig bool
<mask> homeDir string
<mask> configFile string
<mask> )
<mask>
<mask> func init() {
<mask> flag.StringVar(&homeDir, "d", "", "set configuration directory")
<mask> flag.StringVar(&configFile, "f", "", "specify configuration file")
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove func Parse() error {
</s> add func Parse(options ...Option) error { </s> remove if err := hub.Parse(); err != nil {
</s> add var options []hub.Option
if flagset["ext-ui"] {
options = append(options, hub.WithExternalUI(externalUI))
}
if flagset["ext-ctl"] {
options = append(options, hub.WithExternalController(externalController))
}
if flagset["secret"] {
options = append(options, hub.WithSecret(secret))
}
if err := hub.Parse(options...); err != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | main.go |
flag.StringVar(&externalUI, "ext-ui", "", "override external ui directory")
flag.StringVar(&externalController, "ext-ctl", "", "override external controller address")
flag.StringVar(&secret, "secret", "", "override secret for RESTful API") | <mask>
<mask> func init() {
<mask> flag.StringVar(&homeDir, "d", "", "set configuration directory")
<mask> flag.StringVar(&configFile, "f", "", "specify configuration file")
<mask> flag.BoolVar(&version, "v", false, "show current version of clash")
<mask> flag.BoolVar(&testConfig, "t", false, "test configuration and exit")
<mask> flag.Parse()
<mask>
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove version bool
testConfig bool
homeDir string
configFile string
</s> add flagset map[string]bool
version bool
testConfig bool
homeDir string
configFile string
externalUI string
externalController string
secret string </s> remove func Parse() error {
</s> add func Parse(options ...Option) error { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | main.go |
flagset = map[string]bool{}
flag.Visit(func(f *flag.Flag) {
flagset[f.Name] = true
}) | <mask> flag.BoolVar(&testConfig, "t", false, "test configuration and exit")
<mask> flag.Parse()
<mask> }
<mask>
<mask> func main() {
<mask> if version {
<mask> fmt.Printf("Clash %s %s %s %s\n", C.Version, runtime.GOOS, runtime.GOARCH, C.BuildTime)
<mask> return
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove if err := hub.Parse(); err != nil {
</s> add var options []hub.Option
if flagset["ext-ui"] {
options = append(options, hub.WithExternalUI(externalUI))
}
if flagset["ext-ctl"] {
options = append(options, hub.WithExternalController(externalController))
}
if flagset["secret"] {
options = append(options, hub.WithSecret(secret))
}
if err := hub.Parse(options...); err != nil { </s> remove func Parse() error {
</s> add func Parse(options ...Option) error { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | main.go |
var options []hub.Option
if flagset["ext-ui"] {
options = append(options, hub.WithExternalUI(externalUI))
}
if flagset["ext-ctl"] {
options = append(options, hub.WithExternalController(externalController))
}
if flagset["secret"] {
options = append(options, hub.WithSecret(secret))
}
if err := hub.Parse(options...); err != nil { | <mask> fmt.Printf("configuration file %s test is successful\n", constant.Path.Config())
<mask> return
<mask> }
<mask>
<mask> if err := hub.Parse(); err != nil {
<mask> log.Fatalln("Parse config error: %s", err.Error())
<mask> }
<mask>
<mask> sigCh := make(chan os.Signal, 1)
<mask> signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
</s> Feature: add more command-line options (#656)
add command-line options to override `external-controller`, `secret` and `external-ui` (#531) </s> remove func Parse() error {
</s> add func Parse(options ...Option) error { </s> remove version bool
testConfig bool
homeDir string
configFile string
</s> add flagset map[string]bool
version bool
testConfig bool
homeDir string
configFile string
externalUI string
externalController string
secret string | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/41a9488cfad4be2b7ae70c293857b18f8f40252f | main.go |
metadata := parseHTTPAddr(request)
metadata.SourceIP = parseSourceIP(conn) | <mask>
<mask> // NewHTTP is HTTPAdapter generator
<mask> func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
<mask> return &HTTPAdapter{
<mask> metadata: metadata,
<mask> R: request,
<mask> conn: conn,
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | adapters/inbound/http.go |
metadata: metadata, | <mask>
<mask> // NewHTTP is HTTPAdapter generator
<mask> func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
<mask> return &HTTPAdapter{
<mask> metadata: parseHTTPAddr(request),
<mask> R: request,
<mask> conn: conn,
<mask> }
<mask> }
<mask>
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | adapters/inbound/http.go |
metadata := parseHTTPAddr(request)
metadata.SourceIP = parseSourceIP(conn) | <mask> // NewHTTPS is HTTPAdapter generator
<mask> func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
<mask> return &SocketAdapter{
<mask> metadata: metadata,
<mask> conn: conn,
<mask> }
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | adapters/inbound/https.go |
metadata: metadata, | <mask>
<mask> // NewHTTPS is HTTPAdapter generator
<mask> func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
<mask> return &SocketAdapter{
<mask> metadata: parseHTTPAddr(request),
<mask> conn: conn,
<mask> }
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | adapters/inbound/https.go |
metadata.SourceIP = parseSourceIP(conn) | <mask> func NewSocket(target socks.Addr, conn net.Conn, source C.SourceType) *SocketAdapter {
<mask> metadata := parseSocksAddr(target)
<mask> metadata.Source = source
<mask>
<mask> return &SocketAdapter{
<mask> conn: conn,
<mask> metadata: metadata,
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | adapters/inbound/socket.go |
rules = append(rules, R.NewIPCIDR(payload, target, false))
case "SOURCE-IP-CIDR":
rules = append(rules, R.NewIPCIDR(payload, target, true)) | <mask> rules = append(rules, R.NewDomainKeyword(payload, target))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(payload, target))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(payload, target))
<mask> case "MATCH":
<mask> fallthrough
<mask> case "FINAL":
<mask> rules = append(rules, R.NewFinal(target))
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | config/config.go |
SourceIP *net.IP | <mask> // Metadata is used to store connection address
<mask> type Metadata struct {
<mask> NetWork NetWork
<mask> Source SourceType
<mask> AddrType int
<mask> Host string
<mask> IP *net.IP
<mask> Port string
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | constant/metadata.go |
SourceIPCIDR | <mask> GEOIP
<mask> IPCIDR
<mask> FINAL
<mask> )
<mask>
<mask> type RuleType int
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) </s> remove metadata: parseHTTPAddr(request),
</s> add metadata: metadata, | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | constant/rule.go |
case SourceIPCIDR:
return "SourceIPCIDR" | <mask> return "GEOIP"
<mask> case IPCIDR:
<mask> return "IPCIDR"
<mask> case FINAL:
<mask> return "FINAL"
<mask> default:
<mask> return "Unknow"
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove rules = append(rules, R.NewIPCIDR(payload, target))
</s> add rules = append(rules, R.NewIPCIDR(payload, target, false))
case "SOURCE-IP-CIDR":
rules = append(rules, R.NewIPCIDR(payload, target, true)) </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP </s> remove log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | constant/rule.go |
ipnet *net.IPNet
adapter string
isSourceIP bool | <mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type IPCIDR struct {
<mask> ipnet *net.IPNet
<mask> adapter string
<mask> }
<mask>
<mask> func (i *IPCIDR) RuleType() C.RuleType {
<mask> return C.IPCIDR
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | rules/ipcidr.go |
if i.isSourceIP {
return C.SourceIPCIDR
} | <mask> }
<mask>
<mask> func (i *IPCIDR) RuleType() C.RuleType {
<mask> return C.IPCIDR
<mask> }
<mask>
<mask> func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
<mask> ip := metadata.IP
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | rules/ipcidr.go |
ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP | <mask> return C.IPCIDR
<mask> }
<mask>
<mask> func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
<mask> if metadata.IP == nil {
<mask> return false
<mask> }
<mask>
<mask> return i.ipnet.Contains(*metadata.IP)
<mask> }
<mask>
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | rules/ipcidr.go |
return i.ipnet.Contains(*ip) | <mask> func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
<mask> if metadata.IP == nil {
<mask> return false
<mask> }
<mask>
<mask> return i.ipnet.Contains(*metadata.IP)
<mask> }
<mask>
<mask> func (i *IPCIDR) Adapter() string {
<mask> return i.adapter
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | rules/ipcidr.go |
func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { | <mask> func (i *IPCIDR) Payload() string {
<mask> return i.ipnet.String()
<mask> }
<mask>
<mask> func NewIPCIDR(s string, adapter string) *IPCIDR {
<mask> _, ipnet, err := net.ParseCIDR(s)
<mask> if err != nil {
<mask> }
<mask> return &IPCIDR{
<mask> ipnet: ipnet,
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove ipnet: ipnet,
adapter: adapter,
</s> add ipnet: ipnet,
adapter: adapter,
isSourceIP: isSourceIP, </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove log.Warnln("Proxy[%s] connect [%s] error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | rules/ipcidr.go |
ipnet: ipnet,
adapter: adapter,
isSourceIP: isSourceIP, | <mask> _, ipnet, err := net.ParseCIDR(s)
<mask> if err != nil {
<mask> }
<mask> return &IPCIDR{
<mask> ipnet: ipnet,
<mask> adapter: adapter,
<mask> }
<mask> }
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove log.Warnln("Proxy[%s] connect [%s] error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error()) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | rules/ipcidr.go |
log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error()) | <mask> }
<mask>
<mask> remoConn, err := proxy.Generator(metadata)
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s] error: %s", proxy.Name(), metadata.String(), err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
<mask>
<mask> switch adapter := localConn.(type) {
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { </s> remove ipnet: ipnet,
adapter: adapter,
</s> add ipnet: ipnet,
adapter: adapter,
isSourceIP: isSourceIP, </s> remove log.Infoln("%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove ipnet *net.IPNet
adapter string
</s> add ipnet *net.IPNet
adapter string
isSourceIP bool </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | tunnel/tunnel.go |
log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) | <mask> }
<mask>
<mask> if rule.IsMatch(metadata) {
<mask> if a, ok := t.proxies[rule.Adapter()]; ok {
<mask> log.Infoln("%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter())
<mask> return a, nil
<mask> }
<mask> }
<mask> }
<mask> log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) </s> remove log.Warnln("Proxy[%s] connect [%s] error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error()) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | tunnel/tunnel.go |
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String()) | <mask> return a, nil
<mask> }
<mask> }
<mask> }
<mask> log.Infoln("%v doesn't match any rule using DIRECT", metadata.String())
<mask> return t.proxies["DIRECT"], nil
<mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> return &Tunnel{
</s> Feature: SOURCE-IP-CIDR rule type (#96) </s> remove log.Infoln("%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove
return i.ipnet.Contains(*metadata.IP)
</s> add return i.ipnet.Contains(*ip) </s> remove if metadata.IP == nil {
return false
</s> add ip := metadata.IP
if i.isSourceIP {
ip = metadata.SourceIP </s> remove func NewIPCIDR(s string, adapter string) *IPCIDR {
</s> add func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/42d33fe6298c5ba31ad1cb7a18808949b2411b03 | tunnel/tunnel.go |
Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m aes-256-gcm -k FzcLbKs2dY9mhL"}, | <mask>
<mask> func Benchmark_Shadowsocks(b *testing.B) {
<mask> cfg := &container.Config{
<mask> Image: ImageShadowsocks,
<mask> Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m chacha20-ietf-poly1305 -k FzcLbKs2dY9mhL"},
<mask> ExposedPorts: defaultExposedPorts,
<mask> }
<mask> hostCfg := &container.HostConfig{
<mask> PortBindings: defaultPortBindings,
<mask> }
</s> Test: ss use aes-256-gcm and vmess-aead for benchmark </s> remove configPath := C.Path.Resolve("vmess.json")
</s> add configPath := C.Path.Resolve("vmess-aead.json") </s> remove id, err := startContainer(cfg, hostCfg, "vmess")
</s> add id, err := startContainer(cfg, hostCfg, "vmess-aead") </s> remove AlterID: 32,
</s> add AlterID: 0, </s> remove Cipher: "chacha20-ietf-poly1305",
</s> add Cipher: "aes-256-gcm", | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/44872300e94698428e7e4bacf8255b09042cb40a | test/ss_test.go |
Cipher: "aes-256-gcm", | <mask> Name: "ss",
<mask> Server: localIP.String(),
<mask> Port: 10002,
<mask> Password: "FzcLbKs2dY9mhL",
<mask> Cipher: "chacha20-ietf-poly1305",
<mask> UDP: true,
<mask> })
<mask> if err != nil {
<mask> assert.FailNow(b, err.Error())
<mask> }
</s> Test: ss use aes-256-gcm and vmess-aead for benchmark </s> remove AlterID: 32,
</s> add AlterID: 0, </s> remove id, err := startContainer(cfg, hostCfg, "vmess")
</s> add id, err := startContainer(cfg, hostCfg, "vmess-aead") </s> remove configPath := C.Path.Resolve("vmess.json")
</s> add configPath := C.Path.Resolve("vmess-aead.json") </s> remove Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m chacha20-ietf-poly1305 -k FzcLbKs2dY9mhL"},
</s> add Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m aes-256-gcm -k FzcLbKs2dY9mhL"}, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/44872300e94698428e7e4bacf8255b09042cb40a | test/ss_test.go |
configPath := C.Path.Resolve("vmess-aead.json") | <mask> testSuit(t, proxy)
<mask> }
<mask>
<mask> func Benchmark_Vmess(b *testing.B) {
<mask> configPath := C.Path.Resolve("vmess.json")
<mask>
<mask> cfg := &container.Config{
<mask> Image: ImageVmess,
<mask> ExposedPorts: defaultExposedPorts,
<mask> }
</s> Test: ss use aes-256-gcm and vmess-aead for benchmark </s> remove Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m chacha20-ietf-poly1305 -k FzcLbKs2dY9mhL"},
</s> add Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m aes-256-gcm -k FzcLbKs2dY9mhL"}, </s> remove id, err := startContainer(cfg, hostCfg, "vmess")
</s> add id, err := startContainer(cfg, hostCfg, "vmess-aead") </s> remove AlterID: 32,
</s> add AlterID: 0, </s> remove Cipher: "chacha20-ietf-poly1305",
</s> add Cipher: "aes-256-gcm", | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/44872300e94698428e7e4bacf8255b09042cb40a | test/vmess_test.go |
id, err := startContainer(cfg, hostCfg, "vmess-aead") | <mask> PortBindings: defaultPortBindings,
<mask> Binds: []string{fmt.Sprintf("%s:/etc/v2ray/config.json", configPath)},
<mask> }
<mask>
<mask> id, err := startContainer(cfg, hostCfg, "vmess")
<mask> if err != nil {
<mask> assert.FailNow(b, err.Error())
<mask> }
<mask>
<mask> b.Cleanup(func() {
</s> Test: ss use aes-256-gcm and vmess-aead for benchmark </s> remove AlterID: 32,
</s> add AlterID: 0, </s> remove Cipher: "chacha20-ietf-poly1305",
</s> add Cipher: "aes-256-gcm", </s> remove Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m chacha20-ietf-poly1305 -k FzcLbKs2dY9mhL"},
</s> add Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m aes-256-gcm -k FzcLbKs2dY9mhL"}, </s> remove configPath := C.Path.Resolve("vmess.json")
</s> add configPath := C.Path.Resolve("vmess-aead.json") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/44872300e94698428e7e4bacf8255b09042cb40a | test/vmess_test.go |
AlterID: 0, | <mask> Server: localIP.String(),
<mask> Port: 10002,
<mask> UUID: "b831381d-6324-4d53-ad4f-8cda48b30811",
<mask> Cipher: "auto",
<mask> AlterID: 32,
<mask> UDP: true,
<mask> })
<mask> if err != nil {
<mask> assert.FailNow(b, err.Error())
<mask> }
</s> Test: ss use aes-256-gcm and vmess-aead for benchmark </s> remove Cipher: "chacha20-ietf-poly1305",
</s> add Cipher: "aes-256-gcm", </s> remove id, err := startContainer(cfg, hostCfg, "vmess")
</s> add id, err := startContainer(cfg, hostCfg, "vmess-aead") </s> remove configPath := C.Path.Resolve("vmess.json")
</s> add configPath := C.Path.Resolve("vmess-aead.json") </s> remove Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m chacha20-ietf-poly1305 -k FzcLbKs2dY9mhL"},
</s> add Env: []string{"SS_MODULE=ss-server", "SS_CONFIG=-s 0.0.0.0 -u -v -p 10002 -m aes-256-gcm -k FzcLbKs2dY9mhL"}, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/44872300e94698428e7e4bacf8255b09042cb40a | test/vmess_test.go |
return newPacketConn(&nopPacketConn{}, r), nil | <mask> }
<mask>
<mask> // ListenPacketContext implements C.ProxyAdapter
<mask> func (r *Reject) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
<mask> return newPacketConn(newNopPacketConn(), r), nil
<mask> }
<mask>
<mask> func NewReject() *Reject {
<mask> return &Reject{
<mask> Base: &Base{
</s> Fix: should return io.EOF immediately </s> remove type nopPacketConn struct {
ch chan struct{}
}
func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
}
func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
}
</s> add type nopPacketConn struct{} </s> remove func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
}
func (npc *nopPacketConn) LocalAddr() net.Addr { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
func (npc *nopPacketConn) SetDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetReadDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetWriteDeadline(time.Time) error { return nil }
func newNopPacketConn() *nopPacketConn {
return &nopPacketConn{
ch: make(chan struct{}),
}
}
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) { return len(b), nil }
func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) { return 0, nil, io.EOF }
func (npc *nopPacketConn) Close() error { return nil }
func (npc *nopPacketConn) LocalAddr() net.Addr { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
func (npc *nopPacketConn) SetDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetReadDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetWriteDeadline(time.Time) error { return nil } | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4524cf44181944e400d22f4881e1b5dbd0d87b91 | adapter/outbound/reject.go |
type nopPacketConn struct{} | <mask> func (rw *nopConn) SetDeadline(time.Time) error { return nil }
<mask> func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
<mask> func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil }
<mask>
<mask> type nopPacketConn struct {
<mask> ch chan struct{}
<mask> }
<mask>
<mask> func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
<mask> return len(b), nil
<mask> }
<mask>
<mask> func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> <-npc.ch
<mask> return 0, nil, io.EOF
<mask> }
<mask>
<mask> func (npc *nopPacketConn) Close() error {
<mask> close(npc.ch)
<mask> return nil
<mask> }
</s> Fix: should return io.EOF immediately </s> remove return newPacketConn(newNopPacketConn(), r), nil
</s> add return newPacketConn(&nopPacketConn{}, r), nil </s> remove func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
}
func (npc *nopPacketConn) LocalAddr() net.Addr { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
func (npc *nopPacketConn) SetDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetReadDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetWriteDeadline(time.Time) error { return nil }
func newNopPacketConn() *nopPacketConn {
return &nopPacketConn{
ch: make(chan struct{}),
}
}
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) { return len(b), nil }
func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) { return 0, nil, io.EOF }
func (npc *nopPacketConn) Close() error { return nil }
func (npc *nopPacketConn) LocalAddr() net.Addr { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
func (npc *nopPacketConn) SetDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetReadDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetWriteDeadline(time.Time) error { return nil } | [
"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/4524cf44181944e400d22f4881e1b5dbd0d87b91 | adapter/outbound/reject.go |
func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) { return len(b), nil }
func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) { return 0, nil, io.EOF }
func (npc *nopPacketConn) Close() error { return nil }
func (npc *nopPacketConn) LocalAddr() net.Addr { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
func (npc *nopPacketConn) SetDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetReadDeadline(time.Time) error { return nil }
func (npc *nopPacketConn) SetWriteDeadline(time.Time) error { return nil } | <mask> <-npc.ch
<mask> return 0, nil, io.EOF
<mask> }
<mask>
<mask> func (npc *nopPacketConn) Close() error {
<mask> close(npc.ch)
<mask> return nil
<mask> }
<mask>
<mask> func (npc *nopPacketConn) LocalAddr() net.Addr { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
<mask> func (npc *nopPacketConn) SetDeadline(time.Time) error { return nil }
<mask> func (npc *nopPacketConn) SetReadDeadline(time.Time) error { return nil }
<mask> func (npc *nopPacketConn) SetWriteDeadline(time.Time) error { return nil }
<mask>
<mask> func newNopPacketConn() *nopPacketConn {
<mask> return &nopPacketConn{
<mask> ch: make(chan struct{}),
<mask> }
<mask> }
</s> Fix: should return io.EOF immediately </s> remove return newPacketConn(newNopPacketConn(), r), nil
</s> add return newPacketConn(&nopPacketConn{}, r), nil </s> remove type nopPacketConn struct {
ch chan struct{}
}
func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
}
func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
}
</s> add type nopPacketConn struct{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace"
] | https://github.com/Dreamacro/clash/commit/4524cf44181944e400d22f4881e1b5dbd0d87b91 | adapter/outbound/reject.go |
<mask> package adapters
<mask>
<mask> import (
<mask> "bufio"
<mask> "bytes"
<mask> "context"
<mask> "crypto/tls"
<mask> "encoding/base64"
<mask> "errors"
<mask> "fmt"
</s> Chore: remove unused http outbound proxy code </s> remove addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
user: option.UserName,
pass: option.Password,
tls: option.TLS,
skipCertVerify: option.SkipCertVerify,
tlsConfig: tlsConfig,
</s> add addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
user: option.UserName,
pass: option.Password,
tlsConfig: tlsConfig, </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go | |
"net/url" | <mask> "net"
<mask> "net/http"
<mask> "strconv"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
</s> Chore: remove unused http outbound proxy code </s> remove addr string
user string
pass string
tls bool
skipCertVerify bool
tlsConfig *tls.Config
</s> add addr string
user string
pass string
tlsConfig *tls.Config </s> remove addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
user: option.UserName,
pass: option.Password,
tls: option.TLS,
skipCertVerify: option.SkipCertVerify,
tlsConfig: tlsConfig,
</s> add addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
user: option.UserName,
pass: option.Password,
tlsConfig: tlsConfig, </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove // header ended
buf.WriteString("\r\n")
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
addr string
user string
pass string
tlsConfig *tls.Config | <mask> )
<mask>
<mask> type Http struct {
<mask> *Base
<mask> addr string
<mask> user string
<mask> pass string
<mask> tls bool
<mask> skipCertVerify bool
<mask> tlsConfig *tls.Config
<mask> }
<mask>
<mask> type HttpOption struct {
<mask> Name string `proxy:"name"`
<mask> Server string `proxy:"server"`
</s> Chore: remove unused http outbound proxy code </s> remove var buf bytes.Buffer
var err error
</s> add </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove if err == nil && h.tls {
</s> add if err == nil && h.tlsConfig != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
if err == nil && h.tlsConfig != nil { | <mask> }
<mask>
<mask> func (h *Http) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> c, err := dialContext(ctx, "tcp", h.addr)
<mask> if err == nil && h.tls {
<mask> cc := tls.Client(c, h.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
<mask> }
<mask>
</s> Chore: remove unused http outbound proxy code </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove var buf bytes.Buffer
var err error
</s> add </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
<mask> return newConn(c, h), nil
<mask> }
<mask>
<mask> func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
<mask> var buf bytes.Buffer
<mask> var err error
<mask>
<mask> addr := metadata.RemoteAddress()
<mask> buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
<mask> buf.WriteString("Host: " + metadata.String() + "\r\n")
<mask> buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
<mask>
</s> Chore: remove unused http outbound proxy code </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove if err == nil && h.tls {
</s> add if err == nil && h.tlsConfig != nil { </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go | |
req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} | <mask> var buf bytes.Buffer
<mask> var err error
<mask>
<mask> addr := metadata.RemoteAddress()
<mask> buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
<mask> buf.WriteString("Host: " + metadata.String() + "\r\n")
<mask> buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
<mask>
<mask> if h.user != "" && h.pass != "" {
<mask> auth := h.user + ":" + h.pass
<mask> buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
<mask> }
</s> Chore: remove unused http outbound proxy code </s> remove var buf bytes.Buffer
var err error
</s> add </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) | <mask> buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
<mask>
<mask> if h.user != "" && h.pass != "" {
<mask> auth := h.user + ":" + h.pass
<mask> buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
<mask> }
<mask> // header ended
<mask> buf.WriteString("\r\n")
<mask>
<mask> _, err = rw.Write(buf.Bytes())
</s> Chore: remove unused http outbound proxy code </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove var buf bytes.Buffer
var err error
</s> add </s> remove if err == nil && h.tls {
</s> add if err == nil && h.tlsConfig != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
<mask> if h.user != "" && h.pass != "" {
<mask> auth := h.user + ":" + h.pass
<mask> buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
<mask> }
<mask> // header ended
<mask> buf.WriteString("\r\n")
<mask>
<mask> _, err = rw.Write(buf.Bytes())
<mask> if err != nil {
<mask> return err
<mask> }
</s> Chore: remove unused http outbound proxy code </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove var buf bytes.Buffer
var err error
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go | |
if err := req.Write(rw); err != nil { | <mask> }
<mask> // header ended
<mask> buf.WriteString("\r\n")
<mask>
<mask> _, err = rw.Write(buf.Bytes())
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> var req http.Request
<mask> resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> Chore: remove unused http outbound proxy code </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) </s> remove if err == nil && h.tls {
</s> add if err == nil && h.tlsConfig != nil { </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
resp, err := http.ReadResponse(bufio.NewReader(rw), req) | <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> var req http.Request
<mask> resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> if resp.StatusCode == http.StatusOK {
</s> Chore: remove unused http outbound proxy code </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove if err == nil && h.tls {
</s> add if err == nil && h.tlsConfig != nil { </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} </s> remove buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
</s> add req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
user: option.UserName,
pass: option.Password,
tlsConfig: tlsConfig, | <mask> Base: &Base{
<mask> name: option.Name,
<mask> tp: C.Http,
<mask> },
<mask> addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
<mask> user: option.UserName,
<mask> pass: option.Password,
<mask> tls: option.TLS,
<mask> skipCertVerify: option.SkipCertVerify,
<mask> tlsConfig: tlsConfig,
<mask> }
<mask> }
</s> Chore: remove unused http outbound proxy code </s> remove buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
buf.WriteString("Host: " + metadata.String() + "\r\n")
buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
</s> add req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{
Host: addr,
},
Host: addr,
Header: http.Header{
"Proxy-Connection": []string{"Keep-Alive"},
},
} </s> remove _, err = rw.Write(buf.Bytes())
if err != nil {
</s> add if err := req.Write(rw); err != nil { </s> remove var req http.Request
resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
</s> add resp, err := http.ReadResponse(bufio.NewReader(rw), req) </s> remove // header ended
buf.WriteString("\r\n")
</s> add </s> remove if err == nil && h.tls {
</s> add if err == nil && h.tlsConfig != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/452570704872a939472bab89d06fa8ce67dcdffb | adapters/outbound/http.go |
if socksListener.Address() != addr {
socksListener.Close()
socksListener = nil
}
}
if socksUDPListener != nil {
if socksUDPListener.Address() != addr {
socksUDPListener.Close()
socksUDPListener = nil | <mask> func ReCreateSocks(port int) error {
<mask> addr := genAddr(bindAddress, port, allowLan)
<mask>
<mask> if socksListener != nil {
<mask> if socksListener.Address() == addr {
<mask> return nil
<mask> }
<mask> socksListener.Close()
<mask> socksListener = nil
<mask> }
<mask>
</s> Fix: UDP socks recreate behavior (#355) </s> remove socksListener.Close()
socksListener = nil
</s> add </s> remove return reCreateSocksUDP(addr)
}
func reCreateSocksUDP(addr string) error {
if socksUDPListener != nil {
if socksUDPListener.Address() == addr {
return nil
}
socksUDPListener.Close()
socksUDPListener = nil
}
var err error
socksUDPListener, err = socks.NewSocksUDPProxy(addr)
</s> add udpListener, err := socks.NewSocksUDPProxy(addr) </s> remove var err error
socksListener, err = socks.NewSocksProxy(addr)
</s> add tcpListener, err := socks.NewSocksProxy(addr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/461e0a68735ab1cf79f6f2160aa68eb2ff8402a5 | proxy/listener.go |
<mask> if socksListener != nil {
<mask> if socksListener.Address() == addr {
<mask> return nil
<mask> }
<mask> socksListener.Close()
<mask> socksListener = nil
<mask> }
<mask>
<mask> if portIsZero(addr) {
<mask> return nil
<mask> }
</s> Fix: UDP socks recreate behavior (#355) </s> remove if socksListener.Address() == addr {
return nil
</s> add if socksListener.Address() != addr {
socksListener.Close()
socksListener = nil
}
}
if socksUDPListener != nil {
if socksUDPListener.Address() != addr {
socksUDPListener.Close()
socksUDPListener = nil </s> remove var err error
socksListener, err = socks.NewSocksProxy(addr)
</s> add tcpListener, err := socks.NewSocksProxy(addr) </s> remove return reCreateSocksUDP(addr)
}
func reCreateSocksUDP(addr string) error {
if socksUDPListener != nil {
if socksUDPListener.Address() == addr {
return nil
}
socksUDPListener.Close()
socksUDPListener = nil
}
var err error
socksUDPListener, err = socks.NewSocksUDPProxy(addr)
</s> add udpListener, err := socks.NewSocksUDPProxy(addr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/461e0a68735ab1cf79f6f2160aa68eb2ff8402a5 | proxy/listener.go | |
tcpListener, err := socks.NewSocksProxy(addr) | <mask> if portIsZero(addr) {
<mask> return nil
<mask> }
<mask>
<mask> var err error
<mask> socksListener, err = socks.NewSocksProxy(addr)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> return reCreateSocksUDP(addr)
</s> Fix: UDP socks recreate behavior (#355) </s> remove return reCreateSocksUDP(addr)
}
func reCreateSocksUDP(addr string) error {
if socksUDPListener != nil {
if socksUDPListener.Address() == addr {
return nil
}
socksUDPListener.Close()
socksUDPListener = nil
}
var err error
socksUDPListener, err = socks.NewSocksUDPProxy(addr)
</s> add udpListener, err := socks.NewSocksUDPProxy(addr) </s> remove socksListener.Close()
socksListener = nil
</s> add </s> remove if socksListener.Address() == addr {
return nil
</s> add if socksListener.Address() != addr {
socksListener.Close()
socksListener = nil
}
}
if socksUDPListener != nil {
if socksUDPListener.Address() != addr {
socksUDPListener.Close()
socksUDPListener = nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/461e0a68735ab1cf79f6f2160aa68eb2ff8402a5 | proxy/listener.go |
udpListener, err := socks.NewSocksUDPProxy(addr) | <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> return reCreateSocksUDP(addr)
<mask> }
<mask>
<mask> func reCreateSocksUDP(addr string) error {
<mask> if socksUDPListener != nil {
<mask> if socksUDPListener.Address() == addr {
<mask> return nil
<mask> }
<mask> socksUDPListener.Close()
<mask> socksUDPListener = nil
<mask> }
<mask>
<mask> var err error
<mask> socksUDPListener, err = socks.NewSocksUDPProxy(addr)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> return nil
</s> Fix: UDP socks recreate behavior (#355) </s> remove var err error
socksListener, err = socks.NewSocksProxy(addr)
</s> add tcpListener, err := socks.NewSocksProxy(addr) </s> remove if socksListener.Address() == addr {
return nil
</s> add if socksListener.Address() != addr {
socksListener.Close()
socksListener = nil
}
}
if socksUDPListener != nil {
if socksUDPListener.Address() != addr {
socksUDPListener.Close()
socksUDPListener = nil </s> remove socksListener.Close()
socksListener = nil
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/461e0a68735ab1cf79f6f2160aa68eb2ff8402a5 | proxy/listener.go |
tcpListener.Close() | <mask>
<mask> udpListener, err := socks.NewSocksUDPProxy(addr)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> socksListener = tcpListener
</s> Fix: UDP socks recreate behavior (#355) </s> remove return reCreateSocksUDP(addr)
}
func reCreateSocksUDP(addr string) error {
if socksUDPListener != nil {
if socksUDPListener.Address() == addr {
return nil
}
socksUDPListener.Close()
socksUDPListener = nil
}
var err error
socksUDPListener, err = socks.NewSocksUDPProxy(addr)
</s> add udpListener, err := socks.NewSocksUDPProxy(addr) </s> remove var err error
socksListener, err = socks.NewSocksProxy(addr)
</s> add tcpListener, err := socks.NewSocksProxy(addr) </s> remove if socksListener.Address() == addr {
return nil
</s> add if socksListener.Address() != addr {
socksListener.Close()
socksListener = nil
}
}
if socksUDPListener != nil {
if socksUDPListener.Address() != addr {
socksUDPListener.Close()
socksUDPListener = nil </s> remove socksListener.Close()
socksListener = nil
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/461e0a68735ab1cf79f6f2160aa68eb2ff8402a5 | proxy/listener.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.