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 |
|---|---|---|---|---|
<mask> respBodyKey []byte
<mask> respV byte
<mask> security byte
<mask>
<mask> sent bool
<mask> received bool
<mask> }
<mask>
<mask> func (vc *Conn) Write(b []byte) (int, error) {
<mask> if vc.sent {
</s> Fix: vmess handshake block (#117) </s> remove if vc.sent {
return vc.writer.Write(b)
}
if err := vc.sendRequest(); err != nil {
return 0, err
}
vc.sent = true
</s> add </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) *Conn {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) { </s> remove return newConn(conn, c.user[r], dst, c.security), nil
</s> add return newConn(conn, c.user[r], dst, c.security) </s> remove return &Conn{
</s> add c := &Conn{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/287ad5bc531f6fe222a1469278e3d7fcb0c27b56 | component/vmess/conn.go | |
<mask> received bool
<mask> }
<mask>
<mask> func (vc *Conn) Write(b []byte) (int, error) {
<mask> if vc.sent {
<mask> return vc.writer.Write(b)
<mask> }
<mask>
<mask> if err := vc.sendRequest(); err != nil {
<mask> return 0, err
<mask> }
<mask>
<mask> vc.sent = true
<mask> return vc.writer.Write(b)
<mask> }
<mask>
<mask> func (vc *Conn) Read(b []byte) (int, error) {
<mask> if vc.received {
</s> Fix: vmess handshake block (#117) </s> remove sent bool
</s> add </s> remove return newConn(conn, c.user[r], dst, c.security), nil
</s> add return newConn(conn, c.user[r], dst, c.security) </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) *Conn {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) { </s> remove return &Conn{
</s> add c := &Conn{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/287ad5bc531f6fe222a1469278e3d7fcb0c27b56 | component/vmess/conn.go | |
func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) { | <mask> return md5hash.Sum(nil)
<mask> }
<mask>
<mask> // newConn return a Conn instance
<mask> func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) *Conn {
<mask> randBytes := make([]byte, 33)
<mask> rand.Read(randBytes)
<mask> reqBodyIV := make([]byte, 16)
<mask> reqBodyKey := make([]byte, 16)
<mask> copy(reqBodyIV[:], randBytes[:16])
</s> Fix: vmess handshake block (#117) </s> remove return newConn(conn, c.user[r], dst, c.security), nil
</s> add return newConn(conn, c.user[r], dst, c.security) </s> remove if vc.sent {
return vc.writer.Write(b)
}
if err := vc.sendRequest(); err != nil {
return 0, err
}
vc.sent = true
</s> add </s> remove sent bool
</s> add </s> remove return &Conn{
</s> add c := &Conn{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/287ad5bc531f6fe222a1469278e3d7fcb0c27b56 | component/vmess/conn.go |
c := &Conn{ | <mask> aead, _ = chacha20poly1305.New(key)
<mask> reader = newAEADReader(conn, aead, respBodyIV[:])
<mask> }
<mask>
<mask> return &Conn{
<mask> Conn: conn,
<mask> id: id,
<mask> dst: dst,
<mask> reqBodyIV: reqBodyIV,
<mask> reqBodyKey: reqBodyKey,
</s> Fix: vmess handshake block (#117) </s> remove return newConn(conn, c.user[r], dst, c.security), nil
</s> add return newConn(conn, c.user[r], dst, c.security) </s> remove if vc.sent {
return vc.writer.Write(b)
}
if err := vc.sendRequest(); err != nil {
return 0, err
}
vc.sent = true
</s> add </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) *Conn {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) { </s> remove sent bool
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/287ad5bc531f6fe222a1469278e3d7fcb0c27b56 | component/vmess/conn.go |
if err := c.sendRequest(); err != nil {
return nil, err
}
return c, nil | <mask> reader: reader,
<mask> writer: writer,
<mask> security: security,
<mask> }
<mask> }
</s> Fix: vmess handshake block (#117) </s> remove return newConn(conn, c.user[r], dst, c.security), nil
</s> add return newConn(conn, c.user[r], dst, c.security) </s> remove if vc.sent {
return vc.writer.Write(b)
}
if err := vc.sendRequest(); err != nil {
return 0, err
}
vc.sent = true
</s> add </s> remove sent bool
</s> add </s> remove return &Conn{
</s> add c := &Conn{ </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) *Conn {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) { | [
"keep",
"keep",
"keep",
"add",
"keep"
] | https://github.com/Dreamacro/clash/commit/287ad5bc531f6fe222a1469278e3d7fcb0c27b56 | component/vmess/conn.go |
return newConn(conn, c.user[r], dst, c.security) | <mask> }
<mask> } else if c.tls {
<mask> conn = tls.Client(conn, c.tlsConfig)
<mask> }
<mask> return newConn(conn, c.user[r], dst, c.security), nil
<mask> }
<mask>
<mask> // NewClient return Client instance
<mask> func NewClient(config Config) (*Client, error) {
<mask> uid, err := uuid.FromString(config.UUID)
</s> Fix: vmess handshake block (#117) </s> remove if vc.sent {
return vc.writer.Write(b)
}
if err := vc.sendRequest(); err != nil {
return 0, err
}
vc.sent = true
</s> add </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) *Conn {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) { </s> remove sent bool
</s> add </s> remove return &Conn{
</s> add c := &Conn{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/287ad5bc531f6fe222a1469278e3d7fcb0c27b56 | component/vmess/vmess.go |
<mask> package constant
<mask>
<mask> import (
<mask> "archive/tar"
<mask> "compress/gzip"
<mask> "io"
<mask> "net/http"
<mask> "os"
<mask> "os/user"
<mask> "path"
<mask> "strings"
<mask>
</s> Update: Initialize the config file outside of the init function </s> remove "strings"
</s> add </s> remove if _, err := os.Stat(MMDBPath); os.IsNotExist(err) {
log.Info("Can't find MMDB, start download")
err := downloadMMDB(MMDBPath)
if err != nil {
log.Fatalf("Can't download MMDB: %s", err.Error())
}
}
}
func downloadMMDB(path string) (err error) {
resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
if err != nil {
return
}
defer resp.Body.Close()
gr, err := gzip.NewReader(resp.Body)
if err != nil {
return
}
defer gr.Close()
tr := tar.NewReader(gr)
for {
h, err := tr.Next()
if err == io.EOF {
break
} else if err != nil {
return err
}
if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
continue
}
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, tr)
if err != nil {
return err
}
}
return nil
</s> add </s> remove if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
log.Info("Can't find config, create a empty file")
os.OpenFile(ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
}
</s> add | [
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/295d649624193f9be1a4ee41853ae4787a1d470f | constant/config.go | |
<mask> "net/http"
<mask> "os"
<mask> "os/user"
<mask> "path"
<mask> "strings"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
<mask>
<mask> const (
</s> Update: Initialize the config file outside of the init function </s> remove "archive/tar"
"compress/gzip"
"io"
"net/http"
</s> add </s> remove if _, err := os.Stat(MMDBPath); os.IsNotExist(err) {
log.Info("Can't find MMDB, start download")
err := downloadMMDB(MMDBPath)
if err != nil {
log.Fatalf("Can't download MMDB: %s", err.Error())
}
}
}
func downloadMMDB(path string) (err error) {
resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
if err != nil {
return
}
defer resp.Body.Close()
gr, err := gzip.NewReader(resp.Body)
if err != nil {
return
}
defer gr.Close()
tr := tar.NewReader(gr)
for {
h, err := tr.Next()
if err == io.EOF {
break
} else if err != nil {
return err
}
if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
continue
}
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, tr)
if err != nil {
return err
}
}
return nil
</s> add </s> remove if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
log.Info("Can't find config, create a empty file")
os.OpenFile(ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/295d649624193f9be1a4ee41853ae4787a1d470f | constant/config.go | |
<mask> }
<mask> }
<mask>
<mask> ConfigPath = path.Join(dirPath, "config.ini")
<mask> if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
<mask> log.Info("Can't find config, create a empty file")
<mask> os.OpenFile(ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
<mask> }
<mask>
<mask> MMDBPath = path.Join(dirPath, "Country.mmdb")
<mask> if _, err := os.Stat(MMDBPath); os.IsNotExist(err) {
<mask> log.Info("Can't find MMDB, start download")
<mask> err := downloadMMDB(MMDBPath)
<mask> if err != nil {
</s> Update: Initialize the config file outside of the init function </s> remove if _, err := os.Stat(MMDBPath); os.IsNotExist(err) {
log.Info("Can't find MMDB, start download")
err := downloadMMDB(MMDBPath)
if err != nil {
log.Fatalf("Can't download MMDB: %s", err.Error())
}
}
}
func downloadMMDB(path string) (err error) {
resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
if err != nil {
return
}
defer resp.Body.Close()
gr, err := gzip.NewReader(resp.Body)
if err != nil {
return
}
defer gr.Close()
tr := tar.NewReader(gr)
for {
h, err := tr.Next()
if err == io.EOF {
break
} else if err != nil {
return err
}
if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
continue
}
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, tr)
if err != nil {
return err
}
}
return nil
</s> add </s> remove "strings"
</s> add </s> remove "archive/tar"
"compress/gzip"
"io"
"net/http"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/295d649624193f9be1a4ee41853ae4787a1d470f | constant/config.go | |
<mask> os.OpenFile(ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
<mask> }
<mask>
<mask> MMDBPath = path.Join(dirPath, "Country.mmdb")
<mask> if _, err := os.Stat(MMDBPath); os.IsNotExist(err) {
<mask> log.Info("Can't find MMDB, start download")
<mask> err := downloadMMDB(MMDBPath)
<mask> if err != nil {
<mask> log.Fatalf("Can't download MMDB: %s", err.Error())
<mask> }
<mask> }
<mask> }
<mask>
<mask> func downloadMMDB(path string) (err error) {
<mask> resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer resp.Body.Close()
<mask>
<mask> gr, err := gzip.NewReader(resp.Body)
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer gr.Close()
<mask>
<mask> tr := tar.NewReader(gr)
<mask> for {
<mask> h, err := tr.Next()
<mask> if err == io.EOF {
<mask> break
<mask> } else if err != nil {
<mask> return err
<mask> }
<mask>
<mask> if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
<mask> continue
<mask> }
<mask>
<mask> f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> defer f.Close()
<mask> _, err = io.Copy(f, tr)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> }
<mask>
<mask> return nil
<mask> }
</s> Update: Initialize the config file outside of the init function </s> remove if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
log.Info("Can't find config, create a empty file")
os.OpenFile(ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
}
</s> add </s> remove "strings"
</s> add </s> remove "archive/tar"
"compress/gzip"
"io"
"net/http"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/295d649624193f9be1a4ee41853ae4787a1d470f | constant/config.go | |
config.Init() | <mask> hub.Run()
<mask>
<mask> err := config.Instance().Parse()
<mask> if err != nil {
<mask> log.Fatalf("Parse config error: %s", err.Error())
<mask> }
<mask>
</s> Update: Initialize the config file outside of the init function </s> remove if _, err := os.Stat(MMDBPath); os.IsNotExist(err) {
log.Info("Can't find MMDB, start download")
err := downloadMMDB(MMDBPath)
if err != nil {
log.Fatalf("Can't download MMDB: %s", err.Error())
}
}
}
func downloadMMDB(path string) (err error) {
resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
if err != nil {
return
}
defer resp.Body.Close()
gr, err := gzip.NewReader(resp.Body)
if err != nil {
return
}
defer gr.Close()
tr := tar.NewReader(gr)
for {
h, err := tr.Next()
if err == io.EOF {
break
} else if err != nil {
return err
}
if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
continue
}
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, tr)
if err != nil {
return err
}
}
return nil
</s> add </s> remove if _, err := os.Stat(ConfigPath); os.IsNotExist(err) {
log.Info("Can't find config, create a empty file")
os.OpenFile(ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
}
</s> add </s> remove "strings"
</s> add </s> remove "archive/tar"
"compress/gzip"
"io"
"net/http"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/295d649624193f9be1a4ee41853ae4787a1d470f | main.go |
// socks5, server, port
case "socks5":
if len(proxy) < 3 {
continue
}
addr := fmt.Sprintf("%s:%s", proxy[1], proxy[2])
socks5 := adapters.NewSocks5(key.Name(), addr)
proxies[key.Name()] = socks5 | <mask> return err
<mask> }
<mask> proxies[key.Name()] = ss
<mask> }
<mask> }
<mask>
<mask> // parse proxy group
<mask> for _, key := range groupsConfig.Keys() {
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | config/config.go |
<mask> if event.Payload.(bool) == false {
<mask> log.Errorf("Listening HTTP proxy at %s error", c.general.Port)
<mask> c.general.Port = 0
<mask> }
<mask> break
<mask> case "socks-addr":
<mask> if event.Payload.(bool) == false {
<mask> log.Errorf("Listening SOCKS proxy at %s error", c.general.SocksPort)
<mask> c.general.SocksPort = 0
<mask> }
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | config/config.go | |
<mask> if event.Payload.(bool) == false {
<mask> log.Errorf("Listening SOCKS proxy at %s error", c.general.SocksPort)
<mask> c.general.SocksPort = 0
<mask> }
<mask> break
<mask> case "redir-addr":
<mask> if event.Payload.(bool) == false {
<mask> log.Errorf("Listening Redir proxy at %s error", c.general.RedirPort)
<mask> c.general.RedirPort = 0
<mask> }
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | config/config.go | |
<mask> if event.Payload.(bool) == false {
<mask> log.Errorf("Listening Redir proxy at %s error", c.general.RedirPort)
<mask> c.general.RedirPort = 0
<mask> }
<mask> break
<mask> }
<mask> }
<mask> }
<mask>
<mask> func newConfig() *Config {
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | config/config.go | |
Socks5 | <mask> Reject
<mask> Selector
<mask> Shadowsocks
<mask> URLTest
<mask> )
<mask>
<mask> type ProxyAdapter interface {
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | constant/adapters.go |
case Socks5:
return "Socks5" | <mask> case Shadowsocks:
<mask> return "Shadowsocks"
<mask> case URLTest:
<mask> return "URLTest"
<mask> default:
<mask> return "Unknow"
<mask> }
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | constant/adapters.go |
<mask> case "http-addr":
<mask> addr := event.Payload.(string)
<mask> err := l.updateHTTP(addr)
<mask> reportCH <- &config.Event{Type: "http-addr", Payload: err == nil}
<mask> break
<mask> case "socks-addr":
<mask> addr := event.Payload.(string)
<mask> err := l.updateSocks(addr)
<mask> reportCH <- &config.Event{Type: "socks-addr", Payload: err == nil}
<mask> break
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | proxy/listener.go | |
<mask> case "socks-addr":
<mask> addr := event.Payload.(string)
<mask> err := l.updateSocks(addr)
<mask> reportCH <- &config.Event{Type: "socks-addr", Payload: err == nil}
<mask> break
<mask> case "redir-addr":
<mask> addr := event.Payload.(string)
<mask> err := l.updateRedir(addr)
<mask> reportCH <- &config.Event{Type: "redir-addr", Payload: err == nil}
<mask> break
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | proxy/listener.go | |
<mask> case "redir-addr":
<mask> addr := event.Payload.(string)
<mask> err := l.updateRedir(addr)
<mask> reportCH <- &config.Event{Type: "redir-addr", Payload: err == nil}
<mask> break
<mask> }
<mask> }
<mask> }
<mask>
<mask> // Run ensure config monitoring
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | proxy/listener.go | |
<mask>
<mask> switch adapter := localConn.(type) {
<mask> case *LocalAdapter.HttpAdapter:
<mask> t.handleHTTP(adapter, remoConn)
<mask> break
<mask> case *LocalAdapter.SocksAdapter:
<mask> t.handleSOCKS(adapter, remoConn)
<mask> break
<mask> }
<mask> }
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | tunnel/tunnel.go | |
<mask> t.handleHTTP(adapter, remoConn)
<mask> break
<mask> case *LocalAdapter.SocksAdapter:
<mask> t.handleSOCKS(adapter, remoConn)
<mask> break
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) match(addr *C.Addr) C.Proxy {
<mask> t.configLock.RLock()
</s> New: custom socks5 proxy support </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add </s> remove break
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2b87b907aebc814ba82493e62032f616ac573eae | tunnel/tunnel.go | |
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go u.speedTest(ctx) | <mask> }
<mask>
<mask> func (u *URLTest) loop() {
<mask> tick := time.NewTicker(u.interval)
<mask> go u.speedTest()
<mask> Loop:
<mask> for {
<mask> select {
<mask> case <-tick.C:
<mask> go u.speedTest()
</s> Optimization: use context in urltest speed test (#356) </s> remove go u.speedTest()
</s> add go u.speedTest(ctx) </s> remove func (u *URLTest) speedTest() {
</s> add func (u *URLTest) speedTest(ctx context.Context) { </s> remove ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(ctx, defaultURLTestTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2c82a2bfc84fd112ae6227ca3465203ec311616d | adapters/outbound/urltest.go |
go u.speedTest(ctx) | <mask> Loop:
<mask> for {
<mask> select {
<mask> case <-tick.C:
<mask> go u.speedTest()
<mask> case <-u.done:
<mask> break Loop
<mask> }
<mask> }
<mask> }
</s> Optimization: use context in urltest speed test (#356) </s> remove func (u *URLTest) speedTest() {
</s> add func (u *URLTest) speedTest(ctx context.Context) { </s> remove go u.speedTest()
</s> add ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go u.speedTest(ctx) </s> remove ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(ctx, defaultURLTestTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2c82a2bfc84fd112ae6227ca3465203ec311616d | adapters/outbound/urltest.go |
func (u *URLTest) speedTest(ctx context.Context) { | <mask> }
<mask> u.fast = fast
<mask> }
<mask>
<mask> func (u *URLTest) speedTest() {
<mask> if !atomic.CompareAndSwapInt32(&u.once, 0, 1) {
<mask> return
<mask> }
<mask> defer atomic.StoreInt32(&u.once, 0)
<mask>
</s> Optimization: use context in urltest speed test (#356) </s> remove go u.speedTest()
</s> add go u.speedTest(ctx) </s> remove go u.speedTest()
</s> add ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go u.speedTest(ctx) </s> remove ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> add ctx, cancel := context.WithTimeout(ctx, defaultURLTestTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2c82a2bfc84fd112ae6227ca3465203ec311616d | adapters/outbound/urltest.go |
ctx, cancel := context.WithTimeout(ctx, defaultURLTestTimeout) | <mask> return
<mask> }
<mask> defer atomic.StoreInt32(&u.once, 0)
<mask>
<mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> defer cancel()
<mask> picker := picker.WithoutAutoCancel(ctx)
<mask> for _, p := range u.proxies {
<mask> proxy := p
<mask> picker.Go(func() (interface{}, error) {
</s> Optimization: use context in urltest speed test (#356) </s> remove go u.speedTest()
</s> add ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go u.speedTest(ctx) </s> remove func (u *URLTest) speedTest() {
</s> add func (u *URLTest) speedTest(ctx context.Context) { </s> remove go u.speedTest()
</s> add go u.speedTest(ctx) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2c82a2bfc84fd112ae6227ca3465203ec311616d | adapters/outbound/urltest.go |
func (t *Table) GetOrCreateLock(key string) (*sync.Cond, bool) {
item, loaded := t.mapping.LoadOrStore(key, sync.NewCond(&sync.Mutex{}))
return item.(*sync.Cond), loaded | <mask> }
<mask> return item.(C.PacketConn)
<mask> }
<mask>
<mask> func (t *Table) GetOrCreateLock(key string) (*sync.WaitGroup, bool) {
<mask> item, loaded := t.mapping.LoadOrStore(key, &sync.WaitGroup{})
<mask> return item.(*sync.WaitGroup), loaded
<mask> }
<mask>
<mask> func (t *Table) Delete(key string) {
<mask> t.mapping.Delete(key)
<mask> }
</s> Fix: tunnel UDP race condition (#1043) </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { </s> remove wg, loaded := natTable.GetOrCreateLock(lockKey)
</s> add cond, loaded := natTable.GetOrCreateLock(lockKey) </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | component/nat/table.go |
// make a fAddr if request ip is fakeip | <mask> log.Warnln("[Metadata] not valid: %#v", metadata)
<mask> return
<mask> }
<mask>
<mask> // make a fAddr if requset ip is fakeip
<mask> var fAddr net.Addr
<mask> if resolver.IsExistFakeIP(metadata.DstIP) {
<mask> fAddr = metadata.UDPAddr()
<mask> }
<mask>
</s> Fix: tunnel UDP race condition (#1043) </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return </s> remove wg, loaded := natTable.GetOrCreateLock(lockKey)
</s> add cond, loaded := natTable.GetOrCreateLock(lockKey) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { | <mask> return
<mask> }
<mask>
<mask> key := packet.LocalAddr().String()
<mask> pc := natTable.Get(key)
<mask> if pc != nil {
<mask> handleUDPToRemote(packet, pc, metadata)
<mask> return
<mask> }
<mask>
<mask> lockKey := key + "-lock"
<mask> wg, loaded := natTable.GetOrCreateLock(lockKey)
</s> Fix: tunnel UDP race condition (#1043) </s> remove wg, loaded := natTable.GetOrCreateLock(lockKey)
</s> add cond, loaded := natTable.GetOrCreateLock(lockKey) </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return </s> remove func (t *Table) GetOrCreateLock(key string) (*sync.WaitGroup, bool) {
item, loaded := t.mapping.LoadOrStore(key, &sync.WaitGroup{})
return item.(*sync.WaitGroup), loaded
</s> add func (t *Table) GetOrCreateLock(key string) (*sync.Cond, bool) {
item, loaded := t.mapping.LoadOrStore(key, sync.NewCond(&sync.Mutex{}))
return item.(*sync.Cond), loaded | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
cond, loaded := natTable.GetOrCreateLock(lockKey) | <mask> return
<mask> }
<mask>
<mask> lockKey := key + "-lock"
<mask> wg, loaded := natTable.GetOrCreateLock(lockKey)
<mask>
<mask> go func() {
<mask> if !loaded {
<mask> wg.Add(1)
<mask> proxy, rule, err := resolveMetadata(metadata)
</s> Fix: tunnel UDP race condition (#1043) </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return </s> remove func (t *Table) GetOrCreateLock(key string) (*sync.WaitGroup, bool) {
item, loaded := t.mapping.LoadOrStore(key, &sync.WaitGroup{})
return item.(*sync.WaitGroup), loaded
</s> add func (t *Table) GetOrCreateLock(key string) (*sync.Cond, bool) {
item, loaded := t.mapping.LoadOrStore(key, sync.NewCond(&sync.Mutex{}))
return item.(*sync.Cond), loaded </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} | <mask> lockKey := key + "-lock"
<mask> wg, loaded := natTable.GetOrCreateLock(lockKey)
<mask>
<mask> go func() {
<mask> if !loaded {
<mask> wg.Add(1)
<mask> proxy, rule, err := resolveMetadata(metadata)
<mask> if err != nil {
<mask> log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
<mask> natTable.Delete(lockKey)
<mask> wg.Done()
<mask> return
<mask> }
<mask>
<mask> rawPc, err := proxy.DialUDP(metadata)
<mask> if err != nil {
<mask> log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
<mask> natTable.Delete(lockKey)
<mask> wg.Done()
<mask> return
<mask> }
<mask> pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
<mask>
<mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask>
<mask> natTable.Set(key, pc)
<mask> natTable.Delete(lockKey)
<mask> wg.Done()
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> Fix: tunnel UDP race condition (#1043) </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return </s> remove wg, loaded := natTable.GetOrCreateLock(lockKey)
</s> add cond, loaded := natTable.GetOrCreateLock(lockKey) </s> remove natTable.Set(key, pc)
</s> add defer func() { </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
defer func() { | <mask> default:
<mask> log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask>
<mask> natTable.Set(key, pc)
<mask> natTable.Delete(lockKey)
<mask> wg.Done()
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
<mask> }
<mask>
</s> Fix: tunnel UDP race condition (#1043) </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return | <mask> }
<mask>
<mask> natTable.Set(key, pc)
<mask> natTable.Delete(lockKey)
<mask> wg.Done()
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
<mask> }
<mask>
<mask> wg.Wait()
<mask> pc := natTable.Get(key)
<mask> if pc != nil {
</s> Fix: tunnel UDP race condition (#1043) </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove natTable.Set(key, pc)
</s> add defer func() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) | <mask> wg.Done()
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
<mask> }
<mask>
<mask> wg.Wait()
<mask> pc := natTable.Get(key)
<mask> if pc != nil {
<mask> handleUDPToRemote(packet, pc, metadata)
<mask> }
<mask> }()
<mask> }
<mask>
<mask> func handleTCPConn(localConn C.ServerAdapter) {
</s> Fix: tunnel UDP race condition (#1043) </s> remove pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add handle := func() bool {
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
return true
}
return false
}
if handle() { </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove natTable.Set(key, pc)
</s> add defer func() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
natTable.Set(key, pc)
handle() | <mask> default:
<mask> log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask> }()
<mask> }
<mask>
<mask> func handleTCPConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
</s> Fix: tunnel UDP race condition (#1043) </s> remove wg.Wait()
pc := natTable.Get(key)
if pc != nil {
handleUDPToRemote(packet, pc, metadata)
</s> add rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
return
}
pc := newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String()) </s> remove natTable.Set(key, pc)
</s> add defer func() { </s> remove if !loaded {
wg.Add(1)
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("[UDP] dial %s error: %s", proxy.Name(), err.Error())
natTable.Delete(lockKey)
wg.Done()
return
}
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule)
switch true {
case rule != nil:
log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
case mode == Global:
log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
case mode == Direct:
log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
default:
log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
}
</s> add if loaded {
cond.L.Lock()
cond.Wait()
handle()
cond.L.Unlock()
return
} </s> remove func (t *Table) GetOrCreateLock(key string) (*sync.WaitGroup, bool) {
item, loaded := t.mapping.LoadOrStore(key, &sync.WaitGroup{})
return item.(*sync.WaitGroup), loaded
</s> add func (t *Table) GetOrCreateLock(key string) (*sync.Cond, bool) {
item, loaded := t.mapping.LoadOrStore(key, sync.NewCond(&sync.Mutex{}))
return item.(*sync.Cond), loaded </s> remove wg.Done()
go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add cond.Broadcast()
}()
proxy, rule, err := resolveMetadata(metadata)
if err != nil {
log.Warnln("[UDP] Parse metadata failed: %s", err.Error())
return | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2cd1b890ce211ab7bd54857099a123c2ba840ab5 | tunnel/tunnel.go |
"net/netip" | <mask>
<mask> import (
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
<mask>
<mask> type packet struct {
</s> Chore: update tproxy udp packet read logic </s> remove lAddr *net.UDPAddr
</s> add lAddr netip.AddrPort </s> remove "encoding/binary"
"errors"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/packet.go |
lAddr netip.AddrPort | <mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
<mask>
<mask> type packet struct {
<mask> lAddr *net.UDPAddr
<mask> buf []byte
<mask> }
<mask>
<mask> func (c *packet) Data() []byte {
<mask> return c.buf
</s> Chore: update tproxy udp packet read logic </s> remove return c.lAddr
</s> add return &net.UDPAddr{IP: c.lAddr.Addr().AsSlice(), Port: int(c.lAddr.Port()), Zone: c.lAddr.Addr().Zone()} </s> remove tc, err := dialUDP("udp", addr.(*net.UDPAddr), c.lAddr)
</s> add tc, err := dialUDP("udp", addr.(*net.UDPAddr).AddrPort(), c.lAddr) </s> remove func handlePacketConn(pc net.PacketConn, in chan<- *inbound.PacketAdapter, buf []byte, lAddr *net.UDPAddr, rAddr *net.UDPAddr) {
target := socks5.ParseAddrToSocksAddr(rAddr)
</s> add func handlePacketConn(in chan<- *inbound.PacketAdapter, buf []byte, lAddr, rAddr netip.AddrPort) {
target := socks5.AddrFromStdAddrPort(rAddr) </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
return nil, errors.New("UDP redir not supported on current platform")
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/packet.go |
tc, err := dialUDP("udp", addr.(*net.UDPAddr).AddrPort(), c.lAddr) | <mask> }
<mask>
<mask> // WriteBack opens a new socket binding `addr` to write UDP packet back
<mask> func (c *packet) WriteBack(b []byte, addr net.Addr) (n int, err error) {
<mask> tc, err := dialUDP("udp", addr.(*net.UDPAddr), c.lAddr)
<mask> if err != nil {
<mask> n = 0
<mask> return
<mask> }
<mask> n, err = tc.Write(b)
</s> Chore: update tproxy udp packet read logic </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove return c.lAddr
</s> add return &net.UDPAddr{IP: c.lAddr.Addr().AsSlice(), Port: int(c.lAddr.Port()), Zone: c.lAddr.Addr().Zone()} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/packet.go |
return &net.UDPAddr{IP: c.lAddr.Addr().AsSlice(), Port: int(c.lAddr.Port()), Zone: c.lAddr.Addr().Zone()} | <mask> }
<mask>
<mask> // LocalAddr returns the source IP/Port of UDP Packet
<mask> func (c *packet) LocalAddr() net.Addr {
<mask> return c.lAddr
<mask> }
<mask>
<mask> func (c *packet) Drop() {
<mask> pool.Put(c.buf)
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove lAddr *net.UDPAddr
</s> add lAddr netip.AddrPort </s> remove tc, err := dialUDP("udp", addr.(*net.UDPAddr), c.lAddr)
</s> add tc, err := dialUDP("udp", addr.(*net.UDPAddr).AddrPort(), c.lAddr) </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/packet.go |
"net/netip" | <mask> package tproxy
<mask>
<mask> import (
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/adapter/inbound"
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Chore: update tproxy udp packet read logic </s> remove "encoding/binary"
"errors"
</s> add </s> remove lAddr *net.UDPAddr
</s> add lAddr netip.AddrPort | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp.go |
n, oobn, _, lAddr, err := c.ReadMsgUDPAddrPort(buf, oob) | <mask> go func() {
<mask> oob := make([]byte, 1024)
<mask> for {
<mask> buf := pool.Get(pool.UDPBufferSize)
<mask> n, oobn, _, lAddr, err := c.ReadMsgUDP(buf, oob)
<mask> if err != nil {
<mask> pool.Put(buf)
<mask> if rl.closed {
<mask> break
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove return nil, err
</s> add return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp.go |
rAddr, err := getOrigDst(oob[:oobn]) | <mask> }
<mask> continue
<mask> }
<mask>
<mask> rAddr, err := getOrigDst(oob, oobn)
<mask> if err != nil {
<mask> continue
<mask> }
<mask> handlePacketConn(l, in, buf[:n], lAddr, rAddr)
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove handlePacketConn(l, in, buf[:n], lAddr, rAddr)
</s> add handlePacketConn(in, buf[:n], lAddr, rAddr) </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp.go |
handlePacketConn(in, buf[:n], lAddr, rAddr) | <mask> rAddr, err := getOrigDst(oob, oobn)
<mask> if err != nil {
<mask> continue
<mask> }
<mask> handlePacketConn(l, in, buf[:n], lAddr, rAddr)
<mask> }
<mask> }()
<mask>
<mask> return rl, nil
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove rAddr, err := getOrigDst(oob, oobn)
</s> add rAddr, err := getOrigDst(oob[:oobn]) </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp.go |
func handlePacketConn(in chan<- *inbound.PacketAdapter, buf []byte, lAddr, rAddr netip.AddrPort) {
target := socks5.AddrFromStdAddrPort(rAddr) | <mask>
<mask> return rl, nil
<mask> }
<mask>
<mask> func handlePacketConn(pc net.PacketConn, in chan<- *inbound.PacketAdapter, buf []byte, lAddr *net.UDPAddr, rAddr *net.UDPAddr) {
<mask> target := socks5.ParseAddrToSocksAddr(rAddr)
<mask> pkt := &packet{
<mask> lAddr: lAddr,
<mask> buf: buf,
<mask> }
<mask> select {
</s> Chore: update tproxy udp packet read logic </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (*net.UDPConn, error) { </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { </s> remove handlePacketConn(l, in, buf[:n], lAddr, rAddr)
</s> add handlePacketConn(in, buf[:n], lAddr, rAddr) </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
return nil, errors.New("UDP redir not supported on current platform")
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") </s> remove func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
</s> add func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp.go |
<mask>
<mask> package tproxy
<mask>
<mask> import (
<mask> "encoding/binary"
<mask> "errors"
<mask> "fmt"
<mask> "net"
<mask> "os"
<mask> "strconv"
<mask> "syscall"
</s> Chore: update tproxy udp packet read logic | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go | |
"net/netip" | <mask> "fmt"
<mask> "net"
<mask> "os"
<mask> "strconv"
<mask> "syscall"
<mask>
<mask> "golang.org/x/sys/unix"
</s> Chore: update tproxy udp packet read logic </s> remove "encoding/binary"
"errors"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
"golang.org/x/sys/unix" | <mask> "os"
<mask> "strconv"
<mask> "syscall"
<mask> )
<mask>
<mask> const (
<mask> IPV6_TRANSPARENT = 0x4b
<mask> IPV6_RECVORIGDSTADDR = 0x4a
<mask> )
</s> Chore: update tproxy udp packet read logic </s> remove "encoding/binary"
"errors"
</s> add </s> remove lAddr *net.UDPAddr
</s> add lAddr netip.AddrPort | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { | <mask> )
<mask>
<mask> // dialUDP acts like net.DialUDP for transparent proxy.
<mask> // It binds to a non-local address(`lAddr`).
<mask> func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
<mask> rSockAddr, err := udpAddrToSockAddr(rAddr)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Chore: update tproxy udp packet read logic </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (*net.UDPConn, error) { </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
return nil, errors.New("UDP redir not supported on current platform")
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") </s> remove tc, err := dialUDP("udp", addr.(*net.UDPAddr), c.lAddr)
</s> add tc, err := dialUDP("udp", addr.(*net.UDPAddr).AddrPort(), c.lAddr) </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
defer func() {
if err != nil {
syscall.Close(fd)
}
}()
| <mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Chore: update tproxy udp packet read logic </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
<mask> syscall.Close(fd)
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.SetsockoptInt(fd, syscall.SOL_IP, syscall.IP_TRANSPARENT, 1); err != nil {
<mask> syscall.Close(fd)
</s> Chore: update tproxy udp packet read logic </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go | |
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.SetsockoptInt(fd, syscall.SOL_IP, syscall.IP_TRANSPARENT, 1); err != nil {
<mask> syscall.Close(fd)
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.Bind(fd, lSockAddr); err != nil {
<mask> syscall.Close(fd)
</s> Chore: update tproxy udp packet read logic </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go | |
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.Bind(fd, lSockAddr); err != nil {
<mask> syscall.Close(fd)
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.Connect(fd, rSockAddr); err != nil {
<mask> syscall.Close(fd)
</s> Chore: update tproxy udp packet read logic </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go | |
<mask> return nil, err
<mask> }
<mask>
<mask> if err = syscall.Connect(fd, rSockAddr); err != nil {
<mask> syscall.Close(fd)
<mask> return nil, err
<mask> }
<mask>
<mask> fdFile := os.NewFile(uintptr(fd), fmt.Sprintf("net-udp-dial-%s", rAddr.String()))
<mask> defer fdFile.Close()
</s> Chore: update tproxy udp packet read logic </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go | |
<mask> defer fdFile.Close()
<mask>
<mask> c, err := net.FileConn(fdFile)
<mask> if err != nil {
<mask> syscall.Close(fd)
<mask> return nil, err
<mask> }
<mask>
<mask> return c.(*net.UDPConn), nil
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go | |
func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} | <mask>
<mask> return c.(*net.UDPConn), nil
<mask> }
<mask>
<mask> func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
<mask> switch {
<mask> case addr.IP.To4() != nil:
<mask> ip := [4]byte{}
<mask> copy(ip[:], addr.IP.To4())
<mask>
<mask> return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
<mask>
<mask> default:
<mask> ip := [16]byte{}
<mask> copy(ip[:], addr.IP.To16())
<mask>
<mask> zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
<mask> if err != nil {
<mask> zoneID = 0
<mask> }
<mask>
<mask> return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
<mask> }
<mask> }
<mask>
</s> Chore: update tproxy udp packet read logic </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
</s> add func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove syscall.Close(fd)
</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/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 | <mask> if err != nil {
<mask> zoneID = 0
<mask> }
<mask>
<mask> return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
<mask> }
<mask> }
<mask>
<mask> func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
<mask> switch net[len(net)-1] {
</s> Chore: update tproxy udp packet read logic </s> remove func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
</s> add func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
return &syscall.SockaddrInet6{Addr: addr.Addr().As16(), Port: int(addr.Port()), ZoneId: uint32(zoneID)}, nil | <mask> if err != nil {
<mask> zoneID = 0
<mask> }
<mask> }
<mask>
<mask> func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int {
<mask> switch net[len(net)-1] {
</s> Chore: update tproxy udp packet read logic </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
</s> add func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { | <mask> return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
<mask> }
<mask> }
<mask>
<mask> func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
<mask> switch net[len(net)-1] {
<mask> case '4':
<mask> return syscall.AF_INET
<mask> case '6':
<mask> return syscall.AF_INET6
</s> Chore: update tproxy udp packet read logic </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} </s> remove if (lAddr == nil || lAddr.IP.To4() != nil) && (rAddr == nil || lAddr.IP.To4() != nil) {
</s> add if lAddr.Addr().Is4() && rAddr.Addr().Is4() { </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
if lAddr.Addr().Is4() && rAddr.Addr().Is4() { | <mask> case '6':
<mask> return syscall.AF_INET6
<mask> }
<mask>
<mask> if (lAddr == nil || lAddr.IP.To4() != nil) && (rAddr == nil || lAddr.IP.To4() != nil) {
<mask> return syscall.AF_INET
<mask> }
<mask> return syscall.AF_INET6
<mask> }
<mask>
</s> Chore: update tproxy udp packet read logic </s> remove func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
</s> add func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove return nil, err
</s> add return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) | <mask> }
<mask> return syscall.AF_INET6
<mask> }
<mask>
<mask> func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
<mask> msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> for _, msg := range msgs {
</s> Chore: update tproxy udp packet read logic </s> remove return nil, err
</s> add return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (*net.UDPConn, error) { </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
return nil, errors.New("UDP redir not supported on current platform")
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) | <mask>
<mask> func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
<mask> msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> for _, msg := range msgs {
<mask> if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
<mask> ip := net.IP(msg.Data[4:8])
</s> Chore: update tproxy udp packet read logic </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove if (lAddr == nil || lAddr.IP.To4() != nil) && (rAddr == nil || lAddr.IP.To4() != nil) {
</s> add if lAddr.Addr().Is4() && rAddr.Addr().Is4() { </s> remove n, oobn, _, lAddr, err := c.ReadMsgUDP(buf, oob)
</s> add n, oobn, _, lAddr, err := c.ReadMsgUDPAddrPort(buf, oob) </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
// retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> for _, msg := range msgs {
<mask> if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
<mask> ip := net.IP(msg.Data[4:8])
<mask> port := binary.BigEndian.Uint16(msg.Data[2:4])
<mask> return &net.UDPAddr{IP: ip, Port: int(port)}, nil
<mask> } else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
<mask> ip := net.IP(msg.Data[8:24])
<mask> port := binary.BigEndian.Uint16(msg.Data[2:4])
<mask> return &net.UDPAddr{IP: ip, Port: int(port)}, nil
<mask> }
<mask> }
<mask>
<mask> return nil, errors.New("cannot find origDst")
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove return nil, err
</s> add return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) </s> remove return nil, errors.New("cannot find origDst")
</s> add return rAddr, nil </s> remove if (lAddr == nil || lAddr.IP.To4() != nil) && (rAddr == nil || lAddr.IP.To4() != nil) {
</s> add if lAddr.Addr().Is4() && rAddr.Addr().Is4() { </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
return rAddr, nil | <mask> return &net.UDPAddr{IP: ip, Port: int(port)}, nil
<mask> }
<mask> }
<mask>
<mask> return nil, errors.New("cannot find origDst")
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove for _, msg := range msgs {
if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
ip := net.IP(msg.Data[4:8])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
ip := net.IP(msg.Data[8:24])
port := binary.BigEndian.Uint16(msg.Data[2:4])
return &net.UDPAddr{IP: ip, Port: int(port)}, nil
}
</s> add // retrieve the destination address from the SCM.
sa, err := unix.ParseOrigDstAddr(&scms[0])
if err != nil {
return netip.AddrPort{}, fmt.Errorf("retrieve destination: %w", err)
}
// encode the destination address into a cmsg.
var rAddr netip.AddrPort
switch v := sa.(type) {
case *unix.SockaddrInet4:
rAddr = netip.AddrPortFrom(netip.AddrFrom4(v.Addr), uint16(v.Port))
case *unix.SockaddrInet6:
rAddr = netip.AddrPortFrom(netip.AddrFrom16(v.Addr), uint16(v.Port))
default:
return netip.AddrPort{}, fmt.Errorf("unsupported address type: %T", v) </s> remove func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
switch {
case addr.IP.To4() != nil:
ip := [4]byte{}
copy(ip[:], addr.IP.To4())
return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
default:
ip := [16]byte{}
copy(ip[:], addr.IP.To16())
zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
if err != nil {
zoneID = 0
}
</s> add func udpAddrToSockAddr(addr netip.AddrPort) (syscall.Sockaddr, error) {
if addr.Addr().Is4() {
return &syscall.SockaddrInet4{Addr: addr.Addr().As4(), Port: int(addr.Port())}, nil
} </s> remove return c.lAddr
</s> add return &net.UDPAddr{IP: c.lAddr.Addr().AsSlice(), Port: int(c.lAddr.Port()), Zone: c.lAddr.Addr().Zone()} </s> remove func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
</s> add func udpAddrFamily(net string, lAddr, rAddr netip.AddrPort) int { </s> remove return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
</s> add zoneID, err := strconv.ParseUint(addr.Addr().Zone(), 10, 32)
if err != nil {
zoneID = 0 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_linux.go |
"net/netip" | <mask>
<mask> import (
<mask> "errors"
<mask> "net"
<mask> )
<mask>
<mask> func getOrigDst(oob []byte) (netip.AddrPort, error) {
<mask> return netip.AddrPort{}, errors.New("UDP redir not supported on current platform")
<mask> }
<mask>
</s> Chore: update tproxy udp packet read logic </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
return nil, errors.New("UDP redir not supported on current platform")
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (*net.UDPConn, error) { </s> remove "encoding/binary"
"errors"
</s> add </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_other.go |
func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") | <mask> "errors"
<mask> "net"
<mask> )
<mask>
<mask> func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
<mask> return nil, errors.New("UDP redir not supported on current platform")
<mask> }
<mask>
<mask> func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
<mask> return nil, errors.New("UDP redir not supported on current platform")
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (*net.UDPConn, error) { </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove return nil, err
</s> add return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_other.go |
func dialUDP(network string, lAddr, rAddr netip.AddrPort) (*net.UDPConn, error) { | <mask> func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
<mask> return nil, errors.New("UDP redir not supported on current platform")
<mask> }
<mask>
<mask> func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
<mask> return nil, errors.New("UDP redir not supported on current platform")
<mask> }
</s> Chore: update tproxy udp packet read logic </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
return nil, errors.New("UDP redir not supported on current platform")
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
return netip.AddrPort{}, errors.New("UDP redir not supported on current platform") </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove return nil, err
</s> add return netip.AddrPort{}, fmt.Errorf("parse control message: %w", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | listener/tproxy/udp_other.go |
func AddrFromStdAddrPort(addrPort netip.AddrPort) Addr {
addr := addrPort.Addr()
if addr.Is4() {
ip4 := addr.As4()
return []byte{AtypIPv4, ip4[0], ip4[1], ip4[2], ip4[3], byte(addrPort.Port() >> 8), byte(addrPort.Port())}
}
buf := make([]byte, 1+net.IPv6len+2)
buf[0] = AtypIPv6
copy(buf[1:], addr.AsSlice())
buf[1+net.IPv6len] = byte(addrPort.Port() >> 8)
buf[1+net.IPv6len+1] = byte(addrPort.Port())
return buf
}
| <mask> }
<mask> return parsed
<mask> }
<mask>
<mask> // DecodeUDPPacket split `packet` to addr payload, and this function is mutable with `packet`
<mask> func DecodeUDPPacket(packet []byte) (addr Addr, payload []byte, err error) {
<mask> if len(packet) < 5 {
<mask> err = errors.New("insufficient length of packet")
</s> Chore: update tproxy udp packet read logic </s> remove func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
</s> add func getOrigDst(oob []byte) (netip.AddrPort, error) {
// oob contains socket control messages which we need to parse.
scms, err := unix.ParseSocketControlMessage(oob) </s> remove tc, err := dialUDP("udp", addr.(*net.UDPAddr), c.lAddr)
</s> add tc, err := dialUDP("udp", addr.(*net.UDPAddr).AddrPort(), c.lAddr) </s> remove func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
</s> add func dialUDP(network string, lAddr, rAddr netip.AddrPort) (uc *net.UDPConn, err error) { </s> remove syscall.Close(fd)
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fa1a5c4b98f24388a99a8e4279c79c82e52027f | transport/socks5/socks5.go |
"github.com/Dreamacro/clash/adapters/outbound"
"github.com/Dreamacro/clash/common/observable" | <mask> "strings"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/remote"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
<mask> R "github.com/Dreamacro/clash/rules"
<mask>
<mask> log "github.com/sirupsen/logrus"
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove LocalAdapter "github.com/Dreamacro/clash/adapters/local"
</s> add InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
"github.com/Dreamacro/clash/common/observable" </s> remove A "github.com/Dreamacro/clash/adapters/remote"
</s> add A "github.com/Dreamacro/clash/adapters/outbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | config/config.go |
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/remote"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
<mask> R "github.com/Dreamacro/clash/rules"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> "gopkg.in/ini.v1"
<mask> )
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/adapters/remote"
</s> add "github.com/Dreamacro/clash/adapters/outbound"
"github.com/Dreamacro/clash/common/observable" </s> remove A "github.com/Dreamacro/clash/adapters/remote"
</s> add A "github.com/Dreamacro/clash/adapters/outbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/observable"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | config/config.go | |
Metadata() *Metadata | <mask> Close()
<mask> }
<mask>
<mask> type ServerAdapter interface {
<mask> Addr() *Addr
<mask> Close()
<mask> }
<mask>
<mask> type Proxy interface {
<mask> Name() string
</s> Chore: make the code more semantic </s> remove Generator(addr *Addr) (ProxyAdapter, error)
</s> add Generator(metadata *Metadata) (ProxyAdapter, error) </s> remove IsMatch(addr *Addr) bool
</s> add IsMatch(metadata *Metadata) bool </s> remove return i.ipnet.Contains(*addr.IP)
</s> add return i.ipnet.Contains(*metadata.IP) </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove func (f *Final) IsMatch(addr *C.Addr) bool {
</s> add func (f *Final) IsMatch(metadata *C.Metadata) bool { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | constant/adapters.go |
Generator(metadata *Metadata) (ProxyAdapter, error) | <mask>
<mask> type Proxy interface {
<mask> Name() string
<mask> Type() AdapterType
<mask> Generator(addr *Addr) (ProxyAdapter, error)
<mask> }
<mask>
<mask> // AdapterType is enum of adapter type
<mask> type AdapterType int
<mask>
</s> Chore: make the code more semantic </s> remove Addr() *Addr
</s> add Metadata() *Metadata </s> remove IsMatch(addr *Addr) bool
</s> add IsMatch(metadata *Metadata) bool </s> remove case *LocalAdapter.HTTPAdapter:
</s> add case *InboundAdapter.HTTPAdapter: </s> remove case *LocalAdapter.SocketAdapter:
</s> add case *InboundAdapter.SocketAdapter: </s> remove remoConn, err := proxy.Generator(addr)
</s> add remoConn, err := proxy.Generator(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | constant/adapters.go |
IsMatch(metadata *Metadata) bool | <mask> }
<mask>
<mask> type Rule interface {
<mask> RuleType() RuleType
<mask> IsMatch(addr *Addr) bool
<mask> Adapter() string
<mask> Payload() string
<mask> }
</s> Chore: make the code more semantic </s> remove Generator(addr *Addr) (ProxyAdapter, error)
</s> add Generator(metadata *Metadata) (ProxyAdapter, error) </s> remove Addr() *Addr
</s> add Metadata() *Metadata </s> remove func (f *Final) IsMatch(addr *C.Addr) bool {
</s> add func (f *Final) IsMatch(metadata *C.Metadata) bool { </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove domain := addr.Host
</s> add domain := metadata.Host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | constant/rule.go |
A "github.com/Dreamacro/clash/adapters/outbound" | <mask> "net/http"
<mask> "strconv"
<mask> "time"
<mask>
<mask> A "github.com/Dreamacro/clash/adapters/remote"
<mask> C "github.com/Dreamacro/clash/constant"
<mask>
<mask> "github.com/go-chi/chi"
<mask> "github.com/go-chi/render"
<mask> )
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/remote"
</s> add "github.com/Dreamacro/clash/adapters/outbound"
"github.com/Dreamacro/clash/common/observable" </s> remove "github.com/Dreamacro/clash/observable"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | hub/proxies.go |
"github.com/Dreamacro/clash/adapters/inbound" | <mask> "bufio"
<mask> "net"
<mask> "net/http"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/local"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove A "github.com/Dreamacro/clash/adapters/remote"
</s> add A "github.com/Dreamacro/clash/adapters/outbound" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | proxy/http/server.go |
"github.com/Dreamacro/clash/adapters/inbound" | <mask>
<mask> import (
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/local"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> log "github.com/sirupsen/logrus"
<mask> )
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove LocalAdapter "github.com/Dreamacro/clash/adapters/local"
</s> add InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
"github.com/Dreamacro/clash/common/observable" </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove "github.com/Dreamacro/clash/observable"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | proxy/redir/tcp.go |
"github.com/Dreamacro/clash/adapters/inbound" | <mask>
<mask> import (
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/local"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/socks"
<mask> log "github.com/sirupsen/logrus"
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove LocalAdapter "github.com/Dreamacro/clash/adapters/local"
</s> add InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
"github.com/Dreamacro/clash/common/observable" </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove "github.com/Dreamacro/clash/observable"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | proxy/socks/tcp.go |
func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | <mask> func (dk *DomainKeyword) RuleType() C.RuleType {
<mask> return C.DomainKeyword
<mask> }
<mask>
<mask> func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
<mask> if addr.AddrType != C.AtypDomainName {
<mask> return false
<mask> }
<mask> domain := addr.Host
<mask> return strings.Contains(domain, dk.keyword)
<mask> }
</s> Chore: make the code more semantic </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/domain_keyword.go |
domain := metadata.Host | <mask> func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
<mask> if addr.AddrType != C.AtypDomainName {
<mask> return false
<mask> }
<mask> domain := addr.Host
<mask> return strings.Contains(domain, dk.keyword)
<mask> }
<mask>
<mask> func (dk *DomainKeyword) Adapter() string {
<mask> return dk.adapter
</s> Chore: make the code more semantic </s> remove func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/domain_keyword.go |
func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | <mask> func (ds *DomainSuffix) RuleType() C.RuleType {
<mask> return C.DomainSuffix
<mask> }
<mask>
<mask> func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
<mask> if addr.AddrType != C.AtypDomainName {
<mask> return false
<mask> }
<mask> domain := addr.Host
<mask> return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix
<mask> }
</s> Chore: make the code more semantic </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/domain_suffix.go |
domain := metadata.Host | <mask> func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
<mask> if addr.AddrType != C.AtypDomainName {
<mask> return false
<mask> }
<mask> domain := addr.Host
<mask> return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix
<mask> }
<mask>
<mask> func (ds *DomainSuffix) Adapter() string {
<mask> return ds.adapter
</s> Chore: make the code more semantic </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/domain_suffix.go |
func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | <mask> func (d *Domain) RuleType() C.RuleType {
<mask> return C.Domain
<mask> }
<mask>
<mask> func (d *Domain) IsMatch(addr *C.Addr) bool {
<mask> if addr.AddrType != C.AtypDomainName {
<mask> return false
<mask> }
<mask> return addr.Host == d.domain
<mask> }
<mask>
</s> Chore: make the code more semantic </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove domain := addr.Host
</s> add domain := metadata.Host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/domian.go |
return metadata.Host == d.domain | <mask> func (d *Domain) IsMatch(addr *C.Addr) bool {
<mask> if addr.AddrType != C.AtypDomainName {
<mask> return false
<mask> }
<mask> return addr.Host == d.domain
<mask> }
<mask>
<mask> func (d *Domain) Adapter() string {
<mask> return d.adapter
<mask> }
</s> Chore: make the code more semantic </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove domain := addr.Host
</s> add domain := metadata.Host </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/domian.go |
func (f *Final) IsMatch(metadata *C.Metadata) bool { | <mask> func (f *Final) RuleType() C.RuleType {
<mask> return C.FINAL
<mask> }
<mask>
<mask> func (f *Final) IsMatch(addr *C.Addr) bool {
<mask> return true
<mask> }
<mask>
<mask> func (f *Final) Adapter() string {
<mask> return f.adapter
</s> Chore: make the code more semantic </s> remove IsMatch(addr *Addr) bool
</s> add IsMatch(metadata *Metadata) bool </s> remove func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (g *GEOIP) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/final.go |
func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { | <mask> func (g *GEOIP) RuleType() C.RuleType {
<mask> return C.GEOIP
<mask> }
<mask>
<mask> func (g *GEOIP) IsMatch(addr *C.Addr) bool {
<mask> if addr.IP == nil {
<mask> return false
<mask> }
<mask> record, _ := mmdb.Country(*addr.IP)
<mask> return record.Country.IsoCode == g.country
<mask> }
</s> Chore: make the code more semantic </s> remove record, _ := mmdb.Country(*addr.IP)
</s> add record, _ := mmdb.Country(*metadata.IP) </s> remove func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove return i.ipnet.Contains(*addr.IP)
</s> add return i.ipnet.Contains(*metadata.IP) </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/geoip.go |
record, _ := mmdb.Country(*metadata.IP) | <mask> func (g *GEOIP) IsMatch(addr *C.Addr) bool {
<mask> if addr.IP == nil {
<mask> return false
<mask> }
<mask> record, _ := mmdb.Country(*addr.IP)
<mask> return record.Country.IsoCode == g.country
<mask> }
<mask>
<mask> func (g *GEOIP) Adapter() string {
<mask> return g.adapter
</s> Chore: make the code more semantic </s> remove func (g *GEOIP) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove return i.ipnet.Contains(*addr.IP)
</s> add return i.ipnet.Contains(*metadata.IP) </s> remove func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove domain := addr.Host
</s> add domain := metadata.Host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/geoip.go |
func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { | <mask> func (i *IPCIDR) RuleType() C.RuleType {
<mask> return C.IPCIDR
<mask> }
<mask>
<mask> func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
<mask> if addr.IP == nil {
<mask> return false
<mask> }
<mask>
<mask> return i.ipnet.Contains(*addr.IP)
<mask> }
</s> Chore: make the code more semantic </s> remove return i.ipnet.Contains(*addr.IP)
</s> add return i.ipnet.Contains(*metadata.IP) </s> remove func (g *GEOIP) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove record, _ := mmdb.Country(*addr.IP)
</s> add record, _ := mmdb.Country(*metadata.IP) </s> remove func (d *Domain) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (d *Domain) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { </s> remove func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
if addr.AddrType != C.AtypDomainName {
</s> add func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
if metadata.AddrType != C.AtypDomainName { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/ipcidr.go |
return i.ipnet.Contains(*metadata.IP) | <mask> if addr.IP == nil {
<mask> return false
<mask> }
<mask>
<mask> return i.ipnet.Contains(*addr.IP)
<mask> }
<mask>
<mask> func (i *IPCIDR) Adapter() string {
<mask> return i.adapter
<mask> }
</s> Chore: make the code more semantic </s> remove func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove record, _ := mmdb.Country(*addr.IP)
</s> add record, _ := mmdb.Country(*metadata.IP) </s> remove func (g *GEOIP) IsMatch(addr *C.Addr) bool {
if addr.IP == nil {
</s> add func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
if metadata.IP == nil { </s> remove return addr.Host == d.domain
</s> add return metadata.Host == d.domain </s> remove domain := addr.Host
</s> add domain := metadata.Host | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | rules/ipcidr.go |
"github.com/Dreamacro/clash/adapters/inbound" | <mask> "net"
<mask> "net/http"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/local"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, proxy C.ProxyAdapter) {
<mask> conn := newTrafficTrack(proxy.Conn(), t.traffic)
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove A "github.com/Dreamacro/clash/adapters/remote"
</s> add A "github.com/Dreamacro/clash/adapters/outbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove addr := localConn.Addr()
</s> add metadata := localConn.Metadata() </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/connection.go |
InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
"github.com/Dreamacro/clash/common/observable" | <mask> import (
<mask> "sync"
<mask> "time"
<mask>
<mask> LocalAdapter "github.com/Dreamacro/clash/adapters/local"
<mask> cfg "github.com/Dreamacro/clash/config"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
<mask>
<mask> "gopkg.in/eapache/channels.v1"
</s> Chore: make the code more semantic </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove "github.com/Dreamacro/clash/adapters/remote"
</s> add "github.com/Dreamacro/clash/adapters/outbound"
"github.com/Dreamacro/clash/common/observable" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/observable"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
<mask>
<mask> LocalAdapter "github.com/Dreamacro/clash/adapters/local"
<mask> cfg "github.com/Dreamacro/clash/config"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
<mask>
<mask> "gopkg.in/eapache/channels.v1"
<mask> )
<mask>
<mask> var (
</s> Chore: make the code more semantic </s> remove LocalAdapter "github.com/Dreamacro/clash/adapters/local"
</s> add InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
"github.com/Dreamacro/clash/common/observable" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/observable"
</s> add </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go | |
metadata := localConn.Metadata() | <mask> }
<mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> addr := localConn.Addr()
<mask>
<mask> var proxy C.Proxy
<mask> switch t.mode {
<mask> case cfg.Direct:
<mask> proxy = t.proxies["DIRECT"]
</s> Chore: make the code more semantic </s> remove case *LocalAdapter.SocketAdapter:
</s> add case *InboundAdapter.SocketAdapter: </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) </s> remove func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> add func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { </s> remove case *LocalAdapter.HTTPAdapter:
</s> add case *InboundAdapter.HTTPAdapter: </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
proxy = t.match(metadata) | <mask> case cfg.Global:
<mask> proxy = t.proxies["GLOBAL"]
<mask> // Rule
<mask> default:
<mask> proxy = t.match(addr)
<mask> }
<mask> remoConn, err := proxy.Generator(addr)
<mask> if err != nil {
<mask> t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error())
<mask> return
</s> Chore: make the code more semantic </s> remove remoConn, err := proxy.Generator(addr)
</s> add remoConn, err := proxy.Generator(metadata) </s> remove addr := localConn.Addr()
</s> add metadata := localConn.Metadata() </s> remove t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String()) </s> remove t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
</s> add t.logCh <- newLog(C.INFO, "%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove if rule.IsMatch(addr) {
</s> add if rule.IsMatch(metadata) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
remoConn, err := proxy.Generator(metadata) | <mask> // Rule
<mask> default:
<mask> proxy = t.match(addr)
<mask> }
<mask> remoConn, err := proxy.Generator(addr)
<mask> if err != nil {
<mask> t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
</s> Chore: make the code more semantic </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) </s> remove t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String()) </s> remove t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
</s> add t.logCh <- newLog(C.INFO, "%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove addr := localConn.Addr()
</s> add metadata := localConn.Metadata() </s> remove if rule.IsMatch(addr) {
</s> add if rule.IsMatch(metadata) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
case *InboundAdapter.HTTPAdapter: | <mask> }
<mask> defer remoConn.Close()
<mask>
<mask> switch adapter := localConn.(type) {
<mask> case *LocalAdapter.HTTPAdapter:
<mask> t.handleHTTP(adapter, remoConn)
<mask> case *LocalAdapter.SocketAdapter:
<mask> t.handleSOCKS(adapter, remoConn)
<mask> }
<mask> }
</s> Chore: make the code more semantic </s> remove case *LocalAdapter.SocketAdapter:
</s> add case *InboundAdapter.SocketAdapter: </s> remove func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> add func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { </s> remove addr := localConn.Addr()
</s> add metadata := localConn.Metadata() </s> remove remoConn, err := proxy.Generator(addr)
</s> add remoConn, err := proxy.Generator(metadata) </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
case *InboundAdapter.SocketAdapter: | <mask>
<mask> switch adapter := localConn.(type) {
<mask> case *LocalAdapter.HTTPAdapter:
<mask> t.handleHTTP(adapter, remoConn)
<mask> case *LocalAdapter.SocketAdapter:
<mask> t.handleSOCKS(adapter, remoConn)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> Chore: make the code more semantic </s> remove case *LocalAdapter.HTTPAdapter:
</s> add case *InboundAdapter.HTTPAdapter: </s> remove func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> add func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { </s> remove addr := localConn.Addr()
</s> add metadata := localConn.Metadata() </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) </s> remove "github.com/Dreamacro/clash/adapters/local"
</s> add "github.com/Dreamacro/clash/adapters/inbound" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { | <mask> t.handleSOCKS(adapter, remoConn)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) match(addr *C.Addr) C.Proxy {
<mask> t.configLock.RLock()
<mask> defer t.configLock.RUnlock()
<mask>
<mask> for _, rule := range t.rules {
<mask> if rule.IsMatch(addr) {
</s> Chore: make the code more semantic </s> remove if rule.IsMatch(addr) {
</s> add if rule.IsMatch(metadata) { </s> remove case *LocalAdapter.SocketAdapter:
</s> add case *InboundAdapter.SocketAdapter: </s> remove case *LocalAdapter.HTTPAdapter:
</s> add case *InboundAdapter.HTTPAdapter: </s> remove addr := localConn.Addr()
</s> add metadata := localConn.Metadata() </s> remove t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
if rule.IsMatch(metadata) { | <mask> t.configLock.RLock()
<mask> defer t.configLock.RUnlock()
<mask>
<mask> for _, rule := range t.rules {
<mask> if rule.IsMatch(addr) {
<mask> a, ok := t.proxies[rule.Adapter()]
<mask> if !ok {
<mask> continue
<mask> }
<mask> t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
</s> Chore: make the code more semantic </s> remove t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
</s> add t.logCh <- newLog(C.INFO, "%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String()) </s> remove func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> add func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { </s> remove remoConn, err := proxy.Generator(addr)
</s> add remoConn, err := proxy.Generator(metadata) </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
t.logCh <- newLog(C.INFO, "%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter()) | <mask> a, ok := t.proxies[rule.Adapter()]
<mask> if !ok {
<mask> continue
<mask> }
<mask> t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
<mask> return a
<mask> }
<mask> }
<mask> t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
<mask> return t.proxies["DIRECT"]
</s> Chore: make the code more semantic </s> remove t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
</s> add t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String()) </s> remove if rule.IsMatch(addr) {
</s> add if rule.IsMatch(metadata) { </s> remove remoConn, err := proxy.Generator(addr)
</s> add remoConn, err := proxy.Generator(metadata) </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) </s> remove func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> add func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String()) | <mask> t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
<mask> return a
<mask> }
<mask> }
<mask> t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
<mask> return t.proxies["DIRECT"]
<mask> }
<mask>
<mask> // Run initial task
<mask> func (t *Tunnel) Run() {
</s> Chore: make the code more semantic </s> remove t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
</s> add t.logCh <- newLog(C.INFO, "%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove if rule.IsMatch(addr) {
</s> add if rule.IsMatch(metadata) { </s> remove remoConn, err := proxy.Generator(addr)
</s> add remoConn, err := proxy.Generator(metadata) </s> remove proxy = t.match(addr)
</s> add proxy = t.match(metadata) </s> remove func (t *Tunnel) match(addr *C.Addr) C.Proxy {
</s> add func (t *Tunnel) match(metadata *C.Metadata) C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2fd59cb31c01caccead1876814795f3ed6f91a5f | tunnel/tunnel.go |
case "ssr":
ssrOption := &ShadowSocksROption{}
err = decoder.Decode(mapping, ssrOption)
if err != nil {
break
}
proxy, err = NewShadowSocksR(*ssrOption) | <mask> if err != nil {
<mask> break
<mask> }
<mask> proxy, err = NewShadowSocks(*ssOption)
<mask> case "socks5":
<mask> socksOption := &Socks5Option{}
<mask> err = decoder.Decode(mapping, socksOption)
<mask> if err != nil {
<mask> break
</s> Feature: add ssr support (#805)
* Refactor ssr stream cipher to expose iv and key
References:
https://github.com/Dreamacro/go-shadowsocks2
https://github.com/sh4d0wfiend/go-shadowsocksr2
* Implement ssr obfs
Reference:
https://github.com/mzz2017/shadowsocksR
* Implement ssr protocol
References:
https://github.com/mzz2017/shadowsocksR
https://github.com/shadowsocksRb/shadowsocksr-libev
https://github.com/shadowsocksr-backup/shadowsocksr </s> remove github.com/Dreamacro/go-shadowsocks2 v0.1.5 h1:BizWSjmwzAyQoslz6YhJYMiAGT99j9cnm9zlxVr+kyI=
github.com/Dreamacro/go-shadowsocks2 v0.1.5/go.mod h1:LSXCjyHesPY3pLjhwff1mQX72ItcBT/N2xNC685cYeU=
</s> add github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a h1:JhQFrFOkCpRB8qsN6PrzHFzjy/8iQpFFk5cbOiplh6s=
github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a/go.mod h1:LSXCjyHesPY3pLjhwff1mQX72ItcBT/N2xNC685cYeU= </s> remove github.com/Dreamacro/go-shadowsocks2 v0.1.5
</s> add github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/33a6579a3a59d220ce018958b17343dc247409b8 | adapters/outbound/parser.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.