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 |
|---|---|---|---|---|
WORKDIR /clash-src
COPY . /clash-src
RUN go mod download && \ | <mask> FROM golang:latest as builder
<mask> RUN wget http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz -O /tmp/GeoLite2-Country.tar.gz && \
<mask> tar zxvf /tmp/GeoLite2-Country.tar.gz -C /tmp && \
<mask> cp /tmp/GeoLite2-Country_*/GeoLite2-Country.mmdb /Country.mmdb
<mask> RUN curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh && \
<mask> mkdir -p /go/src/github.com/Dreamacro/clash
<mask> WORKDIR /go/src/github.com/Dreamacro/clash
<mask> COPY . /go/src/github.com/Dreamacro/clash
<mask> RUN dep ensure && \
<mask> GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags '-w -s' -o /clash && \
<mask> chmod +x /clash
<mask>
<mask> FROM alpine:latest
<mask> RUN apk --no-cache add ca-certificates && \
</s> Feature: repalce dep with go module </s> remove before_install:
- go get -u github.com/golang/dep/cmd/dep
</s> add </s> remove - "$GOPATH/bin/dep ensure"
</s> add - "go mod download" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/04e05c6a859c71b8b7bb33d50a1ddeb936868212 | Dockerfile |
for idx, line := range rulesConfig {
rule := trimArr(strings.Split(line, ","))
var (
payload string
target string
)
switch len(rule) {
case 2:
target = rule[1]
case 3:
payload = rule[1]
target = rule[2]
default:
return nil, fmt.Errorf("Rules[%d] error: format invalid", idx) | <mask> rules := []C.Rule{}
<mask>
<mask> rulesConfig := cfg.Rule
<mask> // parse rules
<mask> for _, line := range rulesConfig {
<mask> rule := strings.Split(line, ",")
<mask> if len(rule) < 3 {
<mask> continue
<mask> }
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN":
<mask> rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) </s> remove log.Warnln("Proxy connect error: %s", err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s] error: %s", proxy.Name(), metadata.String(), err.Error()) </s> remove rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(payload, target)) </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
rules = append(rules, R.NewDomain(payload, target)) | <mask> }
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN":
<mask> rules = append(rules, R.NewDomain(rule[1], rule[2]))
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(payload, target)) </s> remove rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(payload, target)) </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
rules = append(rules, R.NewDomainSuffix(payload, target)) | <mask> switch rule[0] {
<mask> case "DOMAIN":
<mask> rules = append(rules, R.NewDomain(rule[1], rule[2]))
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(payload, target)) </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
rules = append(rules, R.NewDomainKeyword(payload, target)) | <mask> rules = append(rules, R.NewDomain(rule[1], rule[2]))
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(payload, target)) </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) </s> remove rules = append(rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
rules = append(rules, R.NewGEOIP(payload, target)) | <mask> rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> rules = append(rules, R.NewFinal(rule[2]))
<mask> }
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(payload, target)) </s> remove rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(payload, target)) </s> remove rules = append(rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(target)) </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough | <mask> rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> rules = append(rules, R.NewFinal(rule[2]))
<mask> }
<mask> }
<mask>
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) </s> remove rules = append(rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(target)) </s> remove rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(payload, target)) </s> remove rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(payload, target)) </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
rules = append(rules, R.NewFinal(target)) | <mask> rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> rules = append(rules, R.NewFinal(rule[2]))
<mask> }
<mask> }
<mask>
<mask> return rules, nil
<mask> }
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) </s> remove rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(payload, target)) </s> remove rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(payload, target)) </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | config/config.go |
log.Warnln("Proxy[%s] connect [%s] error: %s", proxy.Name(), metadata.String(), err.Error()) | <mask> proxy = t.match(metadata)
<mask> }
<mask> remoConn, err := proxy.Generator(metadata)
<mask> if err != nil {
<mask> log.Warnln("Proxy connect error: %s", err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
<mask>
<mask> switch adapter := localConn.(type) {
</s> Change: replace `FINAL` with `MATCH` in a progressive way </s> remove for _, line := range rulesConfig {
rule := strings.Split(line, ",")
if len(rule) < 3 {
continue
</s> add for idx, line := range rulesConfig {
rule := trimArr(strings.Split(line, ","))
var (
payload string
target string
)
switch len(rule) {
case 2:
target = rule[1]
case 3:
payload = rule[1]
target = rule[2]
default:
return nil, fmt.Errorf("Rules[%d] error: format invalid", idx) </s> remove rules = append(rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(target)) </s> remove rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(payload, target))
case "MATCH":
fallthrough </s> remove rules = append(rules, R.NewDomain(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomain(payload, target)) </s> remove rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(payload, target)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/05bf4d44ab679cf40dbf2d901da2403dc9ce7c8b | tunnel/tunnel.go |
<mask> import (
<mask> "io"
<mask> "net"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
<mask>
<mask> // Relay copies between left and right bidirectionally.
<mask> func Relay(leftConn, rightConn net.Conn) {
<mask> ch := make(chan error)
</s> Chore: adjust Relay copy memory alloc logic </s> remove buf := pool.Get(pool.RelayBufferSize)
</s> add </s> remove _, err := io.CopyBuffer(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
</s> add _, err := io.Copy(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}) </s> remove buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
</s> add io.Copy(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/06d75da257d7960b906893e498eda53484559d61 | common/net/relay.go | |
<mask> func Relay(leftConn, rightConn net.Conn) {
<mask> ch := make(chan error)
<mask>
<mask> go func() {
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> // Wrapping to avoid using *net.TCPConn.(ReadFrom)
<mask> // See also https://github.com/Dreamacro/clash/pull/1209
<mask> _, err := io.CopyBuffer(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}, buf)
<mask> pool.Put(buf)
<mask> leftConn.SetReadDeadline(time.Now())
</s> Chore: adjust Relay copy memory alloc logic </s> remove _, err := io.CopyBuffer(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
</s> add _, err := io.Copy(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}) </s> remove buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
</s> add io.Copy(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}) </s> remove
"github.com/Dreamacro/clash/common/pool"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/06d75da257d7960b906893e498eda53484559d61 | common/net/relay.go | |
_, err := io.Copy(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}) | <mask> go func() {
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> // Wrapping to avoid using *net.TCPConn.(ReadFrom)
<mask> // See also https://github.com/Dreamacro/clash/pull/1209
<mask> _, err := io.CopyBuffer(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}, buf)
<mask> pool.Put(buf)
<mask> leftConn.SetReadDeadline(time.Now())
<mask> ch <- err
<mask> }()
<mask>
<mask> buf := pool.Get(pool.RelayBufferSize)
</s> Chore: adjust Relay copy memory alloc logic </s> remove buf := pool.Get(pool.RelayBufferSize)
</s> add </s> remove buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
</s> add io.Copy(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}) </s> remove
"github.com/Dreamacro/clash/common/pool"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/06d75da257d7960b906893e498eda53484559d61 | common/net/relay.go |
io.Copy(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}) | <mask> leftConn.SetReadDeadline(time.Now())
<mask> ch <- err
<mask> }()
<mask>
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> io.CopyBuffer(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn}, buf)
<mask> pool.Put(buf)
<mask> rightConn.SetReadDeadline(time.Now())
<mask> <-ch
<mask> }
</s> Chore: adjust Relay copy memory alloc logic </s> remove _, err := io.CopyBuffer(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
</s> add _, err := io.Copy(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn}) </s> remove buf := pool.Get(pool.RelayBufferSize)
</s> add </s> remove
"github.com/Dreamacro/clash/common/pool"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/06d75da257d7960b906893e498eda53484559d61 | common/net/relay.go |
// DelByIP implements store.DelByIP
func (c *cachefileStore) DelByIP(ip net.IP) {
ip = ip.To4()
c.cache.DelFakeipPair(ip, c.cache.GetFakeip(ip.To4()))
}
| <mask> }
<mask>
<mask> // Exist implements store.Exist
<mask> func (c *cachefileStore) Exist(ip net.IP) bool {
<mask> _, exist := c.GetByIP(ip)
<mask> return exist
</s> Fix: fakeip pool cycle used </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29") </s> remove first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
</s> add foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/cachefile.go |
// DelByIP implements store.DelByIP
func (m *memoryStore) DelByIP(ip net.IP) {
ipNum := ipToUint(ip.To4())
if elm, exist := m.cache.Get(ipNum); exist {
m.cache.Delete(elm.(string))
}
m.cache.Delete(ipNum)
}
| <mask> func (m *memoryStore) PutByIP(ip net.IP, host string) {
<mask> m.cache.Set(ipToUint(ip.To4()), host)
<mask> }
<mask>
<mask> // Exist implements store.Exist
<mask> func (m *memoryStore) Exist(ip net.IP) bool {
<mask> return m.cache.Exist(ipToUint(ip.To4()))
<mask> }
</s> Fix: fakeip pool cycle used </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29") </s> remove first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
</s> add foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/memory.go |
DelByIP(ip net.IP) | <mask> GetByHost(host string) (net.IP, bool)
<mask> PutByHost(host string, ip net.IP)
<mask> GetByIP(ip net.IP) (string, bool)
<mask> PutByIP(ip net.IP, host string)
<mask> Exist(ip net.IP) bool
<mask> CloneTo(store)
<mask> }
<mask>
<mask> // Pool is a implementation about fake ip generator without storage
</s> Fix: fakeip pool cycle used </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29") </s> remove first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
</s> add foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/pool.go |
p.offset = (p.offset + 1) % (p.max - p.min)
ip := uintToIP(p.min + p.offset - 1)
p.store.DelByIP(ip) | <mask> // Avoid infinite loops
<mask> if p.offset == current {
<mask> break
<mask> }
<mask>
<mask> ip := uintToIP(p.min + p.offset - 1)
<mask> if !p.store.Exist(ip) {
<mask> break
</s> Fix: fakeip pool cycle used </s> remove first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
</s> add foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29") | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/pool.go |
"fmt" | <mask>
<mask> import (
<mask> "net"
<mask> "os"
<mask> "testing"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/component/profile/cachefile"
</s> Fix: fakeip pool cycle used </s> remove first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
</s> add foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29") | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/pool_test.go |
_, ipnet, _ := net.ParseCIDR("192.168.0.1/29") | <mask> }
<mask> }
<mask>
<mask> func TestPool_CycleUsed(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
<mask> pools, tempfile, err := createPools(Options{
<mask> IPNet: ipnet,
<mask> Size: 10,
<mask> })
<mask> assert.Nil(t, err)
</s> Fix: fakeip pool cycle used </s> remove first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
</s> add foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/pool_test.go |
foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar)) | <mask> assert.Nil(t, err)
<mask> defer os.Remove(tempfile)
<mask>
<mask> for _, pool := range pools {
<mask> first := pool.Lookup("foo.com")
<mask> same := pool.Lookup("baz.com")
<mask> assert.True(t, first.Equal(same))
<mask> }
<mask> }
<mask>
<mask> func TestPool_Skip(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> Fix: fakeip pool cycle used </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/075d8ed09417198913866a2820c0ee10f200258e | component/fakeip/pool_test.go |
func ValidAndSplitDomain(domain string) ([]string, bool) { | <mask> type DomainTrie struct {
<mask> root *Node
<mask> }
<mask>
<mask> func validAndSplitDomain(domain string) ([]string, bool) {
<mask> if domain != "" && domain[len(domain)-1] == '.' {
<mask> return nil, false
<mask> }
<mask>
<mask> parts := strings.Split(domain, domainStep)
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | component/trie/domain.go |
parts, valid := ValidAndSplitDomain(domain) | <mask> // 3. subdomain.*.example.com
<mask> // 4. .example.com
<mask> // 5. +.example.com
<mask> func (t *DomainTrie) Insert(domain string, data interface{}) error {
<mask> parts, valid := validAndSplitDomain(domain)
<mask> if !valid {
<mask> return ErrInvalidDomain
<mask> }
<mask>
<mask> if parts[0] == complexWildcard {
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | component/trie/domain.go |
parts, valid := ValidAndSplitDomain(domain) | <mask> // 1. static part
<mask> // 2. wildcard domain
<mask> // 2. dot wildcard domain
<mask> func (t *DomainTrie) Search(domain string) *Node {
<mask> parts, valid := validAndSplitDomain(domain)
<mask> if !valid || parts[0] == "" {
<mask> return nil
<mask> }
<mask>
<mask> n := t.search(t.root, parts)
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) </s> remove func validAndSplitDomain(domain string) ([]string, bool) {
</s> add func ValidAndSplitDomain(domain string) ([]string, bool) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | component/trie/domain.go |
NameServerPolicy map[string]dns.NameServer | <mask> FakeIPRange *fakeip.Pool
<mask> Hosts *trie.DomainTrie
<mask> }
<mask>
<mask> // FallbackFilter config
<mask> type FallbackFilter struct {
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove func validAndSplitDomain(domain string) ([]string, bool) {
</s> add func ValidAndSplitDomain(domain string) ([]string, bool) { </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | config/config.go |
NameServerPolicy map[string]string `yaml:"nameserver-policy"` | <mask> FakeIPRange string `yaml:"fake-ip-range"`
<mask> FakeIPFilter []string `yaml:"fake-ip-filter"`
<mask> DefaultNameserver []string `yaml:"default-nameserver"`
<mask> }
<mask>
<mask> type RawFallbackFilter struct {
<mask> GeoIP bool `yaml:"geoip"`
<mask> IPCIDR []string `yaml:"ipcidr"`
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove func validAndSplitDomain(domain string) ([]string, bool) {
</s> add func ValidAndSplitDomain(domain string) ([]string, bool) { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | config/config.go |
if dnsCfg.NameServerPolicy, err = parseNameServerPolicy(cfg.NameServerPolicy); err != nil {
return nil, err
}
| <mask> if dnsCfg.Fallback, err = parseNameServer(cfg.Fallback); err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> if len(cfg.DefaultNameserver) == 0 {
<mask> return nil, errors.New("default nameserver should have at least one nameserver")
<mask> }
<mask> if dnsCfg.DefaultNameserver, err = parseNameServer(cfg.DefaultNameserver); err != nil {
<mask> return nil, err
<mask> }
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove func validAndSplitDomain(domain string) ([]string, bool) {
</s> add func ValidAndSplitDomain(domain string) ([]string, bool) { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | config/config.go |
policy *trie.DomainTrie | <mask> fallbackDomainFilters []fallbackDomainFilter
<mask> fallbackIPFilters []fallbackIPFilter
<mask> group singleflight.Group
<mask> lruCache *cache.LruCache
<mask> }
<mask>
<mask> // ResolveIP request with TypeA and TypeAAAA, priority return TypeA
<mask> func (r *Resolver) ResolveIP(host string) (ip net.IP, err error) {
<mask> ch := make(chan net.IP, 1)
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove func validAndSplitDomain(domain string) ([]string, bool) {
</s> add func ValidAndSplitDomain(domain string) ([]string, bool) { </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | dns/resolver.go |
if matched := r.matchPolicy(m); len(matched) != 0 {
return r.batchExchange(matched, m)
} | <mask> }
<mask>
<mask> return r.batchExchange(r.main, m)
<mask> })
<mask>
<mask> if err == nil {
<mask> msg = ret.(*D.Msg)
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) </s> remove func validAndSplitDomain(domain string) ([]string, bool) {
</s> add func ValidAndSplitDomain(domain string) ([]string, bool) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | dns/resolver.go |
if matched := r.matchPolicy(m); len(matched) != 0 {
res := <-r.asyncExchange(matched, m)
return res.Msg, res.Error
}
| <mask>
<mask> func (r *Resolver) ipExchange(m *D.Msg) (msg *D.Msg, err error) {
<mask>
<mask> onlyFallback := r.shouldOnlyQueryFallback(m)
<mask>
<mask> if onlyFallback {
<mask> res := <-r.asyncExchange(r.fallback, m)
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | dns/resolver.go |
Policy map[string]NameServer | <mask> EnhancedMode EnhancedMode
<mask> FallbackFilter FallbackFilter
<mask> Pool *fakeip.Pool
<mask> Hosts *trie.DomainTrie
<mask> }
<mask>
<mask> func NewResolver(config Config) *Resolver {
<mask> defaultResolver := &Resolver{
<mask> main: transform(config.Default, nil),
</s> Feature: dns resolve domain through nameserver-policy (#1406) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | dns/resolver.go |
if len(config.Policy) != 0 {
r.policy = trie.New()
for domain, nameserver := range config.Policy {
r.policy.Insert(domain, transform([]NameServer{nameserver}, defaultResolver))
}
}
| <mask> }
<mask>
<mask> fallbackIPFilters := []fallbackIPFilter{}
<mask> if config.FallbackFilter.GeoIP {
<mask> fallbackIPFilters = append(fallbackIPFilters, &geoipFilter{})
<mask> }
<mask> for _, ipnet := range config.FallbackFilter.IPCIDR {
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | dns/resolver.go |
Policy: c.NameServerPolicy, | <mask> },
<mask> Default: c.DefaultNameserver,
<mask> }
<mask>
<mask> r := dns.NewResolver(cfg)
<mask> m := dns.NewEnhancer(cfg)
<mask>
<mask> // reuse cache of old host mapper
</s> Feature: dns resolve domain through nameserver-policy (#1406) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) </s> remove parts, valid := validAndSplitDomain(domain)
</s> add parts, valid := ValidAndSplitDomain(domain) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0778591524e180cc935176e772ede8d8a86c0f85 | hub/executor/executor.go |
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> "github.com/Dreamacro/clash/log"
<mask>
<mask> D "github.com/miekg/dns"
<mask> yaml "gopkg.in/yaml.v2"
<mask> )
<mask>
<mask> var (
<mask> // EnhancedModeMapping is a mapping for EnhancedMode enum
<mask> EnhancedModeMapping = map[string]EnhancedMode{
</s> Chore: support MarshalYAML to some config filed (#581) </s> remove func (e EnhancedMode) MarshalYAML() ([]byte, error) {
return yaml.Marshal(e.String())
</s> add func (e EnhancedMode) MarshalYAML() (interface{}, error) {
return e.String(), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082847b40384c037842fb2ea95b24107dda58903 | dns/util.go | |
func (e EnhancedMode) MarshalYAML() (interface{}, error) {
return e.String(), nil | <mask> return nil
<mask> }
<mask>
<mask> // MarshalYAML serialize EnhancedMode with yaml
<mask> func (e EnhancedMode) MarshalYAML() ([]byte, error) {
<mask> return yaml.Marshal(e.String())
<mask> }
<mask>
<mask> // UnmarshalJSON unserialize EnhancedMode with json
<mask> func (e *EnhancedMode) UnmarshalJSON(data []byte) error {
<mask> var tp string
</s> Chore: support MarshalYAML to some config filed (#581) </s> remove yaml "gopkg.in/yaml.v2"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082847b40384c037842fb2ea95b24107dda58903 | dns/util.go |
// MarshalYAML serialize LogLevel with yaml
func (l LogLevel) MarshalYAML() (interface{}, error) {
return l.String(), nil
}
| <mask> }
<mask>
<mask> func (l LogLevel) String() string {
<mask> switch l {
<mask> case INFO:
<mask> return "info"
</s> Chore: support MarshalYAML to some config filed (#581) </s> remove func (e EnhancedMode) MarshalYAML() ([]byte, error) {
return yaml.Marshal(e.String())
</s> add func (e EnhancedMode) MarshalYAML() (interface{}, error) {
return e.String(), nil </s> remove yaml "gopkg.in/yaml.v2"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082847b40384c037842fb2ea95b24107dda58903 | log/level.go |
// MarshalYAML serialize TunnelMode with yaml
func (m TunnelMode) MarshalYAML() (interface{}, error) {
return m.String(), nil
}
| <mask> }
<mask>
<mask> func (m TunnelMode) String() string {
<mask> switch m {
<mask> case Global:
<mask> return "Global"
<mask> case Rule:
<mask> return "Rule"
</s> Chore: support MarshalYAML to some config filed (#581) </s> remove func (e EnhancedMode) MarshalYAML() ([]byte, error) {
return yaml.Marshal(e.String())
</s> add func (e EnhancedMode) MarshalYAML() (interface{}, error) {
return e.String(), nil </s> remove yaml "gopkg.in/yaml.v2"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082847b40384c037842fb2ea95b24107dda58903 | tunnel/mode.go |
c, err := net.DialTimeout("tcp", net.JoinHostPort(metadata.String(), metadata.Port), tcpTimeout) | <mask> return C.Direct
<mask> }
<mask>
<mask> func (d *Direct) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", net.JoinHostPort(metadata.String(), metadata.Port))
<mask> if err != nil {
<mask> return
<mask> }
<mask> tcpKeepAlive(c)
<mask> return &DirectAdapter{conn: c}, nil
</s> Chore: adjust dial tcp timeout </s> remove c, err := net.Dial("tcp", ss.addr)
</s> add c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082d3bbf04677f9d148778766c2fccd181f3c45a | adapters/outbound/direct.go |
c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) | <mask> return C.Shadowsocks
<mask> }
<mask>
<mask> func (ss *ShadowSocks) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", ss.server)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error", ss.server)
<mask> }
<mask> tcpKeepAlive(c)
<mask> switch ss.obfs {
</s> Chore: adjust dial tcp timeout </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.addr)
</s> add c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.Dial("tcp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add c, err := net.DialTimeout("tcp", net.JoinHostPort(metadata.String(), metadata.Port), tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082d3bbf04677f9d148778766c2fccd181f3c45a | adapters/outbound/shadowsocks.go |
c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout) | <mask> return C.Socks5
<mask> }
<mask>
<mask> func (ss *Socks5) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", ss.addr)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error", ss.addr)
<mask> }
<mask> tcpKeepAlive(c)
<mask> if err := ss.shakeHand(metadata, c); err != nil {
</s> Chore: adjust dial tcp timeout </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.Dial("tcp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add c, err := net.DialTimeout("tcp", net.JoinHostPort(metadata.String(), metadata.Port), tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082d3bbf04677f9d148778766c2fccd181f3c45a | adapters/outbound/socks5.go |
const (
tcpTimeout = 5 * time.Second
)
| <mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> // DelayTest get the delay for the specified URL
<mask> func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
<mask> addr, err := urlToMetadata(url)
<mask> if err != nil {
<mask> return
</s> Chore: adjust dial tcp timeout </s> remove c, err := net.Dial("tcp", ss.addr)
</s> add c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.Dial("tcp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add c, err := net.DialTimeout("tcp", net.JoinHostPort(metadata.String(), metadata.Port), tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082d3bbf04677f9d148778766c2fccd181f3c45a | adapters/outbound/util.go |
c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) | <mask> return C.Vmess
<mask> }
<mask>
<mask> func (ss *Vmess) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", ss.server)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error", ss.server)
<mask> }
<mask> tcpKeepAlive(c)
<mask> c = ss.client.New(c, parseVmessAddr(metadata))
</s> Chore: adjust dial tcp timeout </s> remove c, err := net.Dial("tcp", ss.server)
</s> add c, err := net.DialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.Dial("tcp", ss.addr)
</s> add c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.Dial("tcp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add c, err := net.DialTimeout("tcp", net.JoinHostPort(metadata.String(), metadata.Port), tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/082d3bbf04677f9d148778766c2fccd181f3c45a | adapters/outbound/vmess.go |
"context" | <mask> package adapters
<mask>
<mask> import (
<mask> "bytes"
<mask> "crypto/tls"
<mask> "fmt"
<mask> "net"
<mask> "net/url"
<mask> "strconv"
</s> Fix: tcp dual stack dial </s> remove return net.DialTimeout(network, net.JoinHostPort(ip.String(), port), timeout)
</s> add var c net.Conn
if ipv6 {
c, err = dialer.DialContext(ctx, "tcp6", net.JoinHostPort(ip.String(), port))
} else {
c, err = dialer.DialContext(ctx, "tcp4", net.JoinHostPort(ip.String(), port))
}
if err != nil {
return
}
select {
case results <- dialResult{Conn: c, error: err, ipv6: ipv6}:
case <-returned:
if c != nil {
c.Close()
}
}
}
go startRacer(ctx, host, false)
go startRacer(ctx, host, true)
for {
select {
case res := <-results:
if res.error == nil {
return res.Conn, nil
}
if res.ipv6 {
primary = res
} else {
fallback = res
}
if primary.done && fallback.done {
return nil, primary.error
}
}
} </s> remove ip, err := dns.ResolveIP(host)
if err != nil {
return nil, err
</s> add dialer := net.Dialer{Timeout: timeout}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
returned := make(chan struct{})
defer close(returned)
type dialResult struct {
net.Conn
error
ipv6 bool
done bool | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/09917a2a9519d1acd42b2e1b4031d169eb50203e | adapters/outbound/util.go |
dialer := net.Dialer{Timeout: timeout}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
returned := make(chan struct{})
defer close(returned)
type dialResult struct {
net.Conn
error
ipv6 bool
done bool | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> ip, err := dns.ResolveIP(host)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> return net.DialTimeout(network, net.JoinHostPort(ip.String(), port), timeout)
<mask> }
<mask>
</s> Fix: tcp dual stack dial </s> remove return net.DialTimeout(network, net.JoinHostPort(ip.String(), port), timeout)
</s> add var c net.Conn
if ipv6 {
c, err = dialer.DialContext(ctx, "tcp6", net.JoinHostPort(ip.String(), port))
} else {
c, err = dialer.DialContext(ctx, "tcp4", net.JoinHostPort(ip.String(), port))
}
if err != nil {
return
}
select {
case results <- dialResult{Conn: c, error: err, ipv6: ipv6}:
case <-returned:
if c != nil {
c.Close()
}
}
}
go startRacer(ctx, host, false)
go startRacer(ctx, host, true)
for {
select {
case res := <-results:
if res.error == nil {
return res.Conn, nil
}
if res.ipv6 {
primary = res
} else {
fallback = res
}
if primary.done && fallback.done {
return nil, primary.error
}
}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/09917a2a9519d1acd42b2e1b4031d169eb50203e | adapters/outbound/util.go |
results := make(chan dialResult)
var primary, fallback dialResult
startRacer := func(ctx context.Context, host string, ipv6 bool) {
var err error
var ip net.IP
if ipv6 {
ip, err = dns.ResolveIPv6(host)
} else {
ip, err = dns.ResolveIPv4(host)
}
if err != nil {
return
} | <mask> error
<mask> ipv6 bool
<mask> done bool
<mask> }
<mask>
<mask> var c net.Conn
<mask> if ipv6 {
<mask> c, err = dialer.DialContext(ctx, "tcp6", net.JoinHostPort(ip.String(), port))
</s> Fix: tcp dual stack dial </s> remove ip, err := dns.ResolveIP(host)
if err != nil {
return nil, err
</s> add dialer := net.Dialer{Timeout: timeout}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
returned := make(chan struct{})
defer close(returned)
type dialResult struct {
net.Conn
error
ipv6 bool
done bool </s> remove return net.DialTimeout(network, net.JoinHostPort(ip.String(), port), timeout)
</s> add var c net.Conn
if ipv6 {
c, err = dialer.DialContext(ctx, "tcp6", net.JoinHostPort(ip.String(), port))
} else {
c, err = dialer.DialContext(ctx, "tcp4", net.JoinHostPort(ip.String(), port))
}
if err != nil {
return
}
select {
case results <- dialResult{Conn: c, error: err, ipv6: ipv6}:
case <-returned:
if c != nil {
c.Close()
}
}
}
go startRacer(ctx, host, false)
go startRacer(ctx, host, true)
for {
select {
case res := <-results:
if res.error == nil {
return res.Conn, nil
}
if res.ipv6 {
primary = res
} else {
fallback = res
}
if primary.done && fallback.done {
return nil, primary.error
}
}
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/09917a2a9519d1acd42b2e1b4031d169eb50203e | adapters/outbound/util.go |
var c net.Conn
if ipv6 {
c, err = dialer.DialContext(ctx, "tcp6", net.JoinHostPort(ip.String(), port))
} else {
c, err = dialer.DialContext(ctx, "tcp4", net.JoinHostPort(ip.String(), port))
}
if err != nil {
return
}
select {
case results <- dialResult{Conn: c, error: err, ipv6: ipv6}:
case <-returned:
if c != nil {
c.Close()
}
}
}
go startRacer(ctx, host, false)
go startRacer(ctx, host, true)
for {
select {
case res := <-results:
if res.error == nil {
return res.Conn, nil
}
if res.ipv6 {
primary = res
} else {
fallback = res
}
if primary.done && fallback.done {
return nil, primary.error
}
}
} | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> return net.DialTimeout(network, net.JoinHostPort(ip.String(), port), timeout)
<mask> }
<mask>
<mask> func resolveUDPAddr(network, address string) (*net.UDPAddr, error) {
<mask> host, port, err := net.SplitHostPort(address)
<mask> if err != nil {
</s> Fix: tcp dual stack dial </s> remove ip, err := dns.ResolveIP(host)
if err != nil {
return nil, err
</s> add dialer := net.Dialer{Timeout: timeout}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
returned := make(chan struct{})
defer close(returned)
type dialResult struct {
net.Conn
error
ipv6 bool
done bool | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/09917a2a9519d1acd42b2e1b4031d169eb50203e | adapters/outbound/util.go |
homeDir string
configFile string | <mask> // Path is used to get the configuration path
<mask> var Path *path
<mask>
<mask> type path struct {
<mask> homedir string
<mask> }
<mask>
<mask> func init() {
<mask> homedir, err := os.UserHomeDir()
<mask> if err != nil {
</s> Feature: can set specify config file path in cli (#360) </s> remove Path = &path{homedir: root}
</s> add Path.homeDir = root
}
// SetConfig is used to set the configuration file
func SetConfig(file string) {
Path.configFile = file </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove homedir = filepath.Join(currentDir, homedir)
</s> add homeDir = filepath.Join(currentDir, homeDir) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
homeDir, err := os.UserHomeDir() | <mask> homedir string
<mask> }
<mask>
<mask> func init() {
<mask> homedir, err := os.UserHomeDir()
<mask> if err != nil {
<mask> homedir, _ = os.Getwd()
<mask> }
<mask>
<mask> homedir = P.Join(homedir, ".config", Name)
</s> Feature: can set specify config file path in cli (#360) </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} </s> remove homedir string
</s> add homeDir string
configFile string </s> remove homedir = filepath.Join(currentDir, homedir)
</s> add homeDir = filepath.Join(currentDir, homeDir) </s> remove C.SetHomeDir(homedir)
</s> add C.SetHomeDir(homeDir)
}
if configFile != "" {
if !filepath.IsAbs(configFile) {
currentDir, _ := os.Getwd()
configFile = filepath.Join(currentDir, configFile)
}
C.SetConfig(configFile)
} else {
configFile := filepath.Join(C.Path.HomeDir(), C.Path.Config())
C.SetConfig(configFile) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
homeDir, _ = os.Getwd() | <mask>
<mask> func init() {
<mask> homedir, err := os.UserHomeDir()
<mask> if err != nil {
<mask> homedir, _ = os.Getwd()
<mask> }
<mask>
<mask> homedir = P.Join(homedir, ".config", Name)
<mask> Path = &path{homedir: homedir}
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} </s> remove homedir string
</s> add homeDir string
configFile string </s> remove homedir = filepath.Join(currentDir, homedir)
</s> add homeDir = filepath.Join(currentDir, homeDir) </s> remove C.SetHomeDir(homedir)
</s> add C.SetHomeDir(homeDir)
}
if configFile != "" {
if !filepath.IsAbs(configFile) {
currentDir, _ := os.Getwd()
configFile = filepath.Join(currentDir, configFile)
}
C.SetConfig(configFile)
} else {
configFile := filepath.Join(C.Path.HomeDir(), C.Path.Config())
C.SetConfig(configFile) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} | <mask> if err != nil {
<mask> homedir, _ = os.Getwd()
<mask> }
<mask>
<mask> homedir = P.Join(homedir, ".config", Name)
<mask> Path = &path{homedir: homedir}
<mask> }
<mask>
<mask> // SetHomeDir is used to set the configuration path
<mask> func SetHomeDir(root string) {
<mask> Path = &path{homedir: root}
</s> Feature: can set specify config file path in cli (#360) </s> remove Path = &path{homedir: root}
</s> add Path.homeDir = root
}
// SetConfig is used to set the configuration file
func SetConfig(file string) {
Path.configFile = file </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove homedir string
</s> add homeDir string
configFile string </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove return p.homedir
</s> add return p.homeDir | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
Path.homeDir = root
}
// SetConfig is used to set the configuration file
func SetConfig(file string) {
Path.configFile = file | <mask> }
<mask>
<mask> // SetHomeDir is used to set the configuration path
<mask> func SetHomeDir(root string) {
<mask> Path = &path{homedir: root}
<mask> }
<mask>
<mask> func (p *path) HomeDir() string {
<mask> return p.homedir
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} </s> remove return p.homedir
</s> add return p.homeDir </s> remove homedir string
</s> add homeDir string
configFile string </s> remove return P.Join(p.homedir, "config.yaml")
</s> add return p.configFile </s> remove return P.Join(p.homedir, "Country.mmdb")
</s> add return P.Join(p.homeDir, "Country.mmdb") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
return p.homeDir | <mask> Path = &path{homedir: root}
<mask> }
<mask>
<mask> func (p *path) HomeDir() string {
<mask> return p.homedir
<mask> }
<mask>
<mask> func (p *path) Config() string {
<mask> return P.Join(p.homedir, "config.yaml")
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove return P.Join(p.homedir, "config.yaml")
</s> add return p.configFile </s> remove return P.Join(p.homedir, "Country.mmdb")
</s> add return P.Join(p.homeDir, "Country.mmdb") </s> remove Path = &path{homedir: root}
</s> add Path.homeDir = root
}
// SetConfig is used to set the configuration file
func SetConfig(file string) {
Path.configFile = file </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
return p.configFile | <mask> return p.homedir
<mask> }
<mask>
<mask> func (p *path) Config() string {
<mask> return P.Join(p.homedir, "config.yaml")
<mask> }
<mask>
<mask> func (p *path) MMDB() string {
<mask> return P.Join(p.homedir, "Country.mmdb")
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove return P.Join(p.homedir, "Country.mmdb")
</s> add return P.Join(p.homeDir, "Country.mmdb") </s> remove return p.homedir
</s> add return p.homeDir </s> remove Path = &path{homedir: root}
</s> add Path.homeDir = root
}
// SetConfig is used to set the configuration file
func SetConfig(file string) {
Path.configFile = file </s> remove if homedir != "" {
if !filepath.IsAbs(homedir) {
</s> add if homeDir != "" {
if !filepath.IsAbs(homeDir) { </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
return P.Join(p.homeDir, "Country.mmdb") | <mask> return P.Join(p.homedir, "config.yaml")
<mask> }
<mask>
<mask> func (p *path) MMDB() string {
<mask> return P.Join(p.homedir, "Country.mmdb")
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove return P.Join(p.homedir, "config.yaml")
</s> add return p.configFile </s> remove return p.homedir
</s> add return p.homeDir </s> remove Path = &path{homedir: root}
</s> add Path.homeDir = root
}
// SetConfig is used to set the configuration file
func SetConfig(file string) {
Path.configFile = file </s> remove if homedir != "" {
if !filepath.IsAbs(homedir) {
</s> add if homeDir != "" {
if !filepath.IsAbs(homeDir) { </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | constant/path.go |
version bool
homeDir string
configFile string | <mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> version bool
<mask> homedir string
<mask> )
<mask>
<mask> func init() {
<mask> flag.StringVar(&homedir, "d", "", "set configuration directory")
<mask> flag.BoolVar(&version, "v", false, "show current version of clash")
</s> Feature: can set specify config file path in cli (#360) </s> remove flag.StringVar(&homedir, "d", "", "set configuration directory")
</s> add flag.StringVar(&homeDir, "d", "", "set configuration directory")
flag.StringVar(&configFile, "f", "", "specify configuration file") </s> remove homedir string
</s> add homeDir string
configFile string </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove return P.Join(p.homedir, "config.yaml")
</s> add return p.configFile | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | main.go |
flag.StringVar(&homeDir, "d", "", "set configuration directory")
flag.StringVar(&configFile, "f", "", "specify configuration file") | <mask> homedir string
<mask> )
<mask>
<mask> func init() {
<mask> flag.StringVar(&homedir, "d", "", "set configuration directory")
<mask> flag.BoolVar(&version, "v", false, "show current version of clash")
<mask> flag.Parse()
<mask> }
<mask>
<mask> func main() {
</s> Feature: can set specify config file path in cli (#360) </s> remove version bool
homedir string
</s> add version bool
homeDir string
configFile string </s> remove homedir string
</s> add homeDir string
configFile string </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove return P.Join(p.homedir, "config.yaml")
</s> add return p.configFile </s> remove return p.homedir
</s> add return p.homeDir | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | main.go |
if homeDir != "" {
if !filepath.IsAbs(homeDir) { | <mask> fmt.Printf("Clash %s %s %s %s\n", C.Version, runtime.GOOS, runtime.GOARCH, C.BuildTime)
<mask> return
<mask> }
<mask>
<mask> if homedir != "" {
<mask> if !filepath.IsAbs(homedir) {
<mask> currentDir, _ := os.Getwd()
<mask> homedir = filepath.Join(currentDir, homedir)
<mask> }
<mask> C.SetHomeDir(homedir)
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove homedir = filepath.Join(currentDir, homedir)
</s> add homeDir = filepath.Join(currentDir, homeDir) </s> remove C.SetHomeDir(homedir)
</s> add C.SetHomeDir(homeDir)
}
if configFile != "" {
if !filepath.IsAbs(configFile) {
currentDir, _ := os.Getwd()
configFile = filepath.Join(currentDir, configFile)
}
C.SetConfig(configFile)
} else {
configFile := filepath.Join(C.Path.HomeDir(), C.Path.Config())
C.SetConfig(configFile) </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | main.go |
homeDir = filepath.Join(currentDir, homeDir) | <mask>
<mask> if homedir != "" {
<mask> if !filepath.IsAbs(homedir) {
<mask> currentDir, _ := os.Getwd()
<mask> homedir = filepath.Join(currentDir, homedir)
<mask> }
<mask> C.SetHomeDir(homedir)
<mask> }
<mask>
<mask> if err := config.Init(C.Path.HomeDir()); err != nil {
</s> Feature: can set specify config file path in cli (#360) </s> remove C.SetHomeDir(homedir)
</s> add C.SetHomeDir(homeDir)
}
if configFile != "" {
if !filepath.IsAbs(configFile) {
currentDir, _ := os.Getwd()
configFile = filepath.Join(currentDir, configFile)
}
C.SetConfig(configFile)
} else {
configFile := filepath.Join(C.Path.HomeDir(), C.Path.Config())
C.SetConfig(configFile) </s> remove if homedir != "" {
if !filepath.IsAbs(homedir) {
</s> add if homeDir != "" {
if !filepath.IsAbs(homeDir) { </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove homedir string
</s> add homeDir string
configFile string | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | main.go |
C.SetHomeDir(homeDir)
}
if configFile != "" {
if !filepath.IsAbs(configFile) {
currentDir, _ := os.Getwd()
configFile = filepath.Join(currentDir, configFile)
}
C.SetConfig(configFile)
} else {
configFile := filepath.Join(C.Path.HomeDir(), C.Path.Config())
C.SetConfig(configFile) | <mask> if !filepath.IsAbs(homedir) {
<mask> currentDir, _ := os.Getwd()
<mask> homedir = filepath.Join(currentDir, homedir)
<mask> }
<mask> C.SetHomeDir(homedir)
<mask> }
<mask>
<mask> if err := config.Init(C.Path.HomeDir()); err != nil {
<mask> log.Fatalf("Initial configuration directory error: %s", err.Error())
<mask> }
</s> Feature: can set specify config file path in cli (#360) </s> remove homedir = filepath.Join(currentDir, homedir)
</s> add homeDir = filepath.Join(currentDir, homeDir) </s> remove if homedir != "" {
if !filepath.IsAbs(homedir) {
</s> add if homeDir != "" {
if !filepath.IsAbs(homeDir) { </s> remove homedir, err := os.UserHomeDir()
</s> add homeDir, err := os.UserHomeDir() </s> remove homedir, _ = os.Getwd()
</s> add homeDir, _ = os.Getwd() </s> remove homedir = P.Join(homedir, ".config", Name)
Path = &path{homedir: homedir}
</s> add homeDir = P.Join(homeDir, ".config", Name)
Path = &path{homeDir: homeDir, configFile: "config.yaml"} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0a3595414e2659756075b3fd1703336c0fcaff1e | main.go |
ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) | <mask> return
<mask> }
<mask> defer atomic.StoreInt32(&u.once, 0)
<mask>
<mask> picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> defer cancel()
<mask> for _, p := range u.proxies {
<mask> proxy := p
<mask> picker.Go(func() (interface{}, error) {
<mask> _, err := proxy.URLTest(ctx, u.rawURL)
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) </s> remove ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
fast, ctx := picker.WithContext(ctx)
</s> add fast, ctx := picker.WithTimeout(context.Background(), time.Second) </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
defer cancel()
</s> add picker, ctx := WithTimeout(context.Background(), time.Millisecond*5) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | adapters/outbound/urltest.go |
picker := picker.WithoutAutoCancel(ctx) | <mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> defer cancel()
<mask> for _, p := range u.proxies {
<mask> proxy := p
<mask> picker.Go(func() (interface{}, error) {
<mask> _, err := proxy.URLTest(ctx, u.rawURL)
<mask> if err != nil {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) </s> remove ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
fast, ctx := picker.WithContext(ctx)
</s> add fast, ctx := picker.WithTimeout(context.Background(), time.Second) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | adapters/outbound/urltest.go |
fast := picker.WaitWithoutCancel() | <mask> return proxy, nil
<mask> })
<mask> }
<mask>
<mask> fast := picker.Wait()
<mask> if fast != nil {
<mask> u.fast = fast.(C.Proxy)
<mask> }
<mask> }
<mask>
</s> Fix: urltest get fastest node ehavior (#326) </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { </s> remove picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
defer cancel()
</s> add picker, ctx := WithTimeout(context.Background(), time.Millisecond*5) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | adapters/outbound/urltest.go |
picker.Wait() | <mask> if fast != nil {
<mask> u.fast = fast.(C.Proxy)
<mask> }
<mask> }
<mask>
<mask> func NewURLTest(option URLTestOption, proxies []C.Proxy) (*URLTest, error) {
<mask> _, err := urlToMetadata(option.URL)
</s> Fix: urltest get fastest node ehavior (#326) </s> remove fast := picker.Wait()
</s> add fast := picker.WaitWithoutCancel() </s> remove ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
fast, ctx := picker.WithContext(ctx)
</s> add fast, ctx := picker.WithTimeout(context.Background(), time.Second) </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | adapters/outbound/urltest.go |
ctx context.Context | <mask> // Inspired by errGroup
<mask> type Picker struct {
<mask> cancel func()
<mask>
<mask> wg sync.WaitGroup
<mask>
<mask> once sync.Once
<mask> result interface{}
</s> Fix: urltest get fastest node ehavior (#326) </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) </s> remove return &Picker{cancel: cancel}, ctx
</s> add return newPicker(ctx, cancel), ctx </s> remove // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
// but it doesn't cancel when first element return.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
</s> add // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
firstDone chan struct{}
}
func newPicker(ctx context.Context, cancel func()) *Picker {
return &Picker{
ctx: ctx,
cancel: cancel,
firstDone: make(chan struct{}, 1),
} | <mask> wg sync.WaitGroup
<mask>
<mask> once sync.Once
<mask> result interface{}
<mask> }
<mask>
<mask> // WithContext returns a new Picker and an associated Context derived from ctx.
<mask> // and cancel when first element return.
<mask> func WithContext(ctx context.Context) (*Picker, context.Context) {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove return &Picker{cancel: cancel}, ctx
</s> add return newPicker(ctx, cancel), ctx </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) </s> remove // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
// but it doesn't cancel when first element return.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
</s> add // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
return newPicker(ctx, cancel), ctx | <mask> // WithContext returns a new Picker and an associated Context derived from ctx.
<mask> // and cancel when first element return.
<mask> func WithContext(ctx context.Context) (*Picker, context.Context) {
<mask> ctx, cancel := context.WithCancel(ctx)
<mask> return &Picker{cancel: cancel}, ctx
<mask> }
<mask>
<mask> // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
<mask> // but it doesn't cancel when first element return.
<mask> func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
// but it doesn't cancel when first element return.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
</s> add // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) { </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
// WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) { | <mask> ctx, cancel := context.WithCancel(ctx)
<mask> return &Picker{cancel: cancel}, ctx
<mask> }
<mask>
<mask> // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
<mask> // but it doesn't cancel when first element return.
<mask> func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
<mask> ctx, cancel := context.WithTimeout(ctx, timeout)
<mask> return &Picker{}, ctx, cancel
<mask> }
<mask>
<mask> // Wait blocks until all function calls from the Go method have returned,
</s> Fix: urltest get fastest node ehavior (#326) </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) </s> remove return &Picker{cancel: cancel}, ctx
</s> add return newPicker(ctx, cancel), ctx </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) | <mask> // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
<mask> // but it doesn't cancel when first element return.
<mask> func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
<mask> ctx, cancel := context.WithTimeout(ctx, timeout)
<mask> return &Picker{}, ctx, cancel
<mask> }
<mask>
<mask> // Wait blocks until all function calls from the Go method have returned,
<mask> // then returns the first nil error result (if any) from them.
<mask> func (p *Picker) Wait() interface{} {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
// but it doesn't cancel when first element return.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
</s> add // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) { </s> remove return &Picker{cancel: cancel}, ctx
</s> add return newPicker(ctx, cancel), ctx | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
// WaitWithoutCancel blocks until the first result return, if timeout will return nil.
func (p *Picker) WaitWithoutCancel() interface{} {
select {
case <-p.firstDone:
return p.result
case <-p.ctx.Done():
return p.result
}
}
| <mask> }
<mask>
<mask> // Go calls the given function in a new goroutine.
<mask> // The first call to return a nil error cancels the group; its result will be returned by Wait.
<mask> func (p *Picker) Go(f func() (interface{}, error)) {
<mask> p.wg.Add(1)
<mask>
<mask> go func() {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) </s> remove // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout,
// but it doesn't cancel when first element return.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context, context.CancelFunc) {
</s> add // WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) { </s> remove return &Picker{cancel: cancel}, ctx
</s> add return newPicker(ctx, cancel), ctx </s> remove delay := elm.(uint16)
if delay == 0 {
</s> add if err != nil || delay == 0 { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
p.firstDone <- struct{}{} | <mask>
<mask> if ret, err := f(); err == nil {
<mask> p.once.Do(func() {
<mask> p.result = ret
<mask> if p.cancel != nil {
<mask> p.cancel()
<mask> }
<mask> })
</s> Fix: urltest get fastest node ehavior (#326) </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { </s> remove delay := elm.(uint16)
if delay == 0 {
</s> add if err != nil || delay == 0 { </s> remove fast := picker.Wait()
</s> add fast := picker.WaitWithoutCancel() </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker.go |
"github.com/stretchr/testify/assert" | <mask> import (
<mask> "context"
<mask> "testing"
<mask> "time"
<mask> )
<mask>
<mask> func sleepAndSend(ctx context.Context, delay int, input interface{}) func() (interface{}, error) {
<mask> return func() (interface{}, error) {
<mask> timer := time.NewTimer(time.Millisecond * time.Duration(delay))
<mask> select {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) </s> remove delay := elm.(uint16)
if delay == 0 {
</s> add if err != nil || delay == 0 { </s> remove ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
fast, ctx := picker.WithContext(ctx)
</s> add fast, ctx := picker.WithTimeout(context.Background(), time.Second) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker_test.go |
assert.NotNil(t, number)
assert.Equal(t, number.(int), 1) | <mask> picker.Go(sleepAndSend(ctx, 30, 2))
<mask> picker.Go(sleepAndSend(ctx, 20, 1))
<mask>
<mask> number := picker.Wait()
<mask> if number != nil && number.(int) != 1 {
<mask> t.Error("should recv 1", number)
<mask> }
<mask> }
<mask>
<mask> func TestPicker_Timeout(t *testing.T) {
<mask> picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
<mask> defer cancel()
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
defer cancel()
</s> add picker, ctx := WithTimeout(context.Background(), time.Millisecond*5) </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker_test.go |
picker, ctx := WithTimeout(context.Background(), time.Millisecond*5) | <mask> }
<mask> }
<mask>
<mask> func TestPicker_Timeout(t *testing.T) {
<mask> picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
<mask> defer cancel()
<mask>
<mask> picker.Go(sleepAndSend(ctx, 20, 1))
<mask>
<mask> number := picker.Wait()
<mask> if number != nil {
<mask> t.Error("should recv nil")
</s> Fix: urltest get fastest node ehavior (#326) </s> remove if number != nil && number.(int) != 1 {
t.Error("should recv 1", number)
}
</s> add assert.NotNil(t, number)
assert.Equal(t, number.(int), 1) </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker_test.go |
assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) | <mask>
<mask> picker.Go(sleepAndSend(ctx, 20, 1))
<mask>
<mask> number := picker.Wait()
<mask> if number != nil {
<mask> t.Error("should recv nil")
<mask> }
<mask> }
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
defer cancel()
</s> add picker, ctx := WithTimeout(context.Background(), time.Millisecond*5) </s> remove if number != nil && number.(int) != 1 {
t.Error("should recv 1", number)
}
</s> add assert.NotNil(t, number)
assert.Equal(t, number.(int), 1) </s> remove fast := picker.Wait()
</s> add fast := picker.WaitWithoutCancel() </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | common/picker/picker_test.go |
fast, ctx := picker.WithTimeout(context.Background(), time.Second) | <mask> return r.fakeip
<mask> }
<mask>
<mask> func (r *Resolver) batchExchange(clients []resolver, m *D.Msg) (msg *D.Msg, err error) {
<mask> ctx, cancel := context.WithTimeout(context.Background(), time.Second)
<mask> defer cancel()
<mask> fast, ctx := picker.WithContext(ctx)
<mask>
<mask> for _, client := range clients {
<mask> r := client
<mask> fast.Go(func() (interface{}, error) {
<mask> msg, err := r.ExchangeContext(ctx, m)
<mask> if err != nil || msg.Rcode != D.RcodeSuccess {
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | dns/resolver.go |
<mask> "strconv"
<mask> "time"
<mask>
<mask> A "github.com/Dreamacro/clash/adapters/outbound"
<mask> "github.com/Dreamacro/clash/common/picker"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> T "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/go-chi/chi"
<mask> "github.com/go-chi/render"
</s> Fix: urltest get fastest node ehavior (#326) </s> remove delay := elm.(uint16)
if delay == 0 {
</s> add if err != nil || delay == 0 { </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) </s> remove fast := picker.Wait()
</s> add fast := picker.WaitWithoutCancel() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | hub/route/proxies.go | |
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) | <mask> }
<mask>
<mask> proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
<mask>
<mask> picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
<mask> defer cancel()
<mask> picker.Go(func() (interface{}, error) {
<mask> return proxy.URLTest(ctx, url)
<mask> })
<mask>
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { </s> remove picker, ctx, cancel := WithTimeout(context.Background(), time.Millisecond*5)
defer cancel()
</s> add picker, ctx := WithTimeout(context.Background(), time.Millisecond*5) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | hub/route/proxies.go |
<mask> proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
<mask>
<mask> picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
<mask> defer cancel()
<mask> picker.Go(func() (interface{}, error) {
<mask> return proxy.URLTest(ctx, url)
<mask> })
<mask>
<mask> elm := picker.Wait()
<mask> if elm == nil {
<mask> render.Status(r, http.StatusGatewayTimeout)
<mask> render.JSON(w, r, ErrRequestTimeout)
</s> Fix: urltest get fastest node ehavior (#326) </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) </s> remove delay := elm.(uint16)
if delay == 0 {
</s> add if err != nil || delay == 0 { </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout) </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | hub/route/proxies.go | |
delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { | <mask> picker.Go(func() (interface{}, error) {
<mask> return proxy.URLTest(ctx, url)
<mask> })
<mask>
<mask> elm := picker.Wait()
<mask> if elm == nil {
<mask> render.Status(r, http.StatusGatewayTimeout)
<mask> render.JSON(w, r, ErrRequestTimeout)
<mask> return
<mask> }
<mask>
</s> Fix: urltest get fastest node ehavior (#326) </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove delay := elm.(uint16)
if delay == 0 {
</s> add if err != nil || delay == 0 { </s> remove if number != nil {
t.Error("should recv nil")
}
</s> add assert.Nil(t, number)
}
func TestPicker_WaitWithoutAutoCancel(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*60)
defer cancel()
picker := WithoutAutoCancel(ctx)
trigger := false
picker.Go(sleepAndSend(ctx, 10, 1))
picker.Go(func() (interface{}, error) {
timer := time.NewTimer(time.Millisecond * time.Duration(30))
select {
case <-timer.C:
trigger = true
return 2, nil
case <-ctx.Done():
return nil, ctx.Err()
}
})
elm := picker.WaitWithoutCancel()
assert.NotNil(t, elm)
assert.Equal(t, elm.(int), 1)
elm = picker.Wait()
assert.True(t, trigger)
assert.Equal(t, elm.(int), 1) </s> remove picker, ctx, cancel := picker.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
</s> add ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout)) </s> remove fast := picker.Wait()
</s> add fast := picker.WaitWithoutCancel() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | hub/route/proxies.go |
if err != nil || delay == 0 { | <mask> render.JSON(w, r, ErrRequestTimeout)
<mask> return
<mask> }
<mask>
<mask> delay := elm.(uint16)
<mask> if delay == 0 {
<mask> render.Status(r, http.StatusServiceUnavailable)
<mask> render.JSON(w, r, newError("An error occurred in the delay test"))
<mask> return
<mask> }
<mask>
</s> Fix: urltest get fastest node ehavior (#326) </s> remove elm := picker.Wait()
if elm == nil {
</s> add delay, err := proxy.URLTest(ctx, url)
if ctx.Err() != nil { </s> remove picker.Go(func() (interface{}, error) {
return proxy.URLTest(ctx, url)
})
</s> add </s> remove return &Picker{}, ctx, cancel
</s> add return newPicker(ctx, cancel), ctx
}
// WithoutAutoCancel returns a new Picker and an associated Context derived from ctx,
// but it wouldn't cancel context when the first element return.
func WithoutAutoCancel(ctx context.Context) *Picker {
return newPicker(ctx, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0cdc40beb3cfe3465547d3d5f2a0da913f6e3c4c | hub/route/proxies.go |
"sync" | <mask> package provider
<mask>
<mask> import (
<mask> "context"
<mask> "time"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask>
<mask> "go.uber.org/atomic"
<mask> )
</s> Chore: health checks return immediately if completed (#1097) </s> remove <-ctx.Done()
</s> add wg.Wait() </s> remove go proxy.URLTest(ctx, hc.url)
</s> add wg.Add(1)
go func(p C.Proxy) {
p.URLTest(ctx, hc.url)
wg.Done()
}(proxy) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d33dc3eb9bce2d89e54406e8dea275adb99e4b0 | adapters/provider/healthcheck.go |
wg := &sync.WaitGroup{}
| <mask>
<mask> func (hc *HealthCheck) check() {
<mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> for _, proxy := range hc.proxies {
<mask> wg.Add(1)
<mask>
<mask> go func(p C.Proxy) {
<mask> p.URLTest(ctx, hc.url)
</s> Chore: health checks return immediately if completed (#1097) </s> remove <-ctx.Done()
</s> add wg.Wait() </s> remove go proxy.URLTest(ctx, hc.url)
</s> add wg.Add(1)
go func(p C.Proxy) {
p.URLTest(ctx, hc.url)
wg.Done()
}(proxy) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d33dc3eb9bce2d89e54406e8dea275adb99e4b0 | adapters/provider/healthcheck.go |
wg.Add(1)
go func(p C.Proxy) {
p.URLTest(ctx, hc.url)
wg.Done()
}(proxy) | <mask>
<mask> func (hc *HealthCheck) check() {
<mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> for _, proxy := range hc.proxies {
<mask> go proxy.URLTest(ctx, hc.url)
<mask> }
<mask>
<mask> <-ctx.Done()
<mask> cancel()
<mask> }
</s> Chore: health checks return immediately if completed (#1097) </s> remove <-ctx.Done()
</s> add wg.Wait() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d33dc3eb9bce2d89e54406e8dea275adb99e4b0 | adapters/provider/healthcheck.go |
wg.Wait() | <mask> for _, proxy := range hc.proxies {
<mask> go proxy.URLTest(ctx, hc.url)
<mask> }
<mask>
<mask> <-ctx.Done()
<mask> cancel()
<mask> }
<mask>
<mask> func (hc *HealthCheck) close() {
<mask> hc.done <- struct{}{}
</s> Chore: health checks return immediately if completed (#1097) </s> remove go proxy.URLTest(ctx, hc.url)
</s> add wg.Add(1)
go func(p C.Proxy) {
p.URLTest(ctx, hc.url)
wg.Done()
}(proxy) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d33dc3eb9bce2d89e54406e8dea275adb99e4b0 | adapters/provider/healthcheck.go |
// keep the origional order of ProxyGroups in config file
for idx, mapping := range groupsConfig {
groupName, existName := mapping["name"].(string)
if !existName {
return nil, fmt.Errorf("ProxyGroup %d: missing name", idx)
}
proxyList = append(proxyList, groupName)
}
// check if any loop exists and sort the ProxyGroups | <mask> proxies[proxy.Name()] = adapters.NewProxy(proxy)
<mask> proxyList = append(proxyList, proxy.Name())
<mask> }
<mask>
<mask> // parse proxy group
<mask> if err := proxyGroupsDagSort(groupsConfig); err != nil {
<mask> return nil, err
<mask> }
<mask> for idx, mapping := range groupsConfig {
<mask> groupType, existType := mapping["type"].(string)
</s> Fix: should keep the original order of proxy groups (#284) </s> remove for idx, mapping := range groupsConfig {
</s> add // parse proxy group
for _, mapping := range groupsConfig { </s> remove proxyList = append(proxyList, groupName)
</s> add </s> remove groupName, existName := mapping["name"].(string)
if !(existType && existName) {
return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
</s> add groupName, _ := mapping["name"].(string)
if !existType {
return nil, fmt.Errorf("ProxyGroup %s: missing type", groupName) </s> remove // record original order in config file.
// this field can be used determinate the display order in FrontEnd.
mapping["configIdx"] = idx
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d51877fcdab1392c4dedfce0fabfb494998d6cb | config/config.go |
// parse proxy group
for _, mapping := range groupsConfig { | <mask> // parse proxy group
<mask> if err := proxyGroupsDagSort(groupsConfig); err != nil {
<mask> return nil, err
<mask> }
<mask> for idx, mapping := range groupsConfig {
<mask> groupType, existType := mapping["type"].(string)
<mask> groupName, existName := mapping["name"].(string)
<mask> if !(existType && existName) {
<mask> return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
<mask> }
</s> Fix: should keep the original order of proxy groups (#284) </s> remove groupName, existName := mapping["name"].(string)
if !(existType && existName) {
return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
</s> add groupName, _ := mapping["name"].(string)
if !existType {
return nil, fmt.Errorf("ProxyGroup %s: missing type", groupName) </s> remove // parse proxy group
</s> add // keep the origional order of ProxyGroups in config file
for idx, mapping := range groupsConfig {
groupName, existName := mapping["name"].(string)
if !existName {
return nil, fmt.Errorf("ProxyGroup %d: missing name", idx)
}
proxyList = append(proxyList, groupName)
}
// check if any loop exists and sort the ProxyGroups </s> remove // record original order in config file.
// this field can be used determinate the display order in FrontEnd.
mapping["configIdx"] = idx
</s> add </s> remove proxyList = append(proxyList, groupName)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d51877fcdab1392c4dedfce0fabfb494998d6cb | config/config.go |
groupName, _ := mapping["name"].(string)
if !existType {
return nil, fmt.Errorf("ProxyGroup %s: missing type", groupName) | <mask> return nil, err
<mask> }
<mask> for idx, mapping := range groupsConfig {
<mask> groupType, existType := mapping["type"].(string)
<mask> groupName, existName := mapping["name"].(string)
<mask> if !(existType && existName) {
<mask> return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
<mask> }
<mask>
<mask> if _, exist := proxies[groupName]; exist {
<mask> return nil, fmt.Errorf("ProxyGroup %s: the duplicate name", groupName)
<mask> }
</s> Fix: should keep the original order of proxy groups (#284) </s> remove for idx, mapping := range groupsConfig {
</s> add // parse proxy group
for _, mapping := range groupsConfig { </s> remove // parse proxy group
</s> add // keep the origional order of ProxyGroups in config file
for idx, mapping := range groupsConfig {
groupName, existName := mapping["name"].(string)
if !existName {
return nil, fmt.Errorf("ProxyGroup %d: missing name", idx)
}
proxyList = append(proxyList, groupName)
}
// check if any loop exists and sort the ProxyGroups </s> remove proxyList = append(proxyList, groupName)
</s> add </s> remove // record original order in config file.
// this field can be used determinate the display order in FrontEnd.
mapping["configIdx"] = idx
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d51877fcdab1392c4dedfce0fabfb494998d6cb | config/config.go |
<mask> if err != nil {
<mask> return nil, fmt.Errorf("Proxy %s: %s", groupName, err.Error())
<mask> }
<mask> proxies[groupName] = adapters.NewProxy(group)
<mask> proxyList = append(proxyList, groupName)
<mask> }
<mask>
<mask> ps := []C.Proxy{}
<mask> for _, v := range proxyList {
<mask> ps = append(ps, proxies[v])
</s> Fix: should keep the original order of proxy groups (#284) </s> remove // parse proxy group
</s> add // keep the origional order of ProxyGroups in config file
for idx, mapping := range groupsConfig {
groupName, existName := mapping["name"].(string)
if !existName {
return nil, fmt.Errorf("ProxyGroup %d: missing name", idx)
}
proxyList = append(proxyList, groupName)
}
// check if any loop exists and sort the ProxyGroups </s> remove groupName, existName := mapping["name"].(string)
if !(existType && existName) {
return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
</s> add groupName, _ := mapping["name"].(string)
if !existType {
return nil, fmt.Errorf("ProxyGroup %s: missing type", groupName) </s> remove for idx, mapping := range groupsConfig {
</s> add // parse proxy group
for _, mapping := range groupsConfig { </s> remove // record original order in config file.
// this field can be used determinate the display order in FrontEnd.
mapping["configIdx"] = idx
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d51877fcdab1392c4dedfce0fabfb494998d6cb | config/config.go | |
<mask> graph := make(map[string]*Node)
<mask>
<mask> // Step 1.1 build dependency graph
<mask> for idx, mapping := range groupsConfig {
<mask> // record original order in config file.
<mask> // this field can be used determinate the display order in FrontEnd.
<mask> mapping["configIdx"] = idx
<mask> groupName, existName := mapping["name"].(string)
<mask> if !existName {
<mask> return fmt.Errorf("ProxyGroup %d: missing name", idx)
<mask> }
<mask> if node, ok := graph[groupName]; ok {
</s> Fix: should keep the original order of proxy groups (#284) </s> remove // parse proxy group
</s> add // keep the origional order of ProxyGroups in config file
for idx, mapping := range groupsConfig {
groupName, existName := mapping["name"].(string)
if !existName {
return nil, fmt.Errorf("ProxyGroup %d: missing name", idx)
}
proxyList = append(proxyList, groupName)
}
// check if any loop exists and sort the ProxyGroups </s> remove for idx, mapping := range groupsConfig {
</s> add // parse proxy group
for _, mapping := range groupsConfig { </s> remove groupName, existName := mapping["name"].(string)
if !(existType && existName) {
return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
</s> add groupName, _ := mapping["name"].(string)
if !existType {
return nil, fmt.Errorf("ProxyGroup %s: missing type", groupName) </s> remove proxyList = append(proxyList, groupName)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0d51877fcdab1392c4dedfce0fabfb494998d6cb | config/utils.go | |
<mask> package outbound
<mask>
<mask> import (
<mask> "context"
<mask> "errors"
<mask> "io"
<mask> "net"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/component/dialer"
</s> Change: use nop packet conn for reject </s> remove // SetWriteDeadline is fake function for net.Conn
func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> add 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> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go | |
return NewConn(&nopConn{}, r), nil | <mask> }
<mask>
<mask> // DialContext implements C.ProxyAdapter
<mask> func (r *Reject) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
<mask> return NewConn(&NopConn{}, 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 nil, errors.New("match reject rule")
</s> Change: use nop packet conn for reject </s> remove return nil, errors.New("match reject rule")
</s> add return newPacketConn(newNopPacketConn(), r), nil </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove func (rw *NopConn) Write(b []byte) (int, error) {
</s> add func (rw *nopConn) Write(b []byte) (int, error) { </s> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
return newPacketConn(newNopPacketConn(), 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 nil, errors.New("match reject rule")
<mask> }
<mask>
<mask> func NewReject() *Reject {
<mask> return &Reject{
<mask> Base: &Base{
</s> Change: use nop packet conn for reject </s> remove return NewConn(&NopConn{}, r), nil
</s> add return NewConn(&nopConn{}, r), nil </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove func (rw *NopConn) Write(b []byte) (int, error) {
</s> add func (rw *nopConn) Write(b []byte) (int, error) { </s> remove // SetWriteDeadline is fake function for net.Conn
func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> add 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{}),
}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
type nopConn struct{} | <mask> },
<mask> }
<mask> }
<mask>
<mask> type NopConn struct{}
<mask>
<mask> func (rw *NopConn) Read(b []byte) (int, error) {
<mask> return 0, io.EOF
<mask> }
<mask>
</s> Change: use nop packet conn for reject </s> remove func (rw *NopConn) Read(b []byte) (int, error) {
</s> add func (rw *nopConn) Read(b []byte) (int, error) { </s> remove func (rw *NopConn) Write(b []byte) (int, error) {
</s> add func (rw *nopConn) Write(b []byte) (int, error) { </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
func (rw *nopConn) Read(b []byte) (int, error) { | <mask> }
<mask>
<mask> type NopConn struct{}
<mask>
<mask> func (rw *NopConn) Read(b []byte) (int, error) {
<mask> return 0, io.EOF
<mask> }
<mask>
<mask> func (rw *NopConn) Write(b []byte) (int, error) {
<mask> return 0, io.EOF
</s> Change: use nop packet conn for reject </s> remove type NopConn struct{}
</s> add type nopConn struct{} </s> remove func (rw *NopConn) Write(b []byte) (int, error) {
</s> add func (rw *nopConn) Write(b []byte) (int, error) { </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
func (rw *nopConn) Write(b []byte) (int, error) { | <mask> func (rw *NopConn) Read(b []byte) (int, error) {
<mask> return 0, io.EOF
<mask> }
<mask>
<mask> func (rw *NopConn) Write(b []byte) (int, error) {
<mask> return 0, io.EOF
<mask> }
<mask>
<mask> // Close is fake function for net.Conn
<mask> func (rw *NopConn) Close() error { return nil }
</s> Change: use nop packet conn for reject </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove func (rw *NopConn) Read(b []byte) (int, error) {
</s> add func (rw *nopConn) Read(b []byte) (int, error) { </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} </s> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } | <mask> func (rw *NopConn) Write(b []byte) (int, error) {
<mask> return 0, io.EOF
<mask> }
<mask>
<mask> // Close is fake function for net.Conn
<mask> func (rw *NopConn) Close() error { return nil }
<mask>
<mask> // LocalAddr is fake function for net.Conn
<mask> func (rw *NopConn) LocalAddr() net.Addr { return nil }
<mask>
<mask> // RemoteAddr is fake function for net.Conn
</s> Change: use nop packet conn for reject </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} </s> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} </s> remove func (rw *NopConn) Write(b []byte) (int, error) {
</s> add func (rw *nopConn) Write(b []byte) (int, error) { </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
type nopPacketConn struct {
ch chan struct{}
} | <mask>
<mask> // Close is fake function for net.Conn
<mask> func (rw *NopConn) Close() error { return nil }
<mask>
<mask> // LocalAddr is fake function for net.Conn
<mask> func (rw *NopConn) LocalAddr() net.Addr { return nil }
<mask>
<mask> // RemoteAddr is fake function for net.Conn
<mask> func (rw *NopConn) RemoteAddr() net.Addr { return nil }
<mask>
<mask> // SetDeadline is fake function for net.Conn
</s> Change: use nop packet conn for reject </s> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} </s> remove // SetWriteDeadline is fake function for net.Conn
func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> add 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{}),
}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} | <mask>
<mask> // LocalAddr is fake function for net.Conn
<mask> func (rw *NopConn) LocalAddr() net.Addr { return nil }
<mask>
<mask> // RemoteAddr is fake function for net.Conn
<mask> func (rw *NopConn) RemoteAddr() net.Addr { return nil }
<mask>
<mask> // SetDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetDeadline(time.Time) error { return nil }
<mask>
<mask> // SetReadDeadline is fake function for net.Conn
</s> Change: use nop packet conn for reject </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} </s> remove // SetWriteDeadline is fake function for net.Conn
func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> add 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{}),
}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} | <mask>
<mask> // RemoteAddr is fake function for net.Conn
<mask> func (rw *NopConn) RemoteAddr() net.Addr { return nil }
<mask>
<mask> // SetDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetDeadline(time.Time) error { return nil }
<mask>
<mask> // SetReadDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
<mask>
<mask> // SetWriteDeadline is fake function for net.Conn
</s> Change: use nop packet conn for reject </s> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} </s> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // SetWriteDeadline is fake function for net.Conn
func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> add 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{}),
}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} | <mask>
<mask> // SetDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetDeadline(time.Time) error { return nil }
<mask>
<mask> // SetReadDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
<mask>
<mask> // SetWriteDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> Change: use nop packet conn for reject </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // SetWriteDeadline is fake function for net.Conn
func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> add 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> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
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{}),
}
} | <mask>
<mask> // SetReadDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
<mask>
<mask> // SetWriteDeadline is fake function for net.Conn
<mask> func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }
</s> Change: use nop packet conn for reject </s> remove // SetReadDeadline is fake function for net.Conn
func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) Close() error {
close(npc.ch)
return nil
} </s> remove // SetDeadline is fake function for net.Conn
func (rw *NopConn) SetDeadline(time.Time) error { return nil }
</s> add func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<-npc.ch
return 0, nil, io.EOF
} </s> remove // Close is fake function for net.Conn
func (rw *NopConn) Close() error { return nil }
</s> add func (rw *nopConn) Close() error { return nil }
func (rw *nopConn) LocalAddr() net.Addr { return nil }
func (rw *nopConn) RemoteAddr() net.Addr { return nil }
func (rw *nopConn) SetDeadline(time.Time) error { return nil }
func (rw *nopConn) SetReadDeadline(time.Time) error { return nil }
func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil } </s> remove // RemoteAddr is fake function for net.Conn
func (rw *NopConn) RemoteAddr() net.Addr { return nil }
</s> add func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return len(b), nil
} </s> remove // LocalAddr is fake function for net.Conn
func (rw *NopConn) LocalAddr() net.Addr { return nil }
</s> add type nopPacketConn struct {
ch chan struct{}
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace"
] | https://github.com/Dreamacro/clash/commit/0db15d46c3067baad712ae3b7d9b4c7a7a3c4206 | adapter/outbound/reject.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.