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 |
|---|---|---|---|---|
if groupOption.Type == "select" || groupOption.Type == "relay" { | <mask>
<mask> providers = append(providers, pd)
<mask> } else {
<mask> // select don't need health check
<mask> if groupOption.Type == "select" {
<mask> hc := provider.NewHealthCheck(ps, "", 0)
<mask> pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Feature: support relay (proxy chains) (#539) </s> remove if err := h.shakeHand(metadata, c); err != nil {
</s> add c, err = h.StreamConn(c, metadata)
if err != nil { </s> remove return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %w", server, err)
</s> add return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %w", addr, err) </s> remove addr, err := resolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.addr) </s> remove c, err = v.client.New(c, parseVmessAddr(metadata))
return newConn(c, v), err
</s> add c, err = v.StreamConn(c, metadata)
return NewConn(c, v), err </s> remove return newConn(c, d), nil
</s> add return NewConn(c, d), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | adapters/outboundgroup/parser.go |
case "relay":
group = NewRelay(groupName, providers) | <mask> group = NewFallback(groupName, providers)
<mask> case "load-balance":
<mask> group = NewLoadBalance(groupName, providers)
<mask> default:
<mask> return nil, fmt.Errorf("%w: %s", errType, groupOption.Type)
<mask> }
<mask>
<mask> return group, nil
</s> Feature: support relay (proxy chains) (#539) </s> remove return nil, fmt.Errorf("snell %s obfs mode error: %s", server, obfsOption.Mode)
</s> add return nil, fmt.Errorf("snell %s obfs mode error: %s", addr, obfsOption.Mode) </s> remove return nil, fmt.Errorf("ss %s obfs mode error: %s", server, opts.Mode)
</s> add return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode) </s> remove return nil, fmt.Errorf("%s connect error: %w", ss.server, err)
</s> add return nil, fmt.Errorf("%s connect error: %w", ss.addr, err) </s> remove return nil, fmt.Errorf("ss %s obfs mode error: %s", server, opts.Mode)
</s> add return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | adapters/outboundgroup/parser.go |
Base: outbound.NewBase(name, "", C.Selector, false), | <mask>
<mask> func NewSelector(name string, providers []provider.ProxyProvider) *Selector {
<mask> selected := providers[0].Proxies()[0]
<mask> return &Selector{
<mask> Base: outbound.NewBase(name, C.Selector, false),
<mask> single: singledo.NewSingle(defaultGetProxiesDuration),
<mask> providers: providers,
<mask> selected: selected,
<mask> }
<mask> }
</s> Feature: support relay (proxy chains) (#539) </s> remove Base: outbound.NewBase(name, C.Fallback, false),
</s> add Base: outbound.NewBase(name, "", C.Fallback, false), </s> remove Base: outbound.NewBase(name, C.LoadBalance, false),
</s> add Base: outbound.NewBase(name, "", C.LoadBalance, false), </s> remove Base: outbound.NewBase(name, C.URLTest, false),
</s> add Base: outbound.NewBase(name, "", C.URLTest, false), </s> remove func NewBase(name string, tp C.AdapterType, udp bool) *Base {
return &Base{name, tp, udp}
</s> add func (b *Base) Addr() string {
return b.addr
}
func NewBase(name string, addr string, tp C.AdapterType, udp bool) *Base {
return &Base{name, addr, tp, udp} </s> remove if groupOption.Type == "select" {
</s> add if groupOption.Type == "select" || groupOption.Type == "relay" { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | adapters/outboundgroup/selector.go |
Base: outbound.NewBase(name, "", C.URLTest, false), | <mask> }
<mask>
<mask> func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
<mask> return &URLTest{
<mask> Base: outbound.NewBase(name, C.URLTest, false),
<mask> single: singledo.NewSingle(defaultGetProxiesDuration),
<mask> fastSingle: singledo.NewSingle(time.Second * 10),
<mask> providers: providers,
<mask> }
<mask> }
</s> Feature: support relay (proxy chains) (#539) </s> remove Base: outbound.NewBase(name, C.Fallback, false),
</s> add Base: outbound.NewBase(name, "", C.Fallback, false), </s> remove Base: outbound.NewBase(name, C.LoadBalance, false),
</s> add Base: outbound.NewBase(name, "", C.LoadBalance, false), </s> remove Base: outbound.NewBase(name, C.Selector, false),
</s> add Base: outbound.NewBase(name, "", C.Selector, false), </s> remove func NewBase(name string, tp C.AdapterType, udp bool) *Base {
return &Base{name, tp, udp}
</s> add func (b *Base) Addr() string {
return b.addr
}
func NewBase(name string, addr string, tp C.AdapterType, udp bool) *Base {
return &Base{name, addr, tp, udp} </s> remove if groupOption.Type == "select" {
</s> add if groupOption.Type == "select" || groupOption.Type == "relay" { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | adapters/outboundgroup/urltest.go |
Relay | <mask> Vmess
<mask> Trojan
<mask>
<mask> Selector
<mask> Fallback
<mask> URLTest
<mask> LoadBalance
</s> Feature: support relay (proxy chains) (#539) </s> remove server string
</s> add </s> remove server string
</s> add </s> remove addr, err := resolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.addr) </s> remove server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
</s> add addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port)) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | constant/adapters.go |
StreamConn(c net.Conn, metadata *Metadata) (net.Conn, error) | <mask> Name() string
<mask> Type() AdapterType
<mask> DialContext(ctx context.Context, metadata *Metadata) (Conn, error)
<mask> DialUDP(metadata *Metadata) (PacketConn, error)
<mask> SupportUDP() bool
<mask> MarshalJSON() ([]byte, error)
</s> Feature: support relay (proxy chains) (#539) </s> remove return newConn(&NopConn{}, r), nil
</s> add return NewConn(&NopConn{}, r), nil </s> remove func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
c, err := dialer.DialContext(ctx, "tcp", ss.addr)
if err == nil && ss.tls {
</s> add func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
if ss.tls { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | constant/adapters.go |
Addr() string | <mask> SupportUDP() bool
<mask> MarshalJSON() ([]byte, error)
<mask> }
<mask>
<mask> type DelayHistory struct {
<mask> Time time.Time `json:"time"`
</s> Feature: support relay (proxy chains) (#539) </s> remove server string
</s> add </s> remove server string
</s> add </s> remove server string
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | constant/adapters.go |
case Relay:
return "Relay" | <mask> return "Trojan"
<mask>
<mask> case Selector:
<mask> return "Selector"
<mask> case Fallback:
<mask> return "Fallback"
<mask> case URLTest:
<mask> return "URLTest"
</s> Feature: support relay (proxy chains) (#539) </s> remove return nil, fmt.Errorf("%s connect error: %w", ss.server, err)
</s> add return nil, fmt.Errorf("%s connect error: %w", ss.addr, err) </s> remove _, port, _ := net.SplitHostPort(ss.server)
</s> add _, port, _ := net.SplitHostPort(ss.addr) </s> remove func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
c, err := dialer.DialContext(ctx, "tcp", ss.server)
if err != nil {
return nil, fmt.Errorf("%s connect error: %w", ss.server, err)
}
tcpKeepAlive(c)
</s> add func (ss *ShadowSocks) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) { </s> remove func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
c, err := dialer.DialContext(ctx, "tcp", s.server)
if err != nil {
return nil, fmt.Errorf("%s connect error: %w", s.server, err)
}
tcpKeepAlive(c)
</s> add func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c0a2473160f9da2ea2116358fed33a3e6a77ae5a | constant/adapters.go |
// parse with specific interface
// .e.g 10.0.0.1#en0
interfaceName := u.Fragment
| <mask> }
<mask>
<mask> var addr, dnsNetType string
<mask> switch u.Scheme {
<mask> case "udp":
<mask> addr, err = hostWithDefaultPort(u.Host, "53")
<mask> dnsNetType = "" // UDP
<mask> case "tcp":
</s> Feature: can set custom interface for dns nameserver (#2126) </s> remove ret = append(ret, newDoHClient(s.Addr, resolver))
</s> add ret = append(ret, newDoHClient(s.Addr, s.Interface, resolver)) </s> remove Net: dnsNetType,
Addr: addr,
</s> add Net: dnsNetType,
Addr: addr,
Interface: interfaceName, </s> remove return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port))
</s> add options := []dialer.Option{}
if iface != "" {
options = append(options, dialer.WithInterface(iface))
}
return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port), options...) </s> remove func newDoHClient(url string, r *Resolver) *dohClient {
</s> add func newDoHClient(url, iface string, r *Resolver) *dohClient { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c1285adbf87b9a1745425b65404242d9bf1ec37f | config/config.go |
Net: dnsNetType,
Addr: addr,
Interface: interfaceName, | <mask>
<mask> nameservers = append(
<mask> nameservers,
<mask> dns.NameServer{
<mask> Net: dnsNetType,
<mask> Addr: addr,
<mask> },
<mask> )
<mask> }
<mask> return nameservers, nil
<mask> }
</s> Feature: can set custom interface for dns nameserver (#2126) </s> remove return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port))
</s> add options := []dialer.Option{}
if iface != "" {
options = append(options, dialer.WithInterface(iface))
}
return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port), options...) </s> remove func newDoHClient(url string, r *Resolver) *dohClient {
</s> add func newDoHClient(url, iface string, r *Resolver) *dohClient { </s> remove ret = append(ret, newDoHClient(s.Addr, resolver))
</s> add ret = append(ret, newDoHClient(s.Addr, s.Interface, resolver)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c1285adbf87b9a1745425b65404242d9bf1ec37f | config/config.go |
func newDoHClient(url, iface string, r *Resolver) *dohClient { | <mask> err = msg.Unpack(buf)
<mask> return msg, err
<mask> }
<mask>
<mask> func newDoHClient(url string, r *Resolver) *dohClient {
<mask> return &dohClient{
<mask> url: url,
<mask> transport: &http.Transport{
<mask> ForceAttemptHTTP2: true,
<mask> DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
</s> Feature: can set custom interface for dns nameserver (#2126) </s> remove return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port))
</s> add options := []dialer.Option{}
if iface != "" {
options = append(options, dialer.WithInterface(iface))
}
return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port), options...) </s> remove ret = append(ret, newDoHClient(s.Addr, resolver))
</s> add ret = append(ret, newDoHClient(s.Addr, s.Interface, resolver)) </s> remove Net: dnsNetType,
Addr: addr,
</s> add Net: dnsNetType,
Addr: addr,
Interface: interfaceName, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c1285adbf87b9a1745425b65404242d9bf1ec37f | dns/doh.go |
options := []dialer.Option{}
if iface != "" {
options = append(options, dialer.WithInterface(iface))
}
return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port), options...) | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port))
<mask> },
<mask> },
<mask> }
<mask> }
</s> Feature: can set custom interface for dns nameserver (#2126) </s> remove Net: dnsNetType,
Addr: addr,
</s> add Net: dnsNetType,
Addr: addr,
Interface: interfaceName, </s> remove func newDoHClient(url string, r *Resolver) *dohClient {
</s> add func newDoHClient(url, iface string, r *Resolver) *dohClient { </s> remove ret = append(ret, newDoHClient(s.Addr, resolver))
</s> add ret = append(ret, newDoHClient(s.Addr, s.Interface, resolver)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c1285adbf87b9a1745425b65404242d9bf1ec37f | dns/doh.go |
ret = append(ret, newDoHClient(s.Addr, s.Interface, resolver)) | <mask> ret := []dnsClient{}
<mask> for _, s := range servers {
<mask> switch s.Net {
<mask> case "https":
<mask> ret = append(ret, newDoHClient(s.Addr, resolver))
<mask> continue
<mask> case "dhcp":
<mask> ret = append(ret, newDHCPClient(s.Addr))
<mask> continue
<mask> }
</s> Feature: can set custom interface for dns nameserver (#2126) </s> remove return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port))
</s> add options := []dialer.Option{}
if iface != "" {
options = append(options, dialer.WithInterface(iface))
}
return dialer.DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port), options...) </s> remove func newDoHClient(url string, r *Resolver) *dohClient {
</s> add func newDoHClient(url, iface string, r *Resolver) *dohClient { </s> remove Net: dnsNetType,
Addr: addr,
</s> add Net: dnsNetType,
Addr: addr,
Interface: interfaceName, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c1285adbf87b9a1745425b65404242d9bf1ec37f | dns/util.go |
GOOS=darwin golangci-lint run ./...
GOOS=windows golangci-lint run ./...
GOOS=linux golangci-lint run ./...
GOOS=freebsd golangci-lint run ./...
GOOS=openbsd golangci-lint run ./... | <mask>
<mask> releases: $(gz_releases) $(zip_releases)
<mask>
<mask> lint:
<mask> golangci-lint run ./...
<mask>
<mask> clean:
<mask> rm $(BINDIR)/*
</s> Fix: make golangci lint support multi GOOS </s> remove r1, _, err := syscall.Syscall6(
</s> add r1, _, err := syscall.SyscallN( </s> remove err, _, _ := syscall.Syscall6(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0)
</s> add err, _, _ := syscall.SyscallN(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c282d662ca78e4044bb7b2af44f37ed58bdcd9bc | Makefile |
err, _, _ := syscall.SyscallN(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0) | <mask>
<mask> func getTransportTable(fn uintptr, family int, class int) ([]byte, error) {
<mask> for size, buf := uint32(8), make([]byte, 8); ; {
<mask> ptr := unsafe.Pointer(&buf[0])
<mask> err, _, _ := syscall.Syscall6(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0)
<mask>
<mask> switch err {
<mask> case 0:
<mask> return buf, nil
<mask> case uintptr(syscall.ERROR_INSUFFICIENT_BUFFER):
</s> Fix: make golangci lint support multi GOOS </s> remove r1, _, err := syscall.Syscall6(
</s> add r1, _, err := syscall.SyscallN( </s> remove golangci-lint run ./...
</s> add GOOS=darwin golangci-lint run ./...
GOOS=windows golangci-lint run ./...
GOOS=linux golangci-lint run ./...
GOOS=freebsd golangci-lint run ./...
GOOS=openbsd golangci-lint run ./... | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c282d662ca78e4044bb7b2af44f37ed58bdcd9bc | component/process/process_windows.go |
r1, _, err := syscall.SyscallN( | <mask> defer windows.CloseHandle(h)
<mask>
<mask> buf := make([]uint16, syscall.MAX_LONG_PATH)
<mask> size := uint32(len(buf))
<mask> r1, _, err := syscall.Syscall6(
<mask> queryProcName, 4,
<mask> uintptr(h),
<mask> uintptr(1),
<mask> uintptr(unsafe.Pointer(&buf[0])),
<mask> uintptr(unsafe.Pointer(&size)),
</s> Fix: make golangci lint support multi GOOS </s> remove err, _, _ := syscall.Syscall6(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0)
</s> add err, _, _ := syscall.SyscallN(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0) </s> remove golangci-lint run ./...
</s> add GOOS=darwin golangci-lint run ./...
GOOS=windows golangci-lint run ./...
GOOS=linux golangci-lint run ./...
GOOS=freebsd golangci-lint run ./...
GOOS=openbsd golangci-lint run ./... | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c282d662ca78e4044bb7b2af44f37ed58bdcd9bc | component/process/process_windows.go |
done chan struct{} | <mask> rawURL string
<mask> addr *C.Addr
<mask> fast C.Proxy
<mask> delay time.Duration
<mask> }
<mask>
<mask> func (u *URLTest) Name() string {
<mask> return u.name
</s> Fixed: the configuration can now be updated correctly </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) </s> remove for range tick {
go u.speedTest()
</s> add Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} </s> remove // clear proxys and rules
</s> add // empty proxys and rules | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | adapters/urltest.go |
func (u *URLTest) Close() {
u.done <- struct{}{}
}
| <mask> }
<mask>
<mask> func (u *URLTest) loop() {
<mask> tick := time.NewTicker(u.delay)
<mask> go u.speedTest()
<mask> Loop:
</s> Fixed: the configuration can now be updated correctly </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) </s> remove for range tick {
go u.speedTest()
</s> add Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} </s> remove // init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | adapters/urltest.go |
tick := time.NewTicker(u.delay) | <mask> return u.fast.Generator(addr)
<mask> }
<mask>
<mask> func (u *URLTest) loop() {
<mask> tick := time.Tick(u.delay)
<mask> go u.speedTest()
<mask> for range tick {
<mask> go u.speedTest()
<mask> }
<mask> }
</s> Fixed: the configuration can now be updated correctly </s> remove for range tick {
go u.speedTest()
</s> add Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} </s> remove // init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | adapters/urltest.go |
Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} | <mask>
<mask> func (u *URLTest) loop() {
<mask> tick := time.Tick(u.delay)
<mask> go u.speedTest()
<mask> for range tick {
<mask> go u.speedTest()
<mask> }
<mask> }
<mask>
<mask> func (u *URLTest) speedTest() {
<mask> wg := sync.WaitGroup{}
</s> Fixed: the configuration can now be updated correctly </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) </s> remove // init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | adapters/urltest.go |
done: make(chan struct{}), | <mask> url: u,
<mask> addr: addr,
<mask> fast: proxys[0],
<mask> delay: delay,
<mask> }
<mask> go urlTest.loop()
<mask> return urlTest, nil
<mask> }
</s> Fixed: the configuration can now be updated correctly </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) </s> remove // clear proxys and rules
</s> add // empty proxys and rules </s> remove for range tick {
go u.speedTest()
</s> add Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | adapters/urltest.go |
// empty proxys and rules | <mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> // clear proxys and rules
<mask> proxys := make(map[string]C.Proxy)
<mask> rules := []C.Rule{}
<mask>
<mask> proxysConfig := cfg.Section("Proxy")
<mask> rulesConfig := cfg.Section("Rule")
</s> Fixed: the configuration can now be updated correctly </s> remove // init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
</s> add </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) </s> remove for range tick {
go u.speedTest()
</s> add Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | tunnel/tunnel.go |
<mask> proxys[key.Name()] = ss
<mask> }
<mask> }
<mask>
<mask> // init proxy
<mask> proxys["DIRECT"] = adapters.NewDirect(t.traffic)
<mask> proxys["REJECT"] = adapters.NewReject()
<mask>
<mask> // parse rules
<mask> for _, key := range rulesConfig.Keys() {
<mask> rule := strings.Split(key.Name(), ",")
<mask> if len(rule) < 3 {
<mask> continue
</s> Fixed: the configuration can now be updated correctly </s> remove // clear proxys and rules
</s> add // empty proxys and rules </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) </s> remove for range tick {
go u.speedTest()
</s> add Loop:
for {
select {
case <-tick.C:
go u.speedTest()
case <-u.done:
break Loop
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | tunnel/tunnel.go | |
// init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
| <mask> }
<mask>
<mask> t.configLock.Lock()
<mask> defer t.configLock.Unlock()
<mask>
<mask> // stop url-test
</s> Fixed: the configuration can now be updated correctly </s> remove // init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
</s> add </s> remove // clear proxys and rules
</s> add // empty proxys and rules </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | tunnel/tunnel.go |
// stop url-test
for _, elm := range t.proxys {
urlTest, ok := elm.(*adapters.URLTest)
if ok {
urlTest.Close()
}
}
| <mask>
<mask> t.configLock.Lock()
<mask> defer t.configLock.Unlock()
<mask>
<mask> t.proxys = proxys
<mask> t.rules = rules
<mask>
<mask> return nil
<mask> }
<mask>
</s> Fixed: the configuration can now be updated correctly </s> remove // clear proxys and rules
</s> add // empty proxys and rules </s> remove // init proxy
proxys["DIRECT"] = adapters.NewDirect(t.traffic)
proxys["REJECT"] = adapters.NewReject()
</s> add </s> remove tick := time.Tick(u.delay)
</s> add tick := time.NewTicker(u.delay) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c2c8f82f96d405656fb16ec392194598eb40c0aa | tunnel/tunnel.go |
<mask> package process
<mask>
<mask> import (
<mask> "bytes"
<mask> "encoding/binary"
<mask> "net"
<mask> "path/filepath"
<mask> "syscall"
<mask> "unsafe"
</s> Chore: use unix.ByteSliceToString transform cstring </s> remove return filepath.Base(string(buf[:firstZero])), nil
</s> add return filepath.Base(unix.ByteSliceToString(buf)), nil </s> remove firstZero := bytes.IndexByte(buf, 0)
if firstZero <= 0 {
return "", nil
}
</s> add | [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c35cb24bdacf66cd65af508f48323a647882ef08 | component/process/process_darwin.go | |
"golang.org/x/sys/unix" | <mask> "net"
<mask> "path/filepath"
<mask> "syscall"
<mask> "unsafe"
<mask> )
<mask>
<mask> const (
<mask> procpidpathinfo = 0xb
<mask> procpidpathinfosize = 1024
<mask> proccallnumpidinfo = 0x2
</s> Chore: use unix.ByteSliceToString transform cstring </s> remove return filepath.Base(string(buf[:firstZero])), nil
</s> add return filepath.Base(unix.ByteSliceToString(buf)), nil </s> remove firstZero := bytes.IndexByte(buf, 0)
if firstZero <= 0 {
return "", nil
}
</s> add </s> remove "bytes"
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c35cb24bdacf66cd65af508f48323a647882ef08 | component/process/process_darwin.go |
<mask> procpidpathinfosize)
<mask> if errno != 0 {
<mask> return "", errno
<mask> }
<mask> firstZero := bytes.IndexByte(buf, 0)
<mask> if firstZero <= 0 {
<mask> return "", nil
<mask> }
<mask>
<mask> return filepath.Base(string(buf[:firstZero])), nil
<mask> }
<mask>
<mask> func readNativeUint32(b []byte) uint32 {
</s> Chore: use unix.ByteSliceToString transform cstring </s> remove return filepath.Base(string(buf[:firstZero])), nil
</s> add return filepath.Base(unix.ByteSliceToString(buf)), nil </s> remove "bytes"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c35cb24bdacf66cd65af508f48323a647882ef08 | component/process/process_darwin.go | |
return filepath.Base(unix.ByteSliceToString(buf)), nil | <mask> if firstZero <= 0 {
<mask> return "", nil
<mask> }
<mask>
<mask> return filepath.Base(string(buf[:firstZero])), nil
<mask> }
<mask>
<mask> func readNativeUint32(b []byte) uint32 {
<mask> return *(*uint32)(unsafe.Pointer(&b[0]))
<mask> }
</s> Chore: use unix.ByteSliceToString transform cstring </s> remove firstZero := bytes.IndexByte(buf, 0)
if firstZero <= 0 {
return "", nil
}
</s> add </s> remove "bytes"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c35cb24bdacf66cd65af508f48323a647882ef08 | component/process/process_darwin.go |
C "github.com/Dreamacro/clash/constant" | <mask> "context"
<mask> "net/http"
<mask>
<mask> "github.com/Dreamacro/clash/constant/provider"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/go-chi/chi/v5"
</s> Feature: add provider proxies API (#2668) </s> remove name := getEscapeParam(r, "name")
</s> add name := getEscapeParam(r, "providerName") </s> remove r.Route("/{name}", func(r chi.Router) {
</s> add r.Route("/{providerName}", func(r chi.Router) { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c5fe5235f784d073ed6f6756fee2a9c28dbe247f | hub/route/provider.go |
"github.com/samber/lo" | <mask> "github.com/go-chi/chi/v5"
<mask> "github.com/go-chi/render"
<mask> )
<mask>
<mask> func proxyProviderRouter() http.Handler {
<mask> r := chi.NewRouter()
</s> Feature: add provider proxies API (#2668) </s> remove r.Route("/{name}", func(r chi.Router) {
</s> add r.Route("/{providerName}", func(r chi.Router) { </s> remove name := getEscapeParam(r, "name")
</s> add name := getEscapeParam(r, "providerName") | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c5fe5235f784d073ed6f6756fee2a9c28dbe247f | hub/route/provider.go |
r.Route("/{providerName}", func(r chi.Router) { | <mask> func proxyProviderRouter() http.Handler {
<mask> r := chi.NewRouter()
<mask> r.Get("/", getProviders)
<mask>
<mask> r.Route("/{name}", func(r chi.Router) {
<mask> r.Use(parseProviderName, findProviderByName)
<mask> r.Get("/", getProvider)
<mask> r.Put("/", updateProvider)
<mask> r.Get("/healthcheck", healthCheckProvider)
<mask> })
</s> Feature: add provider proxies API (#2668) </s> remove name := getEscapeParam(r, "name")
</s> add name := getEscapeParam(r, "providerName") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c5fe5235f784d073ed6f6756fee2a9c28dbe247f | hub/route/provider.go |
r.Mount("/", proxyProviderProxyRouter())
})
return r
}
func proxyProviderProxyRouter() http.Handler {
r := chi.NewRouter()
r.Route("/{name}", func(r chi.Router) {
r.Use(parseProxyName, findProviderProxyByName)
r.Get("/", getProxy)
r.Get("/healthcheck", getProxyDelay) | <mask> r.Use(parseProviderName, findProviderByName)
<mask> r.Get("/", getProvider)
<mask> r.Put("/", updateProvider)
<mask> r.Get("/healthcheck", healthCheckProvider)
<mask> })
<mask> return r
<mask> }
<mask>
<mask> func getProviders(w http.ResponseWriter, r *http.Request) {
</s> Feature: add provider proxies API (#2668) </s> remove r.Route("/{name}", func(r chi.Router) {
</s> add r.Route("/{providerName}", func(r chi.Router) { </s> remove name := getEscapeParam(r, "name")
</s> add name := getEscapeParam(r, "providerName") | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c5fe5235f784d073ed6f6756fee2a9c28dbe247f | hub/route/provider.go |
name := getEscapeParam(r, "providerName") | <mask> }
<mask>
<mask> func parseProviderName(next http.Handler) http.Handler {
<mask> return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
<mask> name := getEscapeParam(r, "name")
<mask> ctx := context.WithValue(r.Context(), CtxKeyProviderName, name)
<mask> next.ServeHTTP(w, r.WithContext(ctx))
<mask> })
<mask> }
<mask>
</s> Feature: add provider proxies API (#2668) </s> remove r.Route("/{name}", func(r chi.Router) {
</s> add r.Route("/{providerName}", func(r chi.Router) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c5fe5235f784d073ed6f6756fee2a9c28dbe247f | hub/route/provider.go |
return r.fallbackExchange(m) | <mask>
<mask> ret, err, _ := r.group.Do(q.String(), func() (interface{}, error) {
<mask> isIPReq := isIPRequest(q)
<mask> if isIPReq {
<mask> msg, err := r.fallbackExchange(m)
<mask> return msg, err
<mask> }
<mask>
<mask> return r.batchExchange(r.main, m)
<mask> })
<mask>
</s> Fix: #563 and fallback error return </s> remove } else if m.Rcode == D.RcodeServerFailure {
</s> add } else if m.Rcode == D.RcodeServerFailure || m.Rcode == D.RcodeRefused { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c733f807939bd2cc2a5186836c93cd06a4dac220 | dns/resolver.go |
} else if m.Rcode == D.RcodeServerFailure || m.Rcode == D.RcodeRefused { | <mask> fast.Go(func() (interface{}, error) {
<mask> m, err := r.ExchangeContext(ctx, m)
<mask> if err != nil {
<mask> return nil, err
<mask> } else if m.Rcode == D.RcodeServerFailure {
<mask> return nil, errors.New("server failure")
<mask> }
<mask> return m, nil
<mask> })
<mask> }
</s> Fix: #563 and fallback error return </s> remove msg, err := r.fallbackExchange(m)
return msg, err
</s> add return r.fallbackExchange(m) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c733f807939bd2cc2a5186836c93cd06a4dac220 | dns/resolver.go |
err = res.Error | <mask> go func() { <-fallbackMsg }()
<mask> msg = res.Msg
<mask> return msg, err
<mask> }
<mask> }
<mask> }
</s> Fix: #563 and fallback error return </s> remove msg, err := r.fallbackExchange(m)
return msg, err
</s> add return r.fallbackExchange(m) </s> remove } else if m.Rcode == D.RcodeServerFailure {
</s> add } else if m.Rcode == D.RcodeServerFailure || m.Rcode == D.RcodeRefused { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c733f807939bd2cc2a5186836c93cd06a4dac220 | dns/resolver.go |
"strings"
| <mask>
<mask> import (
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type Domain struct {
</s> Improve: auto change payload to lowercase </s> remove suffix: suffix,
</s> add suffix: strings.ToLower(suffix), </s> remove keyword: keyword,
</s> add keyword: strings.ToLower(keyword), </s> remove domain: domain,
</s> add domain: strings.ToLower(domain), | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c7a349e1fe9c394a4b0a6a165d4a7d2eb72c8f3a | rules/domain.go |
domain: strings.ToLower(domain), | <mask> }
<mask>
<mask> func NewDomain(domain string, adapter string) *Domain {
<mask> return &Domain{
<mask> domain: domain,
<mask> adapter: adapter,
<mask> }
<mask> }
</s> Improve: auto change payload to lowercase </s> remove suffix: suffix,
</s> add suffix: strings.ToLower(suffix), </s> remove keyword: keyword,
</s> add keyword: strings.ToLower(keyword), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c7a349e1fe9c394a4b0a6a165d4a7d2eb72c8f3a | rules/domain.go |
keyword: strings.ToLower(keyword), | <mask> }
<mask>
<mask> func NewDomainKeyword(keyword string, adapter string) *DomainKeyword {
<mask> return &DomainKeyword{
<mask> keyword: keyword,
<mask> adapter: adapter,
<mask> }
<mask> }
</s> Improve: auto change payload to lowercase </s> remove suffix: suffix,
</s> add suffix: strings.ToLower(suffix), </s> remove domain: domain,
</s> add domain: strings.ToLower(domain), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c7a349e1fe9c394a4b0a6a165d4a7d2eb72c8f3a | rules/domain_keyword.go |
suffix: strings.ToLower(suffix), | <mask> }
<mask>
<mask> func NewDomainSuffix(suffix string, adapter string) *DomainSuffix {
<mask> return &DomainSuffix{
<mask> suffix: suffix,
<mask> adapter: adapter,
<mask> }
<mask> }
</s> Improve: auto change payload to lowercase </s> remove keyword: keyword,
</s> add keyword: strings.ToLower(keyword), </s> remove domain: domain,
</s> add domain: strings.ToLower(domain), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c7a349e1fe9c394a4b0a6a165d4a7d2eb72c8f3a | rules/domain_suffix.go |
response *http.Response
request *http.Request
transport *http2.Transport
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
// deadlines
deadline *time.Timer | <mask>
<mask> type DialFn = func(network, addr string) (net.Conn, error)
<mask>
<mask> type Conn struct {
<mask> response *http.Response
<mask> request *http.Request
<mask> client *http.Client
<mask> writer *io.PipeWriter
<mask> once sync.Once
<mask> close *atomic.Bool
<mask> err error
<mask> remain int
<mask> br *bufio.Reader
<mask> }
<mask>
<mask> type Config struct {
<mask> ServiceName string
<mask> Host string
</s> Fix: grpc implementation SetDeadline for udp issue </s> remove response, err := g.client.Do(g.request)
</s> add response, err := g.transport.RoundTrip(g.request) </s> remove client := &http.Client{
Transport: transport,
}
</s> add </s> remove func (g *Conn) SetDeadline(t time.Time) error { return nil }
func (g *Conn) SetReadDeadline(t time.Time) error { return nil }
func (g *Conn) SetWriteDeadline(t time.Time) error { return nil }
</s> add func (g *Conn) SetReadDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetDeadline(t time.Time) error {
d := time.Until(t)
if g.deadline != nil {
g.deadline.Reset(d)
return nil
}
g.deadline = time.AfterFunc(d, func() {
g.Close()
})
return nil
} </s> remove ReadIdleTimeout: 0,
</s> add </s> remove request: request,
client: client,
writer: writer,
close: atomic.NewBool(false),
</s> add request: request,
transport: transport,
writer: writer,
close: atomic.NewBool(false), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c9943fb8570b80a4067926489e513eec67b41184 | component/gun/gun.go |
response, err := g.transport.RoundTrip(g.request) | <mask> Host string
<mask> }
<mask>
<mask> func (g *Conn) initRequest() {
<mask> response, err := g.client.Do(g.request)
<mask> if err != nil {
<mask> g.err = err
<mask> g.writer.Close()
<mask> return
<mask> }
</s> Fix: grpc implementation SetDeadline for udp issue </s> remove func (g *Conn) SetDeadline(t time.Time) error { return nil }
func (g *Conn) SetReadDeadline(t time.Time) error { return nil }
func (g *Conn) SetWriteDeadline(t time.Time) error { return nil }
</s> add func (g *Conn) SetReadDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetDeadline(t time.Time) error {
d := time.Until(t)
if g.deadline != nil {
g.deadline.Reset(d)
return nil
}
g.deadline = time.AfterFunc(d, func() {
g.Close()
})
return nil
} </s> remove response *http.Response
request *http.Request
client *http.Client
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
</s> add response *http.Response
request *http.Request
transport *http2.Transport
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
// deadlines
deadline *time.Timer </s> remove client := &http.Client{
Transport: transport,
}
</s> add </s> remove ReadIdleTimeout: 0,
</s> add </s> remove request: request,
client: client,
writer: writer,
close: atomic.NewBool(false),
</s> add request: request,
transport: transport,
writer: writer,
close: atomic.NewBool(false), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c9943fb8570b80a4067926489e513eec67b41184 | component/gun/gun.go |
func (g *Conn) SetReadDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetDeadline(t time.Time) error {
d := time.Until(t)
if g.deadline != nil {
g.deadline.Reset(d)
return nil
}
g.deadline = time.AfterFunc(d, func() {
g.Close()
})
return nil
} | <mask> }
<mask>
<mask> func (g *Conn) LocalAddr() net.Addr { return &net.TCPAddr{IP: net.IPv4zero, Port: 0} }
<mask> func (g *Conn) RemoteAddr() net.Addr { return &net.TCPAddr{IP: net.IPv4zero, Port: 0} }
<mask> func (g *Conn) SetDeadline(t time.Time) error { return nil }
<mask> func (g *Conn) SetReadDeadline(t time.Time) error { return nil }
<mask> func (g *Conn) SetWriteDeadline(t time.Time) error { return nil }
<mask>
<mask> func NewHTTP2Client(dialFn DialFn, tlsConfig *tls.Config) *http2.Transport {
<mask> dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
<mask> pconn, err := dialFn(network, addr)
<mask> if err != nil {
</s> Fix: grpc implementation SetDeadline for udp issue </s> remove response, err := g.client.Do(g.request)
</s> add response, err := g.transport.RoundTrip(g.request) </s> remove response *http.Response
request *http.Request
client *http.Client
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
</s> add response *http.Response
request *http.Request
transport *http2.Transport
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
// deadlines
deadline *time.Timer </s> remove ReadIdleTimeout: 0,
</s> add </s> remove client := &http.Client{
Transport: transport,
}
</s> add </s> remove request: request,
client: client,
writer: writer,
close: atomic.NewBool(false),
</s> add request: request,
transport: transport,
writer: writer,
close: atomic.NewBool(false), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c9943fb8570b80a4067926489e513eec67b41184 | component/gun/gun.go |
<mask> DialTLS: dialFunc,
<mask> TLSClientConfig: tlsConfig,
<mask> AllowHTTP: false,
<mask> DisableCompression: true,
<mask> ReadIdleTimeout: 0,
<mask> PingTimeout: 0,
<mask> }
<mask> }
<mask>
<mask> func StreamGunWithTransport(transport *http2.Transport, cfg *Config) (net.Conn, error) {
</s> Fix: grpc implementation SetDeadline for udp issue </s> remove func (g *Conn) SetDeadline(t time.Time) error { return nil }
func (g *Conn) SetReadDeadline(t time.Time) error { return nil }
func (g *Conn) SetWriteDeadline(t time.Time) error { return nil }
</s> add func (g *Conn) SetReadDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetDeadline(t time.Time) error {
d := time.Until(t)
if g.deadline != nil {
g.deadline.Reset(d)
return nil
}
g.deadline = time.AfterFunc(d, func() {
g.Close()
})
return nil
} </s> remove response, err := g.client.Do(g.request)
</s> add response, err := g.transport.RoundTrip(g.request) </s> remove client := &http.Client{
Transport: transport,
}
</s> add </s> remove request: request,
client: client,
writer: writer,
close: atomic.NewBool(false),
</s> add request: request,
transport: transport,
writer: writer,
close: atomic.NewBool(false), </s> remove response *http.Response
request *http.Request
client *http.Client
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
</s> add response *http.Response
request *http.Request
transport *http2.Transport
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
// deadlines
deadline *time.Timer | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c9943fb8570b80a4067926489e513eec67b41184 | component/gun/gun.go | |
<mask> if cfg.ServiceName != "" {
<mask> serviceName = cfg.ServiceName
<mask> }
<mask>
<mask> client := &http.Client{
<mask> Transport: transport,
<mask> }
<mask>
<mask> reader, writer := io.Pipe()
<mask> request := &http.Request{
<mask> Method: http.MethodPost,
<mask> Body: reader,
<mask> URL: &url.URL{
</s> Fix: grpc implementation SetDeadline for udp issue </s> remove response *http.Response
request *http.Request
client *http.Client
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
</s> add response *http.Response
request *http.Request
transport *http2.Transport
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
// deadlines
deadline *time.Timer </s> remove response, err := g.client.Do(g.request)
</s> add response, err := g.transport.RoundTrip(g.request) </s> remove request: request,
client: client,
writer: writer,
close: atomic.NewBool(false),
</s> add request: request,
transport: transport,
writer: writer,
close: atomic.NewBool(false), </s> remove func (g *Conn) SetDeadline(t time.Time) error { return nil }
func (g *Conn) SetReadDeadline(t time.Time) error { return nil }
func (g *Conn) SetWriteDeadline(t time.Time) error { return nil }
</s> add func (g *Conn) SetReadDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetDeadline(t time.Time) error {
d := time.Until(t)
if g.deadline != nil {
g.deadline.Reset(d)
return nil
}
g.deadline = time.AfterFunc(d, func() {
g.Close()
})
return nil
} </s> remove ReadIdleTimeout: 0,
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c9943fb8570b80a4067926489e513eec67b41184 | component/gun/gun.go | |
request: request,
transport: transport,
writer: writer,
close: atomic.NewBool(false), | <mask> Header: defaultHeader,
<mask> }
<mask>
<mask> conn := &Conn{
<mask> request: request,
<mask> client: client,
<mask> writer: writer,
<mask> close: atomic.NewBool(false),
<mask> }
<mask>
<mask> go conn.once.Do(conn.initRequest)
<mask> return conn, nil
<mask> }
</s> Fix: grpc implementation SetDeadline for udp issue </s> remove client := &http.Client{
Transport: transport,
}
</s> add </s> remove func (g *Conn) SetDeadline(t time.Time) error { return nil }
func (g *Conn) SetReadDeadline(t time.Time) error { return nil }
func (g *Conn) SetWriteDeadline(t time.Time) error { return nil }
</s> add func (g *Conn) SetReadDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
func (g *Conn) SetDeadline(t time.Time) error {
d := time.Until(t)
if g.deadline != nil {
g.deadline.Reset(d)
return nil
}
g.deadline = time.AfterFunc(d, func() {
g.Close()
})
return nil
} </s> remove response, err := g.client.Do(g.request)
</s> add response, err := g.transport.RoundTrip(g.request) </s> remove ReadIdleTimeout: 0,
</s> add </s> remove response *http.Response
request *http.Request
client *http.Client
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
</s> add response *http.Response
request *http.Request
transport *http2.Transport
writer *io.PipeWriter
once sync.Once
close *atomic.Bool
err error
remain int
br *bufio.Reader
// deadlines
deadline *time.Timer | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/c9943fb8570b80a4067926489e513eec67b41184 | component/gun/gun.go |
log.SetLevel(general.LogLevel)
T.Instance().SetMode(general.Mode)
| <mask> T.Instance().UpdateRules(rules)
<mask> }
<mask>
<mask> func updateGeneral(general *config.General) {
<mask> allowLan := general.AllowLan
<mask>
<mask> P.SetAllowLan(allowLan)
<mask> if err := P.ReCreateHTTP(general.Port); err != nil {
</s> Feature: add silent info level </s> remove
log.SetLevel(general.LogLevel)
T.Instance().SetMode(general.Mode)
</s> add </s> remove log.Infof("SOCKS proxy listening at: %s", addr)
</s> add log.Infoln("SOCKS proxy listening at: %s", addr) </s> remove log.Infof("Redir proxy listening at: %s", addr)
</s> add log.Infoln("Redir proxy listening at: %s", addr) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | hub/executor/executor.go |
<mask>
<mask> if err := P.ReCreateRedir(general.RedirPort); err != nil {
<mask> log.Errorln("Start Redir server error: %s", err.Error())
<mask> }
<mask>
<mask> log.SetLevel(general.LogLevel)
<mask> T.Instance().SetMode(general.Mode)
<mask> }
</s> Feature: add silent info level </s> remove log.Infof("SOCKS proxy listening at: %s", addr)
</s> add log.Infoln("SOCKS proxy listening at: %s", addr) </s> remove log.Infof("Redir proxy listening at: %s", addr)
</s> add log.Infoln("Redir proxy listening at: %s", addr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | hub/executor/executor.go | |
"silent": SILENT, | <mask> "warning": WARNING,
<mask> "info": INFO,
<mask> "debug": DEBUG,
<mask> }
<mask> )
<mask>
<mask> const (
</s> Feature: add silent info level </s> remove log "github.com/sirupsen/logrus"
</s> add </s> remove
log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | log/level.go |
SILENT | <mask> INFO
<mask> WARNING
<mask> ERROR
<mask> )
<mask>
<mask> type LogLevel int
<mask>
<mask> // UnmarshalYAML unserialize Mode with yaml
</s> Feature: add silent info level </s> remove log "github.com/sirupsen/logrus"
</s> add </s> remove
log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | log/level.go |
case SILENT:
return "silent" | <mask> case DEBUG:
<mask> return "debug"
<mask> default:
<mask> return "unknow"
<mask> }
<mask> }
</s> Feature: add silent info level </s> remove
log.SetLevel(general.LogLevel)
T.Instance().SetMode(general.Mode)
</s> add </s> remove log.Infof("SOCKS proxy listening at: %s", addr)
</s> add log.Infoln("SOCKS proxy listening at: %s", addr) </s> remove log.Infof("Redir proxy listening at: %s", addr)
</s> add log.Infoln("Redir proxy listening at: %s", addr) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | log/level.go |
"github.com/Dreamacro/clash/log" | <mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask> )
<mask>
<mask> var (
</s> Feature: add silent info level </s> remove
log "github.com/sirupsen/logrus"
</s> add </s> remove log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | proxy/redir/tcp.go |
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> tun = tunnel.Instance()
<mask> )
</s> Feature: add silent info level </s> remove log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | proxy/redir/tcp.go | |
log.Infoln("Redir proxy listening at: %s", addr) | <mask> }
<mask> rl := &redirListener{l, addr, false}
<mask>
<mask> go func() {
<mask> log.Infof("Redir proxy listening at: %s", addr)
<mask> for {
<mask> c, err := l.Accept()
<mask> if err != nil {
<mask> if rl.closed {
<mask> break
</s> Feature: add silent info level </s> remove log.Infof("SOCKS proxy listening at: %s", addr)
</s> add log.Infoln("SOCKS proxy listening at: %s", addr) </s> remove
log.SetLevel(general.LogLevel)
T.Instance().SetMode(general.Mode)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | proxy/redir/tcp.go |
"github.com/Dreamacro/clash/log" | <mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/socks"
<mask> )
<mask>
</s> Feature: add silent info level </s> remove log "github.com/sirupsen/logrus"
</s> add </s> remove
log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | proxy/socks/tcp.go |
<mask> "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/socks"
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> var (
<mask> tun = tunnel.Instance()
<mask> )
</s> Feature: add silent info level </s> remove
log "github.com/sirupsen/logrus"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | proxy/socks/tcp.go | |
log.Infoln("SOCKS proxy listening at: %s", addr) | <mask> }
<mask>
<mask> sl := &sockListener{l, addr, false}
<mask> go func() {
<mask> log.Infof("SOCKS proxy listening at: %s", addr)
<mask> for {
<mask> c, err := l.Accept()
<mask> if err != nil {
<mask> if sl.closed {
<mask> break
</s> Feature: add silent info level </s> remove log.Infof("Redir proxy listening at: %s", addr)
</s> add log.Infoln("Redir proxy listening at: %s", addr) </s> remove
log.SetLevel(general.LogLevel)
T.Instance().SetMode(general.Mode)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ca6e67a3845f6a73dcf0ccd9e2d7f49388414614 | proxy/socks/tcp.go |
<mask> "crypto/tls"
<mask> "fmt"
<mask> "math/rand"
<mask> "net"
<mask> "net/url"
<mask> "runtime"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/gofrs/uuid"
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove "time"
</s> add </s> remove "github.com/gorilla/websocket"
</s> add </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go | |
<mask> "net"
<mask> "net/url"
<mask> "runtime"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/gofrs/uuid"
<mask> "github.com/gorilla/websocket"
<mask> )
<mask>
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove "net/url"
</s> add </s> remove "github.com/gorilla/websocket"
</s> add </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go | |
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/gofrs/uuid"
<mask> "github.com/gorilla/websocket"
<mask> )
<mask>
<mask> // Version of vmess
<mask> const Version byte = 1
<mask>
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove "time"
</s> add </s> remove "net/url"
</s> add </s> remove user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
websocket bool
websocketPath string
tlsConfig *tls.Config
</s> add user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
wsConfig *websocketConfig
tlsConfig *tls.Config | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go | |
user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
wsConfig *websocketConfig
tlsConfig *tls.Config | <mask> }
<mask>
<mask> // Client is vmess connection generator
<mask> type Client struct {
<mask> user []*ID
<mask> uuid *uuid.UUID
<mask> security Security
<mask> tls bool
<mask> host string
<mask> websocket bool
<mask> websocketPath string
<mask> tlsConfig *tls.Config
<mask> }
<mask>
<mask> // Config of vmess
<mask> type Config struct {
<mask> UUID string
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove "github.com/gorilla/websocket"
</s> add </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go |
var err error | <mask> // New return a Conn with net.Conn and DstAddr
<mask> func (c *Client) New(conn net.Conn, dst *DstAddr) (net.Conn, error) {
<mask> r := rand.Intn(len(c.user))
<mask> if c.wsConfig != nil {
<mask> conn, err = newWebsocketConn(conn, c.wsConfig)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err </s> remove
conn = newWebsocketConn(wsConn, conn.RemoteAddr())
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go |
if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) | <mask>
<mask> // New return a Conn with net.Conn and DstAddr
<mask> func (c *Client) New(conn net.Conn, dst *DstAddr) (net.Conn, error) {
<mask> r := rand.Intn(len(c.user))
<mask> if c.websocket {
<mask> dialer := &websocket.Dialer{
<mask> NetDial: func(network, addr string) (net.Conn, error) {
<mask> return conn, nil
<mask> },
<mask> ReadBufferSize: 4 * 1024,
<mask> WriteBufferSize: 4 * 1024,
<mask> HandshakeTimeout: time.Second * 8,
<mask> }
<mask> scheme := "ws"
<mask> if c.tls {
<mask> scheme = "wss"
<mask> dialer.TLSClientConfig = c.tlsConfig
<mask> }
<mask>
<mask> host, port, err := net.SplitHostPort(c.host)
<mask> if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
<mask> host = c.host
<mask> }
<mask>
<mask> uri := url.URL{
<mask> Scheme: scheme,
<mask> Host: host,
<mask> Path: c.websocketPath,
<mask> }
<mask>
<mask> wsConn, resp, err := dialer.Dial(uri.String(), nil)
<mask> if err != nil {
<mask> var reason string
<mask> if resp != nil {
<mask> reason = resp.Status
<mask> }
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err </s> remove
conn = newWebsocketConn(wsConn, conn.RemoteAddr())
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go |
return nil, err | <mask> }
<mask>
<mask> wsConn, resp, err := dialer.Dial(uri.String(), nil)
<mask> if err != nil {
<mask> var reason string
<mask> if resp != nil {
<mask> reason = resp.Status
<mask> }
<mask> return nil, fmt.Errorf("Dial %s error: %s", host, reason)
<mask> }
<mask>
<mask> conn = newWebsocketConn(wsConn, conn.RemoteAddr())
<mask> } else if c.tls {
<mask> conn = tls.Client(conn, c.tlsConfig)
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove
conn = newWebsocketConn(wsConn, conn.RemoteAddr())
</s> add </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go |
<mask> reason = resp.Status
<mask> }
<mask> return nil, fmt.Errorf("Dial %s error: %s", host, reason)
<mask> }
<mask>
<mask> conn = newWebsocketConn(wsConn, conn.RemoteAddr())
<mask> } else if c.tls {
<mask> conn = tls.Client(conn, c.tlsConfig)
<mask> }
<mask> return newConn(conn, c.user[r], dst, c.security), nil
<mask> }
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go | |
var wsConfig *websocketConfig
if config.NetWork == "ws" {
wsConfig = &websocketConfig{
host: config.Host,
path: config.WebSocketPath,
tls: config.TLS,
tlsConfig: tlsConfig,
}
}
| <mask> }
<mask> }
<mask>
<mask> return &Client{
<mask> user: newAlterIDs(newID(&uid), config.AlterID),
<mask> uuid: &uid,
<mask> security: security,
<mask> tls: config.TLS,
<mask> host: config.Host,
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove user: newAlterIDs(newID(&uid), config.AlterID),
uuid: &uid,
security: security,
tls: config.TLS,
host: config.Host,
websocket: config.NetWork == "ws",
websocketPath: config.WebSocketPath,
tlsConfig: tlsConfig,
</s> add user: newAlterIDs(newID(&uid), config.AlterID),
uuid: &uid,
security: security,
tls: config.TLS,
host: config.Host,
wsConfig: wsConfig,
tlsConfig: tlsConfig, </s> remove
conn = newWebsocketConn(wsConn, conn.RemoteAddr())
</s> add </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go |
user: newAlterIDs(newID(&uid), config.AlterID),
uuid: &uid,
security: security,
tls: config.TLS,
host: config.Host,
wsConfig: wsConfig,
tlsConfig: tlsConfig, | <mask> }
<mask> }
<mask>
<mask> return &Client{
<mask> user: newAlterIDs(newID(&uid), config.AlterID),
<mask> uuid: &uid,
<mask> security: security,
<mask> tls: config.TLS,
<mask> host: config.Host,
<mask> websocket: config.NetWork == "ws",
<mask> websocketPath: config.WebSocketPath,
<mask> tlsConfig: tlsConfig,
<mask> }, nil
<mask> }
<mask>
<mask> func getClientSessionCache() tls.ClientSessionCache {
<mask> once.Do(func() {
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/vmess.go |
"crypto/tls" | <mask> package vmess
<mask>
<mask> import (
<mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "net/url"
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove "net/url"
</s> add </s> remove "time"
</s> add </s> remove "github.com/gorilla/websocket"
</s> add </s> remove user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
websocket bool
websocketPath string
tlsConfig *tls.Config
</s> add user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
wsConfig *websocketConfig
tlsConfig *tls.Config | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/websocket.go |
"net/url" | <mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/gorilla/websocket"
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove "time"
</s> add </s> remove "net/url"
</s> add </s> remove "github.com/gorilla/websocket"
</s> add </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/websocket.go |
type websocketConfig struct {
host string
path string
tls bool
tlsConfig *tls.Config
}
| <mask> }
<mask>
<mask> // Read implements net.Conn.Read()
<mask> func (wsc *websocketConn) Read(b []byte) (int, error) {
<mask> for {
<mask> reader, err := wsc.getReader()
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
return &websocketConn{
conn: conn,
remoteAddr: remoteAddr,
</s> add func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err </s> remove user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
websocket bool
websocketPath string
tlsConfig *tls.Config
</s> add user []*ID
uuid *uuid.UUID
security Security
tls bool
host string
wsConfig *websocketConfig
tlsConfig *tls.Config | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/websocket.go |
func newWebsocketConn(conn net.Conn, c *websocketConfig) (net.Conn, error) {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host | <mask> func (wsc *websocketConn) SetWriteDeadline(t time.Time) error {
<mask> return wsc.conn.SetWriteDeadline(t)
<mask> }
<mask>
<mask> func newWebsocketConn(conn *websocket.Conn, remoteAddr net.Addr) net.Conn {
<mask> return &websocketConn{
<mask> conn: conn,
<mask> remoteAddr: remoteAddr,
<mask> }
<mask> }
</s> Chore: optimize code structure in vmess websocket (#28)
* Chore: move conn process of ws to websocket.go
* Chore: some routine adjustment </s> remove if c.websocket {
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return conn, nil
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
scheme := "ws"
if c.tls {
scheme = "wss"
dialer.TLSClientConfig = c.tlsConfig
}
host, port, err := net.SplitHostPort(c.host)
if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
host = c.host
}
uri := url.URL{
Scheme: scheme,
Host: host,
Path: c.websocketPath,
}
wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add if c.wsConfig != nil {
conn, err = newWebsocketConn(conn, c.wsConfig) </s> remove user: newAlterIDs(newID(&uid), config.AlterID),
uuid: &uid,
security: security,
tls: config.TLS,
host: config.Host,
websocket: config.NetWork == "ws",
websocketPath: config.WebSocketPath,
tlsConfig: tlsConfig,
</s> add user: newAlterIDs(newID(&uid), config.AlterID),
uuid: &uid,
security: security,
tls: config.TLS,
host: config.Host,
wsConfig: wsConfig,
tlsConfig: tlsConfig, </s> remove var reason string
if resp != nil {
reason = resp.Status
}
return nil, fmt.Errorf("Dial %s error: %s", host, reason)
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cc6d496143ecaeaf0049825e481954114e9006c3 | component/vmess/websocket.go |
N "github.com/Dreamacro/clash/common/net" | <mask>
<mask> "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/component/resolver"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/context"
<mask> )
</s> Fix: wrap net.Conn to avoid using *net.TCPConn.(ReadFrom) (#1209) </s> remove io.CopyBuffer(rightConn, leftConn, buf)
</s> add io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf) </s> remove _, err := io.CopyBuffer(leftConn, rightConn, buf)
</s> add // Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cd48f69b1fda17ab69cab6192095dd4c7189eba5 | tunnel/connection.go |
// Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf) | <mask> ch := make(chan error)
<mask>
<mask> go func() {
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> _, err := io.CopyBuffer(leftConn, rightConn, buf)
<mask> pool.Put(buf)
<mask> leftConn.SetReadDeadline(time.Now())
<mask> ch <- err
<mask> }()
<mask>
</s> Fix: wrap net.Conn to avoid using *net.TCPConn.(ReadFrom) (#1209) </s> remove io.CopyBuffer(rightConn, leftConn, buf)
</s> add io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cd48f69b1fda17ab69cab6192095dd4c7189eba5 | tunnel/connection.go |
io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf) | <mask> ch <- err
<mask> }()
<mask>
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> io.CopyBuffer(rightConn, leftConn, buf)
<mask> pool.Put(buf)
<mask> rightConn.SetReadDeadline(time.Now())
<mask> <-ch
<mask> }
</s> Fix: wrap net.Conn to avoid using *net.TCPConn.(ReadFrom) (#1209) </s> remove _, err := io.CopyBuffer(leftConn, rightConn, buf)
</s> add // Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cd48f69b1fda17ab69cab6192095dd4c7189eba5 | tunnel/connection.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = h.StreamConn(c, metadata)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/http.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = ss.StreamConn(c, metadata)
<mask> return NewConn(c, ss), err
<mask> }
<mask>
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/shadowsocks.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> return nil, fmt.Errorf("%s connect error: %w", ssr.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = ssr.StreamConn(c, metadata)
<mask> return NewConn(c, ssr), err
<mask> }
<mask>
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/shadowsocksr.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> return nil, fmt.Errorf("%s connect error: %w", s.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = s.StreamConn(c, metadata)
<mask> return NewConn(c, s), err
<mask> }
<mask>
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/snell.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = ss.StreamConn(c, metadata)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/socks5.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> err = cc.HandshakeContext(ctx)
<mask> c = cc
<mask> }
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> tcpKeepAlive(c)
<mask> var user *socks5.User
<mask> if ss.user != "" {
<mask> user = &socks5.User{
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/socks5.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = t.StreamConn(c, metadata)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/trojan.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> c, err = gun.StreamGunWithTransport(t.transport, t.gunConfig)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
<mask> defer safeConnClose(c, err)
<mask> } else {
<mask> c, err = dialer.DialContext(ctx, "tcp", t.addr, t.Base.DialOptions(opts...)...)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/trojan.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> c, err = dialer.DialContext(ctx, "tcp", t.addr, t.Base.DialOptions(opts...)...)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
<mask> defer safeConnClose(c, err)
<mask> tcpKeepAlive(c)
<mask> c, err = t.plainStream(c)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/trojan.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> c, err := gun.StreamGunWithTransport(v.transport, v.gunConfig)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = v.client.StreamConn(c, parseVmessAddr(metadata))
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/vmess.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
<mask> }
<mask> tcpKeepAlive(c)
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = v.StreamConn(c, metadata)
<mask> return NewConn(c, v), err
<mask> }
<mask>
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/vmess.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> c, err = gun.StreamGunWithTransport(v.transport, v.gunConfig)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = v.client.StreamConn(c, parseVmessAddr(metadata))
<mask> } else {
<mask> c, err = dialer.DialContext(ctx, "tcp", v.addr, v.Base.DialOptions(opts...)...)
<mask> if err != nil {
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/vmess.go |
defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | <mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
<mask> }
<mask> tcpKeepAlive(c)
<mask> defer safeConnClose(c, err)
<mask>
<mask> c, err = v.StreamConn(c, metadata)
<mask> }
<mask>
<mask> if err != nil {
</s> Fix: safeConnClose not working (#2463) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) </s> remove defer safeConnClose(c, err)
</s> add defer func(c net.Conn) {
safeConnClose(c, err)
}(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cdc7d449a606f83b814ee0df3674749b94b285a0 | adapter/outbound/vmess.go |
// Experimental config
type Experimental struct {
IgnoreResolveFail bool `yaml:"ignore-resolve-fail"`
}
| <mask> Listen string `yaml:"listen"`
<mask> EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
<mask> }
<mask>
<mask> // Config is clash config manager
<mask> type Config struct {
<mask> General *General
<mask> DNS *DNS
<mask> Experimental *Experimental
<mask> Rules []C.Rule
</s> Feature: add experimental config for resolving ip fail behavior </s> remove General *General
DNS *DNS
Rules []C.Rule
Proxies map[string]C.Proxy
</s> add General *General
DNS *DNS
Experimental *Experimental
Rules []C.Rule
Proxies map[string]C.Proxy </s> remove DNS rawDNS `yaml:"dns"`
Proxy []map[string]interface{} `yaml:"Proxy"`
ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
Rule []string `yaml:"Rule"`
</s> add DNS rawDNS `yaml:"dns"`
Experimental Experimental `yaml:"experimental"`
Proxy []map[string]interface{} `yaml:"Proxy"`
ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
Rule []string `yaml:"Rule"` </s> remove queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configLock *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
</s> add queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock()
}
// UpdateExperimental handle update experimental config
func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
t.configMux.Lock()
t.ignoreResolveFail = ignoreResolveFail
t.configMux.Unlock() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | config/config.go |
General *General
DNS *DNS
Experimental *Experimental
Rules []C.Rule
Proxies map[string]C.Proxy | <mask> }
<mask>
<mask> // Config is clash config manager
<mask> type Config struct {
<mask> General *General
<mask> DNS *DNS
<mask> Rules []C.Rule
<mask> Proxies map[string]C.Proxy
<mask> }
<mask>
<mask> type rawDNS struct {
<mask> Enable bool `yaml:"enable"`
<mask> IPv6 bool `yaml:"ipv6"`
</s> Feature: add experimental config for resolving ip fail behavior </s> remove queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configLock *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
</s> add queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool </s> remove DNS rawDNS `yaml:"dns"`
Proxy []map[string]interface{} `yaml:"Proxy"`
ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
Rule []string `yaml:"Rule"`
</s> add DNS rawDNS `yaml:"dns"`
Experimental Experimental `yaml:"experimental"`
Proxy []map[string]interface{} `yaml:"Proxy"`
ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
Rule []string `yaml:"Rule"` </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock() </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | config/config.go |
DNS rawDNS `yaml:"dns"`
Experimental Experimental `yaml:"experimental"`
Proxy []map[string]interface{} `yaml:"Proxy"`
ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
Rule []string `yaml:"Rule"` | <mask> ExternalController string `yaml:"external-controller"`
<mask> ExternalUI string `yaml:"external-ui"`
<mask> Secret string `yaml:"secret"`
<mask>
<mask> DNS rawDNS `yaml:"dns"`
<mask> Proxy []map[string]interface{} `yaml:"Proxy"`
<mask> ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
<mask> Rule []string `yaml:"Rule"`
<mask> }
<mask>
<mask> func readConfig(path string) (*rawConfig, error) {
<mask> if _, err := os.Stat(path); os.IsNotExist(err) {
<mask> return nil, err
</s> Feature: add experimental config for resolving ip fail behavior </s> remove t.configLock.RLock()
defer t.configLock.RUnlock()
</s> add t.configMux.RLock()
defer t.configMux.RUnlock() </s> remove General *General
DNS *DNS
Rules []C.Rule
Proxies map[string]C.Proxy
</s> add General *General
DNS *DNS
Experimental *Experimental
Rules []C.Rule
Proxies map[string]C.Proxy </s> remove return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
</s> add if !t.ignoreResolveFail {
return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
}
log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
} else {
log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | config/config.go |
Experimental: Experimental{
IgnoreResolveFail: true,
}, | <mask> LogLevel: log.INFO,
<mask> Rule: []string{},
<mask> Proxy: []map[string]interface{}{},
<mask> ProxyGroup: []map[string]interface{}{},
<mask> DNS: rawDNS{
<mask> Enable: false,
<mask> },
<mask> }
<mask> err = yaml.Unmarshal([]byte(data), &rawConfig)
</s> Feature: add experimental config for resolving ip fail behavior </s> remove log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip
</s> add resolved = true </s> remove return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
</s> add if !t.ignoreResolveFail {
return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
}
log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
} else {
log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | config/config.go |
config.Experimental = &rawCfg.Experimental | <mask> rawCfg, err := readConfig(path)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> general, err := parseGeneral(rawCfg)
<mask> if err != nil {
<mask> return nil, err
</s> Feature: add experimental config for resolving ip fail behavior </s> remove log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip
</s> add resolved = true </s> remove if t.shouldResolveIP(rule, metadata) {
</s> add if !resolved && t.shouldResolveIP(rule, metadata) { </s> remove return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
</s> add if !t.ignoreResolveFail {
return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
}
log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
} else {
log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip </s> remove t.configLock.RLock()
defer t.configLock.RUnlock()
</s> add t.configMux.RLock()
defer t.configMux.RUnlock() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | config/config.go |
updateExperimental(cfg.Experimental) | <mask> }
<mask> updateProxies(cfg.Proxies)
<mask> updateRules(cfg.Rules)
<mask> updateDNS(cfg.DNS)
<mask> }
<mask>
<mask> func GetGeneral() *config.General {
<mask> ports := P.GetPorts()
</s> Feature: add experimental config for resolving ip fail behavior </s> remove return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
</s> add if !t.ignoreResolveFail {
return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
}
log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
} else {
log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip </s> remove log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip
</s> add resolved = true </s> remove queue: channels.NewInfiniteChannel(),
proxies: make(map[string]C.Proxy),
configLock: &sync.RWMutex{},
traffic: C.NewTraffic(time.Second),
mode: Rule,
</s> add queue: channels.NewInfiniteChannel(),
proxies: make(map[string]C.Proxy),
configMux: &sync.RWMutex{},
traffic: C.NewTraffic(time.Second),
mode: Rule, | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | hub/executor/executor.go |
func updateExperimental(c *config.Experimental) {
T.Instance().UpdateExperimental(c.IgnoreResolveFail)
}
| <mask> }
<mask>
<mask> func updateDNS(c *config.DNS) {
<mask> if c.Enable == false {
<mask> T.Instance().SetResolver(nil)
<mask> dns.ReCreateServer("", nil)
</s> Feature: add experimental config for resolving ip fail behavior </s> remove t.configLock.RLock()
defer t.configLock.RUnlock()
</s> add t.configMux.RLock()
defer t.configMux.RUnlock() </s> remove return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
</s> add if !t.ignoreResolveFail {
return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
}
log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
} else {
log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip </s> remove log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
metadata.IP = &ip
</s> add resolved = true </s> remove if t.shouldResolveIP(rule, metadata) {
</s> add if !resolved && t.shouldResolveIP(rule, metadata) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | hub/executor/executor.go |
queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool | <mask> )
<mask>
<mask> // Tunnel handle relay inbound proxy and outbound proxy
<mask> type Tunnel struct {
<mask> queue *channels.InfiniteChannel
<mask> rules []C.Rule
<mask> proxies map[string]C.Proxy
<mask> configLock *sync.RWMutex
<mask> traffic *C.Traffic
<mask> resolver *dns.Resolver
<mask>
<mask> // Outbound Rule
<mask> mode Mode
<mask> }
<mask>
</s> Feature: add experimental config for resolving ip fail behavior </s> remove General *General
DNS *DNS
Rules []C.Rule
Proxies map[string]C.Proxy
</s> add General *General
DNS *DNS
Experimental *Experimental
Rules []C.Rule
Proxies map[string]C.Proxy </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock() </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock()
}
// UpdateExperimental handle update experimental config
func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
t.configMux.Lock()
t.ignoreResolveFail = ignoreResolveFail
t.configMux.Unlock() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | tunnel/tunnel.go |
t.configMux.Lock() | <mask> }
<mask>
<mask> // UpdateRules handle update rules
<mask> func (t *Tunnel) UpdateRules(rules []C.Rule) {
<mask> t.configLock.Lock()
<mask> t.rules = rules
<mask> t.configLock.Unlock()
<mask> }
<mask>
<mask> // Proxies return all proxies
</s> Feature: add experimental config for resolving ip fail behavior </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock() </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock()
}
// UpdateExperimental handle update experimental config
func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
t.configMux.Lock()
t.ignoreResolveFail = ignoreResolveFail
t.configMux.Unlock() </s> remove queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configLock *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
</s> add queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool </s> remove General *General
DNS *DNS
Rules []C.Rule
Proxies map[string]C.Proxy
</s> add General *General
DNS *DNS
Experimental *Experimental
Rules []C.Rule
Proxies map[string]C.Proxy | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | tunnel/tunnel.go |
t.configMux.Unlock() | <mask> // UpdateRules handle update rules
<mask> func (t *Tunnel) UpdateRules(rules []C.Rule) {
<mask> t.configLock.Lock()
<mask> t.rules = rules
<mask> t.configLock.Unlock()
<mask> }
<mask>
<mask> // Proxies return all proxies
<mask> func (t *Tunnel) Proxies() map[string]C.Proxy {
<mask> return t.proxies
</s> Feature: add experimental config for resolving ip fail behavior </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock()
}
// UpdateExperimental handle update experimental config
func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
t.configMux.Lock()
t.ignoreResolveFail = ignoreResolveFail
t.configMux.Unlock() </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configLock *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
</s> add queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool </s> remove General *General
DNS *DNS
Rules []C.Rule
Proxies map[string]C.Proxy
</s> add General *General
DNS *DNS
Experimental *Experimental
Rules []C.Rule
Proxies map[string]C.Proxy | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | tunnel/tunnel.go |
t.configMux.Lock() | <mask> }
<mask>
<mask> // UpdateProxies handle update proxies
<mask> func (t *Tunnel) UpdateProxies(proxies map[string]C.Proxy) {
<mask> t.configLock.Lock()
<mask> t.proxies = proxies
<mask> t.configLock.Unlock()
<mask> }
<mask>
<mask> // Mode return current mode
</s> Feature: add experimental config for resolving ip fail behavior </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock()
}
// UpdateExperimental handle update experimental config
func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
t.configMux.Lock()
t.ignoreResolveFail = ignoreResolveFail
t.configMux.Unlock() </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock() </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configLock *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
</s> add queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool </s> remove t.configLock.RLock()
defer t.configLock.RUnlock()
</s> add t.configMux.RLock()
defer t.configMux.RUnlock() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | tunnel/tunnel.go |
t.configMux.Unlock()
}
// UpdateExperimental handle update experimental config
func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
t.configMux.Lock()
t.ignoreResolveFail = ignoreResolveFail
t.configMux.Unlock() | <mask> // UpdateProxies handle update proxies
<mask> func (t *Tunnel) UpdateProxies(proxies map[string]C.Proxy) {
<mask> t.configLock.Lock()
<mask> t.proxies = proxies
<mask> t.configLock.Unlock()
<mask> }
<mask>
<mask> // Mode return current mode
<mask> func (t *Tunnel) Mode() Mode {
<mask> return t.mode
</s> Feature: add experimental config for resolving ip fail behavior </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove t.configLock.Unlock()
</s> add t.configMux.Unlock() </s> remove t.configLock.Lock()
</s> add t.configMux.Lock() </s> remove queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configLock *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
</s> add queue *channels.InfiniteChannel
rules []C.Rule
proxies map[string]C.Proxy
configMux *sync.RWMutex
traffic *C.Traffic
resolver *dns.Resolver
// experimental features
ignoreResolveFail bool </s> remove t.configLock.RLock()
defer t.configLock.RUnlock()
</s> add t.configMux.RLock()
defer t.configMux.RUnlock() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/cec220677455a0851b2d16be6f298664b2556c85 | tunnel/tunnel.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.