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 |
|---|---|---|---|---|
c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption) | <mask> _, port, _ := net.SplitHostPort(ss.server)
<mask> c = obfs.NewHTTPObfs(c, ss.obfsOption.Host, port)
<mask> case "websocket":
<mask> var err error
<mask> c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %s", ss.server, err.Error())
<mask> }
<mask> }
<mask> c = ss.cipher.StreamConn(c)
</s> Feature: v2ray-plugin support disable mux </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} </s> remove var wsOption *v2rayObfs.WebsocketOption
</s> add var v2rayOption *v2rayObfs.Option </s> remove conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
</s> add if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} </s> remove wsOption = &v2rayObfs.WebsocketOption{
</s> add v2rayOption = &v2rayObfs.Option{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | adapters/outbound/shadowsocks.go |
var v2rayOption *v2rayObfs.Option | <mask> if err != nil {
<mask> return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error())
<mask> }
<mask>
<mask> var wsOption *v2rayObfs.WebsocketOption
<mask> var obfsOption *simpleObfsOption
<mask> obfsMode := ""
<mask>
<mask> // forward compatibility before 1.0
<mask> if option.Obfs != "" {
</s> Feature: v2ray-plugin support disable mux </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} </s> remove obfsMode string
obfsOption *simpleObfsOption
wsOption *v2rayObfs.WebsocketOption
</s> add obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option </s> remove c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
</s> add c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption) </s> remove conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
</s> add if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | adapters/outbound/shadowsocks.go |
opts := v2rayObfsOption{Host: "bing.com", Mux: true} | <mask> }
<mask> obfsMode = opts.Mode
<mask> obfsOption = &opts
<mask> } else if option.Plugin == "v2ray-plugin" {
<mask> opts := v2rayObfsOption{Host: "bing.com"}
<mask> if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
<mask> return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %s", server, err.Error())
<mask> }
<mask>
<mask> if opts.Mode != "websocket" {
</s> Feature: v2ray-plugin support disable mux </s> remove var wsOption *v2rayObfs.WebsocketOption
</s> add var v2rayOption *v2rayObfs.Option </s> remove c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
</s> add c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption) </s> remove conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
</s> add if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} </s> remove obfsMode string
obfsOption *simpleObfsOption
wsOption *v2rayObfs.WebsocketOption
</s> add obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | adapters/outbound/shadowsocks.go |
v2rayOption = &v2rayObfs.Option{ | <mask> InsecureSkipVerify: opts.SkipCertVerify,
<mask> ClientSessionCache: getClientSessionCache(),
<mask> }
<mask> }
<mask> wsOption = &v2rayObfs.WebsocketOption{
<mask> Host: opts.Host,
<mask> Path: opts.Path,
<mask> Headers: opts.Headers,
<mask> TLSConfig: tlsConfig,
<mask> }
</s> Feature: v2ray-plugin support disable mux </s> remove conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
</s> add if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} </s> remove c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
</s> add c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption) </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} </s> remove obfsMode string
obfsOption *simpleObfsOption
wsOption *v2rayObfs.WebsocketOption
</s> add obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | adapters/outbound/shadowsocks.go |
Mux: opts.Mux, | <mask> Headers: opts.Headers,
<mask> TLSConfig: tlsConfig,
<mask> }
<mask> }
<mask>
<mask> return &ShadowSocks{
<mask> Base: &Base{
</s> Feature: v2ray-plugin support disable mux </s> remove wsOption = &v2rayObfs.WebsocketOption{
</s> add v2rayOption = &v2rayObfs.Option{ </s> remove conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
</s> add if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} </s> remove // NewWebsocketObfs return a HTTPObfs
func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
</s> add // NewV2rayObfs return a HTTPObfs
func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) { </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} </s> remove c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
</s> add c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | adapters/outbound/shadowsocks.go |
obfsMode: obfsMode,
v2rayOption: v2rayOption,
obfsOption: obfsOption, | <mask> },
<mask> server: server,
<mask> cipher: ciph,
<mask>
<mask> obfsMode: obfsMode,
<mask> wsOption: wsOption,
<mask> obfsOption: obfsOption,
<mask> }, nil
<mask> }
<mask>
<mask> type ssUDPConn struct {
<mask> net.PacketConn
</s> Feature: v2ray-plugin support disable mux </s> remove // WebsocketOption is options of websocket obfs
type WebsocketOption struct {
</s> add // Option is options of websocket obfs
type Option struct { </s> remove obfsMode string
obfsOption *simpleObfsOption
wsOption *v2rayObfs.WebsocketOption
</s> add obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} </s> remove var wsOption *v2rayObfs.WebsocketOption
</s> add var v2rayOption *v2rayObfs.Option </s> remove // NewWebsocketObfs return a HTTPObfs
func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
</s> add // NewV2rayObfs return a HTTPObfs
func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | adapters/outbound/shadowsocks.go |
// Option is options of websocket obfs
type Option struct { | <mask>
<mask> "github.com/Dreamacro/clash/component/vmess"
<mask> )
<mask>
<mask> // WebsocketOption is options of websocket obfs
<mask> type WebsocketOption struct {
<mask> Host string
<mask> Path string
<mask> Headers map[string]string
<mask> TLSConfig *tls.Config
<mask> }
</s> Feature: v2ray-plugin support disable mux </s> remove obfsMode string
obfsOption *simpleObfsOption
wsOption *v2rayObfs.WebsocketOption
</s> add obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option </s> remove // NewWebsocketObfs return a HTTPObfs
func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
</s> add // NewV2rayObfs return a HTTPObfs
func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) { </s> remove obfsMode: obfsMode,
wsOption: wsOption,
obfsOption: obfsOption,
</s> add obfsMode: obfsMode,
v2rayOption: v2rayOption,
obfsOption: obfsOption, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | component/v2ray-plugin/websocket.go |
Mux bool | <mask> Path string
<mask> Headers map[string]string
<mask> TLSConfig *tls.Config
<mask> }
<mask>
<mask> // NewV2rayObfs return a HTTPObfs
<mask> func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) {
<mask> header := http.Header{}
<mask> for k, v := range option.Headers {
</s> Feature: v2ray-plugin support disable mux </s> remove // NewWebsocketObfs return a HTTPObfs
func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
</s> add // NewV2rayObfs return a HTTPObfs
func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) { </s> remove // WebsocketOption is options of websocket obfs
type WebsocketOption struct {
</s> add // Option is options of websocket obfs
type Option struct { </s> remove obfsMode string
obfsOption *simpleObfsOption
wsOption *v2rayObfs.WebsocketOption
</s> add obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option </s> remove var wsOption *v2rayObfs.WebsocketOption
</s> add var v2rayOption *v2rayObfs.Option | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | component/v2ray-plugin/websocket.go |
// NewV2rayObfs return a HTTPObfs
func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) { | <mask> Headers map[string]string
<mask> TLSConfig *tls.Config
<mask> }
<mask>
<mask> // NewWebsocketObfs return a HTTPObfs
<mask> func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
<mask> header := http.Header{}
<mask> for k, v := range option.Headers {
<mask> header.Add(k, v)
<mask> }
<mask>
</s> Feature: v2ray-plugin support disable mux </s> remove // WebsocketOption is options of websocket obfs
type WebsocketOption struct {
</s> add // Option is options of websocket obfs
type Option struct { </s> remove conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
</s> add if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | component/v2ray-plugin/websocket.go |
if option.Mux {
conn = NewMux(conn, MuxOption{
ID: [2]byte{0, 0},
Host: "127.0.0.1",
Port: 0,
})
} | <mask> conn, err = vmess.NewWebsocketConn(conn, config)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> conn = NewMux(conn, MuxOption{
<mask> ID: [2]byte{0, 0},
<mask> Host: "127.0.0.1",
<mask> Port: 0,
<mask> })
<mask> return conn, nil
<mask> }
</s> Feature: v2ray-plugin support disable mux </s> remove c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
</s> add c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption) </s> remove opts := v2rayObfsOption{Host: "bing.com"}
</s> add opts := v2rayObfsOption{Host: "bing.com", Mux: true} </s> remove wsOption = &v2rayObfs.WebsocketOption{
</s> add v2rayOption = &v2rayObfs.Option{ </s> remove var wsOption *v2rayObfs.WebsocketOption
</s> add var v2rayOption *v2rayObfs.Option | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1a8a6d0b5d28161069c23560464be9f1e0eb6fd7 | component/v2ray-plugin/websocket.go |
title: "[Bug] " | <mask> name: Bug report
<mask> description: Create a report to help us improve
<mask> title: '[Bug] '
<mask> body:
<mask> - type: checkboxes
<mask> id: ensure
<mask> attributes:
<mask> label: Verify steps
</s> Chore: fix issue template render type </s> remove render: yaml
label: "Clash version"
</s> add label: Clash version </s> remove label: "Description"
</s> add label: Description | [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1be09f57515f6aefd0f26633ee15ffe3e2c320cb | .github/ISSUE_TEMPLATE/bug_report.yml |
label: Clash version | <mask> "
<mask> required: true
<mask> - type: textarea
<mask> attributes:
<mask> render: yaml
<mask> label: "Clash version"
<mask> validations:
<mask> required: true
<mask> - type: dropdown
<mask> id: os
<mask> attributes:
</s> Chore: fix issue template render type </s> remove label: "Description"
</s> add label: Description </s> remove title: '[Bug] '
</s> add title: "[Bug] " | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1be09f57515f6aefd0f26633ee15ffe3e2c320cb | .github/ISSUE_TEMPLATE/bug_report.yml |
label: Description | <mask> Paste the Clash core log below with the log level set to `DEBUG`.
<mask> "
<mask> - type: textarea
<mask> attributes:
<mask> label: "Description"
<mask> validations:
<mask> required: true
</s> Chore: fix issue template render type </s> remove render: yaml
label: "Clash version"
</s> add label: Clash version </s> remove title: '[Bug] '
</s> add title: "[Bug] " | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1be09f57515f6aefd0f26633ee15ffe3e2c320cb | .github/ISSUE_TEMPLATE/bug_report.yml |
"bufio" | <mask>
<mask> import (
<mask> "fmt"
<mask> "os"
<mask> "strconv"
<mask> "strings"
</s> Fix: Rule with ipv6 address </s> remove for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
</s> add reader := bufio.NewReader(strings.NewReader(rulesConfig.Body()))
for {
line, _, err := reader.ReadLine()
if err != nil {
break
}
rule := strings.Split(string(line), ",") </s> remove ini.LoadOptions{AllowBooleanKeys: true},
</s> add ini.LoadOptions{
AllowBooleanKeys: true,
UnparseableSections: []string{"Rule"},
}, | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1d0d5667fd6b2626acc395fa8696bcfc88d66f76 | config/config.go |
ini.LoadOptions{
AllowBooleanKeys: true,
UnparseableSections: []string{"Rule"},
}, | <mask> if _, err := os.Stat(C.ConfigPath); os.IsNotExist(err) {
<mask> return nil, err
<mask> }
<mask> return ini.LoadSources(
<mask> ini.LoadOptions{AllowBooleanKeys: true},
<mask> C.ConfigPath,
<mask> )
<mask> }
<mask>
<mask> // Parse config
</s> Fix: Rule with ipv6 address </s> remove for _, key := range rulesConfig.Keys() {
rule := strings.Split(key.Name(), ",")
</s> add reader := bufio.NewReader(strings.NewReader(rulesConfig.Body()))
for {
line, _, err := reader.ReadLine()
if err != nil {
break
}
rule := strings.Split(string(line), ",") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1d0d5667fd6b2626acc395fa8696bcfc88d66f76 | config/config.go |
reader := bufio.NewReader(strings.NewReader(rulesConfig.Body()))
for {
line, _, err := reader.ReadLine()
if err != nil {
break
}
rule := strings.Split(string(line), ",") | <mask> rules := []C.Rule{}
<mask>
<mask> rulesConfig := cfg.Section("Rule")
<mask> // parse rules
<mask> for _, key := range rulesConfig.Keys() {
<mask> rule := strings.Split(key.Name(), ",")
<mask> if len(rule) < 3 {
<mask> continue
<mask> }
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
</s> Fix: Rule with ipv6 address </s> remove ini.LoadOptions{AllowBooleanKeys: true},
</s> add ini.LoadOptions{
AllowBooleanKeys: true,
UnparseableSections: []string{"Rule"},
}, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1d0d5667fd6b2626acc395fa8696bcfc88d66f76 | config/config.go |
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> pc = ss.cipher.PacketConn(pc)
</s> Fix(socks5): fully udp associate support (#233) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/shadowsocks.go |
return &ssUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil | <mask> return nil, nil, err
<mask> }
<mask>
<mask> pc = ss.cipher.PacketConn(pc)
<mask> return &ssUDPConn{PacketConn: pc, rAddr: remoteAddr}, addr, nil
<mask> }
<mask>
<mask> func (ss *ShadowSocks) MarshalJSON() ([]byte, error) {
<mask> return json.Marshal(map[string]string{
<mask> "type": ss.Type().String(),
</s> Fix(socks5): fully udp associate support (#233) </s> remove remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
</s> add func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) { </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/shadowsocks.go |
"io"
"io/ioutil" | <mask> "crypto/tls"
<mask> "fmt"
<mask> "net"
<mask> "strconv"
<mask>
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Fix(socks5): fully udp associate support (#233) </s> remove udp: option.UDP,
</s> add udp: true, </s> remove return err
</s> add return nil, err </s> remove return errors.New("SOCKS version error")
</s> add return nil, errors.New("SOCKS version error") | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { | <mask> Username: ss.user,
<mask> Password: ss.pass,
<mask> }
<mask> }
<mask> if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
<mask> return nil, err
<mask> }
<mask> return c, nil
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
return nil, nil, err
</s> add bindAddr, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user)
if err != nil {
err = fmt.Errorf("%v client hanshake error", err)
return </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) { | <mask> }
<mask> return c, nil
<mask> }
<mask>
<mask> func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
<mask> c, err := dialTimeout("tcp", ss.addr, tcpTimeout)
<mask>
<mask> if err == nil && ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err = cc.Handshake()
</s> Fix(socks5): fully udp associate support (#233) </s> remove if err == nil && ss.tls {
</s> add if ss.tls { </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
</s> add if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
| [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
if err != nil {
err = fmt.Errorf("%s connect error", ss.addr)
return
} | <mask> func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) {
<mask> c, err := dialTimeout("tcp", ss.addr, tcpTimeout)
<mask>
<mask> if ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
</s> add func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) { </s> remove if err == nil && ss.tls {
</s> add if ss.tls { </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
if ss.tls { | <mask>
<mask> func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
<mask> c, err := dialTimeout("tcp", ss.addr, tcpTimeout)
<mask>
<mask> if err == nil && ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
</s> add func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) { </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
</s> add if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
defer func() {
if err != nil {
c.Close()
}
}()
| <mask> err = cc.Handshake()
<mask> c = cc
<mask> }
<mask>
<mask> if err != nil {
<mask> return nil, nil, fmt.Errorf("%s connect error", ss.addr)
<mask> }
<mask> tcpKeepAlive(c)
<mask> var user *socks5.User
<mask> if ss.user != "" {
<mask> user = &socks5.User{
<mask> Username: ss.user,
</s> Fix(socks5): fully udp associate support (#233) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
</s> add if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { </s> remove if err == nil && ss.tls {
</s> add if ss.tls { </s> remove func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
</s> add func ClientHandshake(rw io.ReadWriter, addr Addr, command Command, user *User) (Addr, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
bindAddr, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user)
if err != nil {
err = fmt.Errorf("%v client hanshake error", err)
return | <mask> Password: ss.pass,
<mask> }
<mask> }
<mask>
<mask> if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
<mask> return nil, nil, err
<mask> }
<mask> return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
<mask> }
<mask>
<mask> func NewSocks5(option Socks5Option) *Socks5 {
</s> Fix(socks5): fully udp associate support (#233) </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
</s> add if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil | <mask>
<mask> if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
<mask> return nil, nil, err
<mask> }
<mask> return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
<mask> }
<mask>
<mask> func NewSocks5(option Socks5Option) *Socks5 {
<mask> var tlsConfig *tls.Config
<mask> if option.TLS {
</s> Fix(socks5): fully udp associate support (#233) </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
return nil, nil, err
</s> add bindAddr, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user)
if err != nil {
err = fmt.Errorf("%v client hanshake error", err)
return </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
</s> add if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/socks5.go |
if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil | <mask> return nil, nil, fmt.Errorf("%s connect error", v.server)
<mask> }
<mask> tcpKeepAlive(c)
<mask> c, err = v.client.New(c, parseVmessAddr(metadata))
<mask> return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
<mask> }
<mask>
<mask> func NewVmess(option VmessOption) (*Vmess, error) {
<mask> security := strings.ToLower(option.Cipher)
<mask> client, err := vmess.NewClient(vmess.Config{
</s> Fix(socks5): fully udp associate support (#233) </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
return nil, nil, err
</s> add bindAddr, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user)
if err != nil {
err = fmt.Errorf("%v client hanshake error", err)
return </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
</s> add func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/vmess.go |
udp: true, | <mask> return &Vmess{
<mask> Base: &Base{
<mask> name: option.Name,
<mask> tp: C.Vmess,
<mask> udp: option.UDP,
<mask> },
<mask> server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
<mask> client: client,
<mask> }, nil
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
</s> add if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil { </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | adapters/outbound/vmess.go |
type Addr []byte
func (a Addr) String() string {
var host, port string
switch a[0] {
case AtypDomainName:
host = string(a[2 : 2+int(a[1])])
port = strconv.Itoa((int(a[2+int(a[1])]) << 8) | int(a[2+int(a[1])+1]))
case AtypIPv4:
host = net.IP(a[1 : 1+net.IPv4len]).String()
port = strconv.Itoa((int(a[1+net.IPv4len]) << 8) | int(a[1+net.IPv4len+1]))
case AtypIPv6:
host = net.IP(a[1 : 1+net.IPv6len]).String()
port = strconv.Itoa((int(a[1+net.IPv6len]) << 8) | int(a[1+net.IPv6len+1]))
}
return net.JoinHostPort(host, port)
} | <mask> // MaxAuthLen is the maximum size of user/password field in SOCKS5 Auth
<mask> const MaxAuthLen = 255
<mask>
<mask> // Addr represents a SOCKS address as defined in RFC 1928 section 5.
<mask> type Addr = []byte
<mask>
<mask> // SOCKS errors as defined in RFC 1928 section 6.
<mask> const (
<mask> ErrGeneralFailure = Error(1)
<mask> ErrConnectionNotAllowed = Error(2)
</s> Fix(socks5): fully udp associate support (#233) </s> remove // write VER REP RSV ATYP BND.ADDR BND.PORT
_, err = rw.Write([]byte{5, 0, 0, 1, 0, 0, 0, 0, 0, 0})
</s> add switch command {
case CmdConnect, CmdUDPAssociate:
// Acquire server listened address info
localAddr := ParseAddr(rw.LocalAddr().String())
if localAddr == nil {
err = ErrAddressNotSupported
} else {
// write VER REP RSV ATYP BND.ADDR BND.PORT
_, err = rw.Write(bytes.Join([][]byte{{5, 0, 0}, localAddr}, []byte{}))
}
case CmdBind:
fallthrough
default:
err = ErrCommandNotSupported
}
</s> remove func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
</s> add func ClientHandshake(rw io.ReadWriter, addr Addr, command Command, user *User) (Addr, error) { </s> remove socksListener *socks.SockListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
</s> add socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
<mask> if _, err = io.ReadFull(rw, buf[:3]); err != nil {
<mask> return
<mask> }
<mask>
<mask> if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
<mask> err = ErrCommandNotSupported
<mask> return
<mask> }
<mask>
<mask> command = buf[1]
<mask> addr, err = readAddr(rw, buf)
<mask> if err != nil {
<mask> return
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove return err
</s> add return nil, err </s> remove return errors.New("SOCKS need auth")
</s> add return nil, errors.New("SOCKS need auth") </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return errors.New("rejected username/password")
</s> add return nil, errors.New("rejected username/password") </s> remove return nil
</s> add return readAddr(rw, buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go | |
switch command {
case CmdConnect, CmdUDPAssociate:
// Acquire server listened address info
localAddr := ParseAddr(rw.LocalAddr().String())
if localAddr == nil {
err = ErrAddressNotSupported
} else {
// write VER REP RSV ATYP BND.ADDR BND.PORT
_, err = rw.Write(bytes.Join([][]byte{{5, 0, 0}, localAddr}, []byte{}))
}
case CmdBind:
fallthrough
default:
err = ErrCommandNotSupported
}
| <mask> addr, err = readAddr(rw, buf)
<mask> if err != nil {
<mask> return
<mask> }
<mask> // write VER REP RSV ATYP BND.ADDR BND.PORT
<mask> _, err = rw.Write([]byte{5, 0, 0, 1, 0, 0, 0, 0, 0, 0})
<mask> return
<mask> }
<mask>
<mask> // ClientHandshake fast-tracks SOCKS initialization to get target address to connect on client side.
<mask> func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
</s> Fix(socks5): fully udp associate support (#233) </s> remove func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
</s> add func ClientHandshake(rw io.ReadWriter, addr Addr, command Command, user *User) (Addr, error) { </s> remove return err
</s> add return nil, err </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return nil
</s> add return readAddr(rw, buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
func ClientHandshake(rw io.ReadWriter, addr Addr, command Command, user *User) (Addr, error) { | <mask> return
<mask> }
<mask>
<mask> // ClientHandshake fast-tracks SOCKS initialization to get target address to connect on client side.
<mask> func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
<mask> buf := make([]byte, MaxAddrLen)
<mask> var err error
<mask>
<mask> // VER, NMETHODS, METHODS
<mask> if user != nil {
</s> Fix(socks5): fully udp associate support (#233) </s> remove // write VER REP RSV ATYP BND.ADDR BND.PORT
_, err = rw.Write([]byte{5, 0, 0, 1, 0, 0, 0, 0, 0, 0})
</s> add switch command {
case CmdConnect, CmdUDPAssociate:
// Acquire server listened address info
localAddr := ParseAddr(rw.LocalAddr().String())
if localAddr == nil {
err = ErrAddressNotSupported
} else {
// write VER REP RSV ATYP BND.ADDR BND.PORT
_, err = rw.Write(bytes.Join([][]byte{{5, 0, 0}, localAddr}, []byte{}))
}
case CmdBind:
fallthrough
default:
err = ErrCommandNotSupported
}
</s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, err | <mask> } else {
<mask> _, err = rw.Write([]byte{5, 1, 0})
<mask> }
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> // VER, METHOD
<mask> if _, err := io.ReadFull(rw, buf[:2]); err != nil {
<mask> return err
</s> Fix(socks5): fully udp associate support (#233) </s> remove return err
</s> add return nil, err </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, err | <mask> }
<mask>
<mask> // VER, METHOD
<mask> if _, err := io.ReadFull(rw, buf[:2]); err != nil {
<mask> return err
<mask> }
<mask>
<mask> if buf[0] != 5 {
<mask> return errors.New("SOCKS version error")
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove return errors.New("SOCKS version error")
</s> add return nil, errors.New("SOCKS version error") </s> remove return err
</s> add return nil, err </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, errors.New("SOCKS version error") | <mask> return err
<mask> }
<mask>
<mask> if buf[0] != 5 {
<mask> return errors.New("SOCKS version error")
<mask> }
<mask>
<mask> if buf[1] == 2 {
<mask> // password protocol version
<mask> authMsg := &bytes.Buffer{}
</s> Fix(socks5): fully udp associate support (#233) </s> remove return err
</s> add return nil, err </s> remove return errors.New("SOCKS need auth")
</s> add return nil, errors.New("SOCKS need auth") </s> remove return errors.New("rejected username/password")
</s> add return nil, errors.New("rejected username/password") </s> remove return err
</s> add return nil, err </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, err | <mask> authMsg.WriteByte(uint8(len(user.Password)))
<mask> authMsg.WriteString(user.Password)
<mask>
<mask> if _, err := rw.Write(authMsg.Bytes()); err != nil {
<mask> return err
<mask> }
<mask>
<mask> if _, err := io.ReadFull(rw, buf[:2]); err != nil {
<mask> return err
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, err | <mask> return err
<mask> }
<mask>
<mask> if _, err := io.ReadFull(rw, buf[:2]); err != nil {
<mask> return err
<mask> }
<mask>
<mask> if buf[1] != 0 {
<mask> return errors.New("rejected username/password")
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove return errors.New("rejected username/password")
</s> add return nil, errors.New("rejected username/password") </s> remove return errors.New("SOCKS need auth")
</s> add return nil, errors.New("SOCKS need auth") </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, errors.New("rejected username/password") | <mask> return err
<mask> }
<mask>
<mask> if buf[1] != 0 {
<mask> return errors.New("rejected username/password")
<mask> }
<mask> } else if buf[1] != 0 {
<mask> return errors.New("SOCKS need auth")
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove return errors.New("SOCKS need auth")
</s> add return nil, errors.New("SOCKS need auth") </s> remove return err
</s> add return nil, err </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add </s> remove return errors.New("SOCKS version error")
</s> add return nil, errors.New("SOCKS version error") </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return nil, errors.New("SOCKS need auth") | <mask> if buf[1] != 0 {
<mask> return errors.New("rejected username/password")
<mask> }
<mask> } else if buf[1] != 0 {
<mask> return errors.New("SOCKS need auth")
<mask> }
<mask>
<mask> // VER, CMD, RSV, ADDR
<mask> if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
<mask> return err
</s> Fix(socks5): fully udp associate support (#233) </s> remove return errors.New("rejected username/password")
</s> add return nil, errors.New("rejected username/password") </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err </s> remove return err
</s> add return nil, err </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err | <mask> return errors.New("SOCKS need auth")
<mask> }
<mask>
<mask> // VER, CMD, RSV, ADDR
<mask> if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
<mask> return err
<mask> }
<mask>
<mask> if _, err := io.ReadFull(rw, buf[:10]); err != nil {
<mask> return err
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove return errors.New("SOCKS need auth")
</s> add return nil, errors.New("SOCKS need auth") </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
// VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err | <mask> if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
<mask> return err
<mask> }
<mask>
<mask> if _, err := io.ReadFull(rw, buf[:10]); err != nil {
<mask> return err
<mask> }
<mask>
<mask> return nil
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err </s> remove return errors.New("SOCKS need auth")
</s> add return nil, errors.New("SOCKS need auth") </s> remove return err
</s> add return nil, err </s> remove return nil
</s> add return readAddr(rw, buf) </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
return readAddr(rw, buf) | <mask> if _, err := io.ReadFull(rw, buf[:10]); err != nil {
<mask> return err
<mask> }
<mask>
<mask> return nil
<mask> }
<mask>
<mask> func readAddr(r io.Reader, b []byte) (Addr, error) {
<mask> if len(b) < MaxAddrLen {
<mask> return nil, io.ErrShortBuffer
</s> Fix(socks5): fully udp associate support (#233) </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
return err
</s> add if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
return nil, err </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | component/socks5/socks5.go |
socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener | <mask>
<mask> var (
<mask> allowLan = false
<mask>
<mask> socksListener *socks.SockListener
<mask> httpListener *http.HttpListener
<mask> redirListener *redir.RedirListener
<mask> )
<mask>
<mask> type listener interface {
<mask> Close()
<mask> Address() string
</s> Fix(socks5): fully udp associate support (#233) </s> remove type Addr = []byte
</s> add type Addr []byte
func (a Addr) String() string {
var host, port string
switch a[0] {
case AtypDomainName:
host = string(a[2 : 2+int(a[1])])
port = strconv.Itoa((int(a[2+int(a[1])]) << 8) | int(a[2+int(a[1])+1]))
case AtypIPv4:
host = net.IP(a[1 : 1+net.IPv4len]).String()
port = strconv.Itoa((int(a[1+net.IPv4len]) << 8) | int(a[1+net.IPv4len+1]))
case AtypIPv6:
host = net.IP(a[1 : 1+net.IPv6len]).String()
port = strconv.Itoa((int(a[1+net.IPv6len]) << 8) | int(a[1+net.IPv6len+1]))
}
return net.JoinHostPort(host, port)
} </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove defer localConn.Close()
metadata := localConn.Metadata()
</s> add defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}() </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | proxy/listener.go |
"io"
"io/ioutil" | <mask> package socks
<mask>
<mask> import (
<mask> "net"
<mask>
<mask> adapters "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Fix(socks5): fully udp associate support (#233) </s> remove socksListener *socks.SockListener
httpListener *http.HttpListener
redirListener *redir.RedirListener
</s> add socksListener *socks.SockListener
socksUDPListener *socks.SockUDPListener
httpListener *http.HttpListener
redirListener *redir.RedirListener </s> remove type Addr = []byte
</s> add type Addr []byte
func (a Addr) String() string {
var host, port string
switch a[0] {
case AtypDomainName:
host = string(a[2 : 2+int(a[1])])
port = strconv.Itoa((int(a[2+int(a[1])]) << 8) | int(a[2+int(a[1])+1]))
case AtypIPv4:
host = net.IP(a[1 : 1+net.IPv4len]).String()
port = strconv.Itoa((int(a[1+net.IPv4len]) << 8) | int(a[1+net.IPv4len+1]))
case AtypIPv6:
host = net.IP(a[1 : 1+net.IPv6len]).String()
port = strconv.Itoa((int(a[1+net.IPv6len]) << 8) | int(a[1+net.IPv6len+1]))
}
return net.JoinHostPort(host, port)
} </s> remove udp: option.UDP,
</s> add udp: true, | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | proxy/socks/tcp.go |
defer conn.Close()
io.Copy(ioutil.Discard, conn) | <mask> return
<mask> }
<mask> conn.(*net.TCPConn).SetKeepAlive(true)
<mask> if command == socks5.CmdUDPAssociate {
<mask> tun.Add(adapters.NewSocket(target, conn, C.SOCKS, C.UDP))
<mask> return
<mask> }
<mask> tun.Add(adapters.NewSocket(target, conn, C.SOCKS, C.TCP))
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add </s> remove return errors.New("SOCKS version error")
</s> add return nil, errors.New("SOCKS version error") </s> remove return errors.New("rejected username/password")
</s> add return nil, errors.New("rejected username/password") </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | proxy/socks/tcp.go |
func (t *Tunnel) handleUDPToRemote(conn net.Conn, pc net.PacketConn, addr net.Addr) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)]) | <mask> }
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
<mask> conn := newTrafficTrack(outbound, t.traffic)
<mask> relay(request, conn)
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
<mask> ch := make(chan error, 1)
<mask>
<mask> go func() {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf)
<mask> for {
</s> Fix(socks5): fully udp associate support (#233) </s> remove <-ch
return nil
</s> add func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn) </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove defer localConn.Close()
metadata := localConn.Metadata()
</s> add defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} | <mask>
<mask> func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
<mask> ch := make(chan error, 1)
<mask>
<mask> go func() {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf)
<mask> for {
<mask> n, err := conn.Read(buf)
<mask> if err != nil {
<mask> ch <- err
<mask> return
<mask> }
<mask> pc.SetReadDeadline(time.Now().Add(120 * time.Second))
<mask> if _, err = pc.WriteTo(buf[:n], addr); err != nil {
<mask> ch <- err
<mask> return
<mask> }
<mask> t.traffic.Up() <- int64(n)
<mask> ch <- nil
<mask> }
<mask> }()
<mask>
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf)
<mask>
<mask> for {
</s> Fix(socks5): fully udp associate support (#233) </s> remove func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
}
func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
ch := make(chan error, 1)
</s> add func (t *Tunnel) handleUDPToRemote(conn net.Conn, pc net.PacketConn, addr net.Addr) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove defer pool.BufPool.Put(buf)
</s> add defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove pc.SetReadDeadline(time.Now().Add(120 * time.Second))
</s> add </s> remove if _, err := conn.Write(buf[:n]); err != nil {
break
</s> add n, err = conn.Write(buf[:n])
if err != nil {
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"k... | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) { | <mask> }
<mask>
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
<mask>
<mask> for {
<mask> n, _, err := pc.ReadFrom(buf)
</s> Fix(socks5): fully udp associate support (#233) </s> remove defer pool.BufPool.Put(buf)
</s> add defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove pc.SetReadDeadline(time.Now().Add(120 * time.Second))
</s> add </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
}
func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
ch := make(chan error, 1)
</s> add func (t *Tunnel) handleUDPToRemote(conn net.Conn, pc net.PacketConn, addr net.Addr) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove break
</s> add return | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
defer pool.BufPool.Put(buf[:cap(buf)]) | <mask> }
<mask> }()
<mask>
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf)
<mask>
<mask> for {
<mask> pc.SetReadDeadline(time.Now().Add(120 * time.Second))
<mask> n, _, err := pc.ReadFrom(buf)
<mask> if err != nil {
</s> Fix(socks5): fully udp associate support (#233) </s> remove pc.SetReadDeadline(time.Now().Add(120 * time.Second))
</s> add </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove break
</s> add return </s> remove func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
}
func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
ch := make(chan error, 1)
</s> add func (t *Tunnel) handleUDPToRemote(conn net.Conn, pc net.PacketConn, addr net.Addr) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)]) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf)
<mask>
<mask> for {
<mask> pc.SetReadDeadline(time.Now().Add(120 * time.Second))
<mask> n, _, err := pc.ReadFrom(buf)
<mask> if err != nil {
<mask> break
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove defer pool.BufPool.Put(buf)
</s> add defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove break
</s> add return </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove if _, err := conn.Write(buf[:n]); err != nil {
break
</s> add n, err = conn.Write(buf[:n])
if err != nil {
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go | |
return | <mask> for {
<mask> pc.SetReadDeadline(time.Now().Add(120 * time.Second))
<mask> n, _, err := pc.ReadFrom(buf)
<mask> if err != nil {
<mask> break
<mask> }
<mask>
<mask> if _, err := conn.Write(buf[:n]); err != nil {
<mask> break
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove pc.SetReadDeadline(time.Now().Add(120 * time.Second))
</s> add </s> remove if _, err := conn.Write(buf[:n]); err != nil {
break
</s> add n, err = conn.Write(buf[:n])
if err != nil {
return </s> remove defer pool.BufPool.Put(buf)
</s> add defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
n, err = conn.Write(buf[:n])
if err != nil {
return | <mask> if err != nil {
<mask> break
<mask> }
<mask>
<mask> if _, err := conn.Write(buf[:n]); err != nil {
<mask> break
<mask> }
<mask>
<mask> t.traffic.Down() <- int64(n)
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove break
</s> add return </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove pc.SetReadDeadline(time.Now().Add(120 * time.Second))
</s> add </s> remove if _, err := io.ReadFull(rw, buf[:10]); err != nil {
return err
</s> add // VER, REP, RSV
if _, err := io.ReadFull(rw, buf[:3]); err != nil {
return nil, err </s> remove return err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
} | <mask> return
<mask> }
<mask> t.traffic.Down() <- int64(n)
<mask> }
<mask>
<mask> func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
<mask> conn := newTrafficTrack(outbound, t.traffic)
<mask> relay(request, conn)
</s> Fix(socks5): fully udp associate support (#233) </s> remove <-ch
return nil
</s> add func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn) </s> remove func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
}
func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
ch := make(chan error, 1)
</s> add func (t *Tunnel) handleUDPToRemote(conn net.Conn, pc net.PacketConn, addr net.Addr) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove if _, err := conn.Write(buf[:n]); err != nil {
break
</s> add n, err = conn.Write(buf[:n])
if err != nil {
return </s> remove defer localConn.Close()
metadata := localConn.Metadata()
</s> add defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn) | <mask>
<mask> t.traffic.Down() <- int64(n)
<mask> }
<mask>
<mask> <-ch
<mask> return nil
<mask> }
<mask>
<mask> // relay copies between left and right bidirectionally.
<mask> func relay(leftConn, rightConn net.Conn) {
<mask> ch := make(chan error)
</s> Fix(socks5): fully udp associate support (#233) </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove if _, err := conn.Write(buf[:n]); err != nil {
break
</s> add n, err = conn.Write(buf[:n])
if err != nil {
return </s> remove func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
}
func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
ch := make(chan error, 1)
</s> add func (t *Tunnel) handleUDPToRemote(conn net.Conn, pc net.PacketConn, addr net.Addr) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)]) </s> remove return nil
</s> add return readAddr(rw, buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/connection.go |
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}() | <mask> return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
<mask> }
<mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> metadata := localConn.Metadata()
<mask>
<mask> if !metadata.Valid() {
<mask> log.Warnln("[Metadata] not valid: %#v", metadata)
<mask> return
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
err = ErrCommandNotSupported
return
}
</s> add </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
</s> add func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ net.PacketConn, _ net.Addr, err error) { </s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go |
metadata := localConn.Metadata() | <mask> }
<mask> }()
<mask>
<mask> if !metadata.Valid() {
<mask> log.Warnln("[Metadata] not valid: %#v", metadata)
<mask> return
<mask> }
</s> Fix(socks5): fully udp associate support (#233) </s> remove defer localConn.Close()
metadata := localConn.Metadata()
</s> add defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}() </s> remove if err != nil {
return nil, nil, fmt.Errorf("%s connect error", ss.addr)
}
</s> add defer func() {
if err != nil {
c.Close()
}
}()
</s> remove go func() {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
for {
n, err := conn.Read(buf)
if err != nil {
ch <- err
return
}
pc.SetReadDeadline(time.Now().Add(120 * time.Second))
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
ch <- err
return
}
t.traffic.Up() <- int64(n)
ch <- nil
}
}()
</s> add n, err := conn.Read(buf)
if err != nil {
return
}
if _, err = pc.WriteTo(buf[:n], addr); err != nil {
return
}
t.traffic.Up() <- int64(n)
} </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove return errors.New("rejected username/password")
</s> add return nil, errors.New("rejected username/password") | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go |
switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) | <mask> return
<mask> }
<mask> }
<mask>
<mask> if metadata.NetWork == C.UDP {
<mask> pc, addr, err := proxy.DialUDP(metadata)
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error())
<mask> return
<mask> }
<mask> defer pc.Close()
</s> Fix(socks5): fully udp associate support (#233) </s> remove defer pc.Close()
</s> add </s> remove t.handleUDPOverTCP(localConn, pc, addr)
return
</s> add natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go |
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error())
<mask> return
<mask> }
<mask> defer pc.Close()
<mask>
<mask> t.handleUDPOverTCP(localConn, pc, addr)
<mask> return
<mask> }
<mask>
</s> Fix(socks5): fully udp associate support (#233) </s> remove t.handleUDPOverTCP(localConn, pc, addr)
return
</s> add natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc) </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go | |
natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc) | <mask> return
<mask> }
<mask> defer pc.Close()
<mask>
<mask> t.handleUDPOverTCP(localConn, pc, addr)
<mask> return
<mask> }
<mask>
<mask> remoConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error())
</s> Fix(socks5): fully udp associate support (#233) </s> remove defer pc.Close()
</s> add </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
</s> add addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
if err != nil {
return
}
targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
}
pc, err := net.ListenPacket("udp", "")
if err != nil {
return
}
go func() {
io.Copy(ioutil.Discard, c)
c.Close()
// A UDP association terminates when the TCP connection that the UDP
// ASSOCIATE request arrived on terminates. RFC1928
pc.Close()
}()
return &socksUDPConn{PacketConn: pc, rAddr: targetAddr}, addr, nil </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go |
t.handleUDPToRemote(localConn, pc, addr)
}
func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) { | <mask> go t.handleUDPToLocal(localConn, pc)
<mask> }
<mask>
<mask> remoConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error())
<mask> return
</s> Fix(socks5): fully udp associate support (#233) </s> remove t.handleUDPOverTCP(localConn, pc, addr)
return
</s> add natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc) </s> remove defer pc.Close()
</s> add </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
</s> add if err != nil {
return nil, nil, fmt.Errorf("new vmess client error: %v", err)
}
return &fakeUDPConn{Conn: c}, c.RemoteAddr(), nil | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go |
log.Debugln("%v UDP is not supported", adapter.Name()) | <mask>
<mask> if metadata.NetWork == C.UDP && !adapter.SupportUDP() {
<mask> continue
<mask> }
<mask>
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> Fix(socks5): fully udp associate support (#233) </s> remove if metadata.NetWork == C.UDP {
pc, addr, err := proxy.DialUDP(metadata)
</s> add switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy)
}
}
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
var err error
pc, addr, err = proxy.DialUDP(metadata) </s> remove defer pc.Close()
</s> add </s> remove t.handleUDPOverTCP(localConn, pc, addr)
return
</s> add natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc) </s> remove defer localConn.Close()
metadata := localConn.Metadata()
</s> add defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}() | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1fd8f690fea1d8bd4f858e44ee44f2d1c8b67b11 | tunnel/tunnel.go |
return nil, fmt.Errorf("Rules[%d] [%s] error: format invalid", idx, line) | <mask> case 3:
<mask> payload = rule[1]
<mask> target = rule[2]
<mask> default:
<mask> return nil, fmt.Errorf("Rules[%d] [- %s] error: format invalid", idx, line)
<mask> }
<mask>
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN":
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewDomain(payload, target))
</s> add parsed = R.NewDomain(payload, target) </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) </s> remove rules = append(rules, R.NewMatch(target))
</s> add parsed = R.NewMatch(target) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
var parsed C.Rule | <mask>
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN":
<mask> parsed = R.NewDomain(payload, target)
<mask> case "DOMAIN-SUFFIX":
<mask> parsed = R.NewDomainSuffix(payload, target)
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewDomain(payload, target))
</s> add parsed = R.NewDomain(payload, target) </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) </s> remove return nil, fmt.Errorf("Rules[%d] [- %s] error: format invalid", idx, line)
</s> add return nil, fmt.Errorf("Rules[%d] [%s] error: format invalid", idx, line) </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
parsed = R.NewDomain(payload, target) | <mask>
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN":
<mask> rules = append(rules, R.NewDomain(payload, target))
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(payload, target))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(payload, target))
<mask> case "GEOIP":
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
parsed = R.NewDomainSuffix(payload, target) | <mask> switch rule[0] {
<mask> case "DOMAIN":
<mask> rules = append(rules, R.NewDomain(payload, target))
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(payload, target))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(payload, target))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(payload, target))
<mask> case "IP-CIDR", "IP-CIDR6":
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewDomain(payload, target))
</s> add parsed = R.NewDomain(payload, target) </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
parsed = R.NewDomainKeyword(payload, target) | <mask> rules = append(rules, R.NewDomain(payload, target))
<mask> case "DOMAIN-SUFFIX":
<mask> rules = append(rules, R.NewDomainSuffix(payload, target))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(payload, target))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(payload, target))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, false))
<mask> case "SOURCE-IP-CIDR":
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) </s> remove rules = append(rules, R.NewDomain(payload, target))
</s> add parsed = R.NewDomain(payload, target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
parsed = R.NewGEOIP(payload, target) | <mask> rules = append(rules, R.NewDomainSuffix(payload, target))
<mask> case "DOMAIN-KEYWORD":
<mask> rules = append(rules, R.NewDomainKeyword(payload, target))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(payload, target))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, false))
<mask> case "SOURCE-IP-CIDR":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, true))
<mask> case "MATCH":
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) </s> remove rules = append(rules, R.NewDomain(payload, target))
</s> add parsed = R.NewDomain(payload, target) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} | <mask> rules = append(rules, R.NewDomainKeyword(payload, target))
<mask> case "GEOIP":
<mask> rules = append(rules, R.NewGEOIP(payload, target))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, false))
<mask> case "SOURCE-IP-CIDR":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, true))
<mask> case "MATCH":
<mask> fallthrough
<mask> case "FINAL":
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) </s> remove rules = append(rules, R.NewMatch(target))
</s> add parsed = R.NewMatch(target) </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} | <mask> rules = append(rules, R.NewGEOIP(payload, target))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, false))
<mask> case "SOURCE-IP-CIDR":
<mask> rules = append(rules, R.NewIPCIDR(payload, target, true))
<mask> case "MATCH":
<mask> fallthrough
<mask> case "FINAL":
<mask> rules = append(rules, R.NewMatch(target))
<mask> }
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewMatch(target))
</s> add parsed = R.NewMatch(target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) </s> remove rules = append(rules, R.NewDomainSuffix(payload, target))
</s> add parsed = R.NewDomainSuffix(payload, target) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
parsed = R.NewMatch(target) | <mask> rules = append(rules, R.NewIPCIDR(payload, target, true))
<mask> case "MATCH":
<mask> fallthrough
<mask> case "FINAL":
<mask> rules = append(rules, R.NewMatch(target))
<mask> }
<mask> }
<mask>
<mask> return rules, nil
<mask> }
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewGEOIP(payload, target))
</s> add parsed = R.NewGEOIP(payload, target) </s> remove rules = append(rules, R.NewDomainKeyword(payload, target))
</s> add parsed = R.NewDomainKeyword(payload, target) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
if parsed == nil {
return nil, fmt.Errorf("Rules[%d] [%s] error: payload invalid", idx, line)
}
rules = append(rules, parsed) | <mask> fallthrough
<mask> case "FINAL":
<mask> parsed = R.NewMatch(target)
<mask> }
<mask> }
<mask>
<mask> return rules, nil
<mask> }
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewMatch(target))
</s> add parsed = R.NewMatch(target) </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove return nil, fmt.Errorf("Rules[%d] [- %s] error: format invalid", idx, line)
</s> add return nil, fmt.Errorf("Rules[%d] [%s] error: format invalid", idx, line) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | config/config.go |
return nil | <mask> func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR {
<mask> _, ipnet, err := net.ParseCIDR(s)
<mask> if err != nil {
<mask> }
<mask> return &IPCIDR{
<mask> ipnet: ipnet,
<mask> adapter: adapter,
<mask> isSourceIP: isSourceIP,
<mask> }
</s> Fix: IP-CIDR invalid payload crash </s> remove rules = append(rules, R.NewIPCIDR(payload, target, true))
</s> add if rule := R.NewIPCIDR(payload, target, true); rule != nil {
parsed = rule
} </s> remove rules = append(rules, R.NewIPCIDR(payload, target, false))
</s> add if rule := R.NewIPCIDR(payload, target, false); rule != nil {
parsed = rule
} </s> remove return nil, fmt.Errorf("Rules[%d] [- %s] error: format invalid", idx, line)
</s> add return nil, fmt.Errorf("Rules[%d] [%s] error: format invalid", idx, line) </s> remove rules = append(rules, R.NewMatch(target))
</s> add parsed = R.NewMatch(target) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2036f8cb7a885dd82616c55f54032ba67a0d2c91 | rules/ipcidr.go |
func NewSocket(target socks5.Addr, conn net.Conn, source C.Type) *SocketAdapter { | <mask> return s.metadata
<mask> }
<mask>
<mask> // NewSocket is SocketAdapter generator
<mask> func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
<mask> metadata := parseSocksAddr(target)
<mask> metadata.NetWork = netType
<mask> metadata.Type = source
<mask> if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
<mask> metadata.SrcIP = ip
</s> Chore: remove unused parameter netType (#651) </s> remove tunnel.Add(inbound.NewSocket(target, conn, C.REDIR, C.TCP))
</s> add tunnel.Add(inbound.NewSocket(target, conn, C.REDIR)) </s> remove tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS, C.TCP))
</s> add tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS)) </s> remove metadata.NetWork = netType
</s> add metadata.NetWork = C.TCP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2047b8eda1c7a28e484ebe5361d28be75c9b6d75 | adapters/inbound/socket.go |
metadata.NetWork = C.TCP | <mask>
<mask> // NewSocket is SocketAdapter generator
<mask> func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
<mask> metadata := parseSocksAddr(target)
<mask> metadata.NetWork = netType
<mask> metadata.Type = source
<mask> if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
<mask> metadata.SrcIP = ip
<mask> metadata.SrcPort = port
<mask> }
</s> Chore: remove unused parameter netType (#651) </s> remove tunnel.Add(inbound.NewSocket(target, conn, C.REDIR, C.TCP))
</s> add tunnel.Add(inbound.NewSocket(target, conn, C.REDIR)) </s> remove tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS, C.TCP))
</s> add tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS)) </s> remove func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
</s> add func NewSocket(target socks5.Addr, conn net.Conn, source C.Type) *SocketAdapter { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2047b8eda1c7a28e484ebe5361d28be75c9b6d75 | adapters/inbound/socket.go |
tunnel.Add(inbound.NewSocket(target, conn, C.REDIR)) | <mask> conn.Close()
<mask> return
<mask> }
<mask> conn.(*net.TCPConn).SetKeepAlive(true)
<mask> tunnel.Add(inbound.NewSocket(target, conn, C.REDIR, C.TCP))
<mask> }
</s> Chore: remove unused parameter netType (#651) </s> remove tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS, C.TCP))
</s> add tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS)) </s> remove func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
</s> add func NewSocket(target socks5.Addr, conn net.Conn, source C.Type) *SocketAdapter { </s> remove metadata.NetWork = netType
</s> add metadata.NetWork = C.TCP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/2047b8eda1c7a28e484ebe5361d28be75c9b6d75 | proxy/redir/tcp.go |
tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS)) | <mask> defer conn.Close()
<mask> io.Copy(ioutil.Discard, conn)
<mask> return
<mask> }
<mask> tunnel.Add(adapters.NewSocket(target, conn, C.SOCKS, C.TCP))
<mask> }
</s> Chore: remove unused parameter netType (#651) </s> remove tunnel.Add(inbound.NewSocket(target, conn, C.REDIR, C.TCP))
</s> add tunnel.Add(inbound.NewSocket(target, conn, C.REDIR)) </s> remove func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
</s> add func NewSocket(target socks5.Addr, conn net.Conn, source C.Type) *SocketAdapter { </s> remove metadata.NetWork = netType
</s> add metadata.NetWork = C.TCP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/2047b8eda1c7a28e484ebe5361d28be75c9b6d75 | proxy/socks/tcp.go |
<mask> HTTPOpts HTTPOptions `proxy:"http-opts,omitempty"`
<mask> HTTP2Opts HTTP2Options `proxy:"h2-opts,omitempty"`
<mask> GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"`
<mask> WSOpts WSOptions `proxy:"ws-opts,omitempty"`
<mask>
<mask> // TODO: remove these until 2022
<mask> WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
<mask> WSPath string `proxy:"ws-path,omitempty"`
<mask> }
<mask>
<mask> type HTTPOptions struct {
<mask> Method string `proxy:"method,omitempty"`
<mask> Path []string `proxy:"path,omitempty"`
</s> Chore: remove forward compatible code </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break </s> remove initOnce.Do(migrateCache)
</s> add initOnce.Do(initCache) </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | adapter/outbound/vmess.go | |
<mask> func (v *Vmess) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> var err error
<mask> switch v.option.Network {
<mask> case "ws":
<mask> if v.option.WSOpts.Path == "" {
<mask> v.option.WSOpts.Path = v.option.WSPath
<mask> }
<mask> if len(v.option.WSOpts.Headers) == 0 {
<mask> v.option.WSOpts.Headers = v.option.WSHeaders
<mask> }
<mask>
<mask> host, port, _ := net.SplitHostPort(v.addr)
<mask> wsOpts := &vmess.WebsocketConfig{
<mask> Host: host,
<mask> Port: port,
<mask> Path: v.option.WSOpts.Path,
</s> Chore: remove forward compatible code </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) </s> remove defer db.Close()
</s> add </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | adapter/outbound/vmess.go | |
<mask> package cachefile
<mask>
<mask> import (
<mask> "bytes"
<mask> "encoding/gob"
<mask> "os"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/component/profile"
</s> Chore: remove forward compatible code </s> remove initOnce.Do(migrateCache)
</s> add initOnce.Do(initCache) </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove defer db.Close()
</s> add </s> remove return
</s> add log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add | [
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go | |
func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break | <mask> func (c *CacheFile) Close() error {
<mask> return c.DB.Close()
<mask> }
<mask>
<mask> // TODO: remove migrateCache until 2022
<mask> func migrateCache() {
<mask> defer func() {
<mask> options := bbolt.Options{Timeout: time.Second}
<mask> db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
<mask> switch err {
<mask> case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
<mask> if err = os.Remove(C.Path.Cache()); err != nil {
<mask> log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
<mask> break
<mask> }
<mask> log.Infoln("[CacheFile] remove invalid cache file and create new one")
<mask> db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
<mask> }
<mask> if err != nil {
<mask> log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
<mask> }
<mask>
<mask> defaultCache = &CacheFile{
<mask> DB: db,
<mask> }
</s> Chore: remove forward compatible code </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) </s> remove return
</s> add log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add </s> remove defer db.Close()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go |
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) | <mask> }
<mask> if err != nil {
<mask> log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
<mask> }
<mask>
<mask> defaultCache = &CacheFile{
<mask> DB: db,
<mask> }
<mask> }()
<mask>
<mask> buf, err := os.ReadFile(C.Path.OldCache())
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer os.Remove(C.Path.OldCache())
<mask>
<mask> // read old cache file
<mask> type cache struct {
<mask> Selected map[string]string
<mask> }
<mask> model := &cache{
<mask> Selected: map[string]string{},
<mask> }
<mask> bufReader := bytes.NewBuffer(buf)
<mask> gob.NewDecoder(bufReader).Decode(model)
<mask>
<mask> // write to new cache file
</s> Chore: remove forward compatible code </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add </s> remove return
</s> add log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove defer db.Close()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"k... | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go |
<mask> }
<mask> model := &cache{
<mask> Selected: map[string]string{},
<mask> }
<mask> bufReader := bytes.NewBuffer(buf)
<mask> gob.NewDecoder(bufReader).Decode(model)
<mask>
<mask> // write to new cache file
<mask> db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer db.Close()
<mask>
</s> Chore: remove forward compatible code </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) </s> remove return
</s> add log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) </s> remove defer db.Close()
</s> add </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go | |
log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) | <mask>
<mask> // write to new cache file
<mask> db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer db.Close()
<mask>
<mask> db.Batch(func(t *bbolt.Tx) error {
<mask> bucket, err := t.CreateBucketIfNotExists(bucketSelected)
</s> Chore: remove forward compatible code </s> remove defer db.Close()
</s> add </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go |
<mask> db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer db.Close()
<mask>
<mask> db.Batch(func(t *bbolt.Tx) error {
<mask> bucket, err := t.CreateBucketIfNotExists(bucketSelected)
<mask> if err != nil {
<mask> return err
</s> Chore: remove forward compatible code </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove return
</s> add log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go | |
defaultCache = &CacheFile{
DB: db,
} | <mask> return
<mask> }
<mask> defer db.Close()
<mask>
<mask> db.Batch(func(t *bbolt.Tx) error {
<mask> bucket, err := t.CreateBucketIfNotExists(bucketSelected)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> for group, selected := range model.Selected {
<mask> if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
<mask> return err
<mask> }
<mask> }
<mask> return nil
<mask> })
<mask> }
<mask>
<mask> // Cache return singleton of CacheFile
<mask> func Cache() *CacheFile {
<mask> initOnce.Do(migrateCache)
</s> Chore: remove forward compatible code </s> remove defer db.Close()
</s> add </s> remove initOnce.Do(migrateCache)
</s> add initOnce.Do(initCache) </s> remove return
</s> add log.Warnln("[CacheFile] can't open cache file: %s", err.Error()) </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go |
initOnce.Do(initCache) | <mask> }
<mask>
<mask> // Cache return singleton of CacheFile
<mask> func Cache() *CacheFile {
<mask> initOnce.Do(migrateCache)
<mask>
<mask> return defaultCache
<mask> }
</s> Chore: remove forward compatible code </s> remove db.Batch(func(t *bbolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
})
</s> add defaultCache = &CacheFile{
DB: db,
} </s> remove
defaultCache = &CacheFile{
DB: db,
}
}()
buf, err := os.ReadFile(C.Path.OldCache())
if err != nil {
return
}
defer os.Remove(C.Path.OldCache())
// read old cache file
type cache struct {
Selected map[string]string
}
model := &cache{
Selected: map[string]string{},
</s> add log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options) </s> remove // TODO: remove migrateCache until 2022
func migrateCache() {
defer func() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break
}
log.Infoln("[CacheFile] remove invalid cache file and create new one")
db, err = bbolt.Open(C.Path.Cache(), fileMode, &options)
}
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
</s> add func initCache() {
options := bbolt.Options{Timeout: time.Second}
db, err := bbolt.Open(C.Path.Cache(), fileMode, &options)
switch err {
case bbolt.ErrInvalid, bbolt.ErrChecksum, bbolt.ErrVersionMismatch:
if err = os.Remove(C.Path.Cache()); err != nil {
log.Warnln("[CacheFile] remove invalid cache file error: %s", err.Error())
break </s> remove bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
// write to new cache file
db, err := bbolt.Open(C.Path.Cache(), fileMode, nil)
</s> add </s> remove defer db.Close()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/204a72bbd356515ccdff9e478f8250d58545b345 | component/profile/cachefile/cache.go |
<mask> func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) {
<mask> if _, err := pc.WriteWithMetadata(packet.Data(), metadata); err != nil {
<mask> return
<mask> }
<mask> DefaultManager.Upload() <- int64(len(packet.Data()))
<mask> }
<mask>
<mask> func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, fAddr net.Addr) {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
</s> Fix: udp traffic track (#608) </s> remove DefaultManager.Download() <- int64(n)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/206767247ea4c7f2a7ee4986ec638e54ad0dda35 | tunnel/connection.go | |
<mask> n, err = packet.WriteBack(buf[:n], from)
<mask> if err != nil {
<mask> return
<mask> }
<mask> DefaultManager.Download() <- int64(n)
<mask> }
<mask> }
<mask>
<mask> func handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
<mask> relay(request, outbound)
</s> Fix: udp traffic track (#608) </s> remove DefaultManager.Upload() <- int64(len(packet.Data()))
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/206767247ea4c7f2a7ee4986ec638e54ad0dda35 | tunnel/connection.go | |
func (ut *udpTracker) WriteWithMetadata(p []byte, metadata *C.Metadata) (int, error) {
n, err := ut.PacketConn.WriteWithMetadata(p, metadata)
upload := int64(n)
ut.manager.Upload() <- upload
ut.UploadTotal += upload
return n, err
}
| <mask> return n, err
<mask> }
<mask>
<mask> func (ut *udpTracker) Close() error {
<mask> ut.manager.Leave(ut)
<mask> return ut.PacketConn.Close()
<mask> }
</s> Fix: udp traffic track (#608) </s> remove DefaultManager.Download() <- int64(n)
</s> add </s> remove DefaultManager.Upload() <- int64(len(packet.Data()))
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/206767247ea4c7f2a7ee4986ec638e54ad0dda35 | tunnel/tracker.go |
metadata.Type = C.HTTP | <mask> // NewHTTP is HTTPAdapter generator
<mask> func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
<mask> metadata := parseHTTPAddr(request)
<mask> if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
<mask> metadata.SrcIP = ip
<mask> metadata.SrcPort = port
<mask> }
<mask> return &HTTPAdapter{
</s> Feature: add experimental connections API </s> remove return &ip, port, nil
</s> add return ip, port, nil </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/http.go |
C "github.com/Dreamacro/clash/constant" | <mask> import (
<mask> "net"
<mask> "net/http"
<mask> )
<mask>
<mask> // NewHTTPS is HTTPAdapter generator
<mask> func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
<mask> metadata := parseHTTPAddr(request)
<mask> metadata.Type = C.HTTPCONNECT
</s> Feature: add experimental connections API </s> remove conn := newTrafficTrack(outbound, t.traffic)
</s> add </s> remove conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
</s> add relay(request, outbound) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/https.go |
metadata.Type = C.HTTPCONNECT | <mask> // NewHTTPS is HTTPAdapter generator
<mask> func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
<mask> metadata := parseHTTPAddr(request)
<mask> if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
<mask> metadata.SrcIP = ip
<mask> metadata.SrcPort = port
<mask> }
<mask> return &SocketAdapter{
</s> Feature: add experimental connections API </s> remove return &ip, port, nil
</s> add return ip, port, nil </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/https.go |
metadata.DstIP = ip | <mask> metadata.Host = string(target[2 : 2+target[1]])
<mask> metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
<mask> case socks5.AtypIPv4:
<mask> ip := net.IP(target[1 : 1+net.IPv4len])
<mask> metadata.DstIP = &ip
<mask> metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
<mask> case socks5.AtypIPv6:
<mask> ip := net.IP(target[1 : 1+net.IPv6len])
<mask> metadata.DstIP = &ip
<mask> metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/util.go |
metadata.DstIP = ip | <mask> metadata.DstIP = &ip
<mask> metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
<mask> case socks5.AtypIPv6:
<mask> ip := net.IP(target[1 : 1+net.IPv6len])
<mask> metadata.DstIP = &ip
<mask> metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
<mask> }
<mask>
<mask> return metadata
<mask> }
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/util.go |
<mask> }
<mask>
<mask> metadata := &C.Metadata{
<mask> NetWork: C.TCP,
<mask> Type: C.HTTP,
<mask> AddrType: C.AtypDomainName,
<mask> Host: host,
<mask> DstIP: nil,
<mask> DstPort: port,
<mask> }
</s> Feature: add experimental connections API </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove return &ip, port, nil
</s> add return ip, port, nil </s> remove return "MATCH"
</s> add return "Match" </s> remove host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/util.go | |
metadata.DstIP = ip | <mask> metadata.AddrType = C.AtypIPv6
<mask> default:
<mask> metadata.AddrType = C.AtypIPv4
<mask> }
<mask> metadata.DstIP = &ip
<mask> }
<mask>
<mask> return metadata
<mask> }
<mask>
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return "MATCH"
</s> add return "Match" </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(metadata.DstIP) </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/util.go |
func parseAddr(addr string) (net.IP, string, error) { | <mask>
<mask> return metadata
<mask> }
<mask>
<mask> func parseAddr(addr string) (*net.IP, string, error) {
<mask> host, port, err := net.SplitHostPort(addr)
<mask> if err != nil {
<mask> return nil, "", err
<mask> }
<mask>
</s> Feature: add experimental connections API </s> remove return &ip, port, nil
</s> add return ip, port, nil </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/util.go |
return ip, port, nil | <mask> return nil, "", err
<mask> }
<mask>
<mask> ip := net.ParseIP(host)
<mask> return &ip, port, nil
<mask> }
</s> Feature: add experimental connections API </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove Type: C.HTTP,
</s> add </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | adapters/inbound/util.go |
mux sync.Mutex | <mask> max uint32
<mask> min uint32
<mask> gateway uint32
<mask> offset uint32
<mask> mux *sync.Mutex
<mask> cache *cache.LruCache
<mask> }
<mask>
<mask> // Lookup return a fake ip with host
<mask> func (p *Pool) Lookup(host string) net.IP {
</s> Feature: add experimental connections API </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove NetWork NetWork
Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string
AddrType int
Host string
</s> add NetWork NetWork `json:"network"`
Type Type `json:"type"`
SrcIP net.IP `json:"sourceIP"`
DstIP net.IP `json:"destinationIP"`
SrcPort string `json:"sourcePort"`
DstPort string `json:"destinationPort"`
AddrType int `json:"-"`
Host string `json:"host"` </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add </s> remove mux: &sync.Mutex{},
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | component/fakeip/pool.go |
<mask> return &Pool{
<mask> min: min,
<mask> max: max,
<mask> gateway: min - 1,
<mask> mux: &sync.Mutex{},
<mask> cache: cache.NewLRUCache(cache.WithSize(size * 2)),
<mask> }, nil
<mask> }
</s> Feature: add experimental connections API </s> remove mux *sync.Mutex
</s> add mux sync.Mutex </s> remove return &ip, port, nil
</s> add return ip, port, nil </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove return "MATCH"
</s> add return "Match" </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | component/fakeip/pool.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.