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 |
|---|---|---|---|---|
ciph, err := core.PickCipher(cipher, key, password)
if err != nil {
return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error()) | <mask> }
<mask>
<mask> func NewShadowSocks(ssURL string) *ShadowSocks {
<mask> server, cipher, password, _ := parseURL(ssURL)
<mask> return &ShadowSocks{
<mask> server: server,
<mask> cipher: cipher,
<mask> password: password,
<mask> }
<mask> }
<mask>
<mask> func parseURL(s string) (addr, cipher, password string, err error) {
<mask> u, err := url.Parse(s)
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove func NewShadowSocks(ssURL string) *ShadowSocks {
</s> add func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
var key []byte </s> remove c = ciph.StreamConn(c)
</s> add c = ss.cipher.StreamConn(c) </s> remove var key []byte
ciph, _ := core.PickCipher(ss.cipher, key, ss.password)
</s> add </s> remove server string
cipher string
password string
</s> add server string
cipher core.Cipher | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | adapters/shadowsocks.go |
return &ShadowSocks{
server: server,
cipher: ciph,
}, nil | <mask> ciph, err := core.PickCipher(cipher, key, password)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error())
<mask> }
<mask> }
<mask>
<mask> func parseURL(s string) (addr, cipher, password string, err error) {
<mask> u, err := url.Parse(s)
<mask> if err != nil {
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove return &ShadowSocks{
server: server,
cipher: cipher,
password: password,
</s> add ciph, err := core.PickCipher(cipher, key, password)
if err != nil {
return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error()) </s> remove var key []byte
ciph, _ := core.PickCipher(ss.cipher, key, ss.password)
</s> add </s> remove func NewShadowSocks(ssURL string) *ShadowSocks {
</s> add func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
var key []byte </s> remove c = ciph.StreamConn(c)
</s> add c = ss.cipher.StreamConn(c) </s> remove t.configLock.Lock()
defer t.configLock.Unlock()
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | adapters/shadowsocks.go |
<mask> t.queue.In() <- req
<mask> }
<mask>
<mask> func (t *Tunnel) UpdateConfig() (err error) {
<mask> t.configLock.Lock()
<mask> defer t.configLock.Unlock()
<mask>
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> return
<mask> }
<mask>
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove return &ShadowSocks{
server: server,
cipher: cipher,
password: password,
</s> add ciph, err := core.PickCipher(cipher, key, password)
if err != nil {
return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error()) </s> remove var key []byte
ciph, _ := core.PickCipher(ss.cipher, key, ss.password)
</s> add </s> remove t.proxys[key.Name()] = adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(ssURL)
if err != nil {
return err
}
proxys[key.Name()] = ss | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go | |
proxys := make(map[string]C.Proxy)
rules := []C.Rule{} | <mask> return
<mask> }
<mask>
<mask> // clear proxys and rules
<mask> t.proxys = make(map[string]C.Proxy)
<mask> t.rules = []C.Rule{}
<mask>
<mask> proxys := cfg.Section("Proxy")
<mask> rules := cfg.Section("Rule")
<mask>
<mask> // parse proxy
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove proxys := cfg.Section("Proxy")
rules := cfg.Section("Rule")
</s> add proxysConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule") </s> remove for _, key := range proxys.Keys() {
</s> add for _, key := range proxysConfig.Keys() { </s> remove t.proxys["DIRECT"] = adapters.NewDirect()
t.proxys["REJECT"] = adapters.NewReject()
</s> add proxys["DIRECT"] = adapters.NewDirect()
proxys["REJECT"] = adapters.NewReject() </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
proxysConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule") | <mask> // clear proxys and rules
<mask> t.proxys = make(map[string]C.Proxy)
<mask> t.rules = []C.Rule{}
<mask>
<mask> proxys := cfg.Section("Proxy")
<mask> rules := cfg.Section("Rule")
<mask>
<mask> // parse proxy
<mask> for _, key := range proxys.Keys() {
<mask> proxy := strings.Split(key.Value(), ",")
<mask> if len(proxy) == 0 {
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove for _, key := range proxys.Keys() {
</s> add for _, key := range proxysConfig.Keys() { </s> remove t.proxys = make(map[string]C.Proxy)
t.rules = []C.Rule{}
</s> add proxys := make(map[string]C.Proxy)
rules := []C.Rule{} </s> remove t.proxys["DIRECT"] = adapters.NewDirect()
t.proxys["REJECT"] = adapters.NewReject()
</s> add proxys["DIRECT"] = adapters.NewDirect()
proxys["REJECT"] = adapters.NewReject() </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
for _, key := range proxysConfig.Keys() { | <mask> proxys := cfg.Section("Proxy")
<mask> rules := cfg.Section("Rule")
<mask>
<mask> // parse proxy
<mask> for _, key := range proxys.Keys() {
<mask> proxy := strings.Split(key.Value(), ",")
<mask> if len(proxy) == 0 {
<mask> continue
<mask> }
<mask> proxy = trimArr(proxy)
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove proxys := cfg.Section("Proxy")
rules := cfg.Section("Rule")
</s> add proxysConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule") </s> remove t.proxys = make(map[string]C.Proxy)
t.rules = []C.Rule{}
</s> add proxys := make(map[string]C.Proxy)
rules := []C.Rule{} </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { </s> remove t.proxys["DIRECT"] = adapters.NewDirect()
t.proxys["REJECT"] = adapters.NewReject()
</s> add proxys["DIRECT"] = adapters.NewDirect()
proxys["REJECT"] = adapters.NewReject() </s> remove t.proxys[key.Name()] = adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(ssURL)
if err != nil {
return err
}
proxys[key.Name()] = ss | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
ss, err := adapters.NewShadowSocks(ssURL)
if err != nil {
return err
}
proxys[key.Name()] = ss | <mask> if len(proxy) < 5 {
<mask> continue
<mask> }
<mask> ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
<mask> t.proxys[key.Name()] = adapters.NewShadowSocks(ssURL)
<mask> }
<mask> }
<mask>
<mask> // init proxy
<mask> t.proxys["DIRECT"] = adapters.NewDirect()
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.proxys["DIRECT"] = adapters.NewDirect()
t.proxys["REJECT"] = adapters.NewReject()
</s> add proxys["DIRECT"] = adapters.NewDirect()
proxys["REJECT"] = adapters.NewReject() </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { </s> remove for _, key := range proxys.Keys() {
</s> add for _, key := range proxysConfig.Keys() { </s> remove proxys := cfg.Section("Proxy")
rules := cfg.Section("Rule")
</s> add proxysConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule") </s> remove t.proxys = make(map[string]C.Proxy)
t.rules = []C.Rule{}
</s> add proxys := make(map[string]C.Proxy)
rules := []C.Rule{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
proxys["DIRECT"] = adapters.NewDirect()
proxys["REJECT"] = adapters.NewReject() | <mask> }
<mask> }
<mask>
<mask> // init proxy
<mask> t.proxys["DIRECT"] = adapters.NewDirect()
<mask> t.proxys["REJECT"] = adapters.NewReject()
<mask>
<mask> // parse rules
<mask> for _, key := range rules.Keys() {
<mask> rule := strings.Split(key.Name(), ",")
<mask> if len(rule) < 3 {
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { </s> remove for _, key := range proxys.Keys() {
</s> add for _, key := range proxysConfig.Keys() { </s> remove t.proxys[key.Name()] = adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(ssURL)
if err != nil {
return err
}
proxys[key.Name()] = ss </s> remove proxys := cfg.Section("Proxy")
rules := cfg.Section("Rule")
</s> add proxysConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule") </s> remove t.proxys = make(map[string]C.Proxy)
t.rules = []C.Rule{}
</s> add proxys := make(map[string]C.Proxy)
rules := []C.Rule{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
for _, key := range rulesConfig.Keys() { | <mask> t.proxys["DIRECT"] = adapters.NewDirect()
<mask> t.proxys["REJECT"] = adapters.NewReject()
<mask>
<mask> // parse rules
<mask> for _, key := range rules.Keys() {
<mask> rule := strings.Split(key.Name(), ",")
<mask> if len(rule) < 3 {
<mask> continue
<mask> }
<mask> rule = trimArr(rule)
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.proxys["DIRECT"] = adapters.NewDirect()
t.proxys["REJECT"] = adapters.NewReject()
</s> add proxys["DIRECT"] = adapters.NewDirect()
proxys["REJECT"] = adapters.NewReject() </s> remove for _, key := range proxys.Keys() {
</s> add for _, key := range proxysConfig.Keys() { </s> remove t.proxys[key.Name()] = adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(ssURL)
if err != nil {
return err
}
proxys[key.Name()] = ss </s> remove proxys := cfg.Section("Proxy")
rules := cfg.Section("Rule")
</s> add proxysConfig := cfg.Section("Proxy")
rulesConfig := cfg.Section("Rule") </s> remove t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) | <mask> }
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "DOMAIN-SUFFIX":
<mask> t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(rule[2])) </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
rules = append(rules, R.NewDomainKeyword(rule[1], rule[2])) | <mask> switch rule[0] {
<mask> case "DOMAIN-SUFFIX":
<mask> t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(rule[2])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
rules = append(rules, R.NewGEOIP(rule[1], rule[2])) | <mask> t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
<mask> case "DOMAIN-KEYWORD":
<mask> t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> t.rules = append(t.rules, R.NewFinal(rule[2]))
<mask> }
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(rule[2])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
rules = append(rules, R.NewIPCIDR(rule[1], rule[2])) | <mask> t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
<mask> case "GEOIP":
<mask> t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> t.rules = append(t.rules, R.NewFinal(rule[2]))
<mask> }
<mask> }
<mask>
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewFinal(rule[2]))
</s> add rules = append(rules, R.NewFinal(rule[2])) </s> remove t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
rules = append(rules, R.NewFinal(rule[2])) | <mask> t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
<mask> case "IP-CIDR", "IP-CIDR6":
<mask> t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
<mask> case "FINAL":
<mask> t.rules = append(t.rules, R.NewFinal(rule[2]))
<mask> }
<mask> }
<mask>
<mask> return nil
<mask> }
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.rules = append(t.rules, R.NewIPCIDR(rule[1], rule[2]))
</s> add rules = append(rules, R.NewIPCIDR(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewGEOIP(rule[1], rule[2]))
</s> add rules = append(rules, R.NewGEOIP(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewDomainKeyword(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainKeyword(rule[1], rule[2])) </s> remove t.rules = append(t.rules, R.NewDomainSuffix(rule[1], rule[2]))
</s> add rules = append(rules, R.NewDomainSuffix(rule[1], rule[2])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
t.configLock.Lock()
defer t.configLock.Unlock()
t.proxys = proxys
t.rules = rules
| <mask> }
<mask> }
<mask>
<mask> return nil
<mask> }
<mask>
<mask> func (t *Tunnel) process() {
<mask> queue := t.queue.Out()
<mask> for {
</s> Fixed: throw error when shadowsocks cipher type wrong </s> remove t.configLock.Lock()
defer t.configLock.Unlock()
</s> add </s> remove return &ShadowSocks{
server: server,
cipher: cipher,
password: password,
</s> add ciph, err := core.PickCipher(cipher, key, password)
if err != nil {
return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error()) </s> remove for _, key := range proxys.Keys() {
</s> add for _, key := range proxysConfig.Keys() { </s> remove for _, key := range rules.Keys() {
</s> add for _, key := range rulesConfig.Keys() { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/961250f99893c0439d791ef02bc3760efa1ea0b2 | tunnel/tunnel.go |
<mask> import (
<mask> "bytes"
<mask> "encoding/binary"
<mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "os"
<mask> "path"
<mask> "path/filepath"
<mask> "strings"
</s> Chore: add more details to process resolving (#2017) </s> remove type (
SocketResolver func(network string, ip net.IP, srcPort int) (inode, uid int, err error)
ProcessNameResolver func(inode, uid int) (name string, err error)
)
// export for android
var (
DefaultSocketResolver SocketResolver = resolveSocketByNetlink
DefaultProcessNameResolver ProcessNameResolver = resolveProcessNameByProcSearch
)
</s> add </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("read response: %w", err) </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove return DefaultProcessNameResolver(inode, uid)
</s> add return resolveProcessNameByProcSearch(inode, uid) </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int, int, error) {
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go | |
<mask>
<mask> return binary.LittleEndian
<mask> }()
<mask>
<mask> type (
<mask> SocketResolver func(network string, ip net.IP, srcPort int) (inode, uid int, err error)
<mask> ProcessNameResolver func(inode, uid int) (name string, err error)
<mask> )
<mask>
<mask> // export for android
<mask> var (
<mask> DefaultSocketResolver SocketResolver = resolveSocketByNetlink
<mask> DefaultProcessNameResolver ProcessNameResolver = resolveProcessNameByProcSearch
<mask> )
<mask>
<mask> const (
<mask> sizeOfSocketDiagRequest = syscall.SizeofNlMsghdr + 8 + 48
<mask> socketDiagByFamily = 20
<mask> pathProc = "/proc"
<mask> )
</s> Chore: add more details to process resolving (#2017) </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove uid = nativeEndian.Uint32(data[64:68])
inode = nativeEndian.Uint32(data[68:72])
</s> add uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72])) </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int, int, error) {
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) { </s> remove return DefaultProcessNameResolver(inode, uid)
</s> add return resolveProcessNameByProcSearch(inode, uid) </s> remove "io"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go | |
inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) | <mask> pathProc = "/proc"
<mask> )
<mask>
<mask> func findProcessName(network string, ip net.IP, srcPort int) (string, error) {
<mask> inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
<mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
<mask> return DefaultProcessNameResolver(inode, uid)
</s> Chore: add more details to process resolving (#2017) </s> remove return DefaultProcessNameResolver(inode, uid)
</s> add return resolveProcessNameByProcSearch(inode, uid) </s> remove type (
SocketResolver func(network string, ip net.IP, srcPort int) (inode, uid int, err error)
ProcessNameResolver func(inode, uid int) (name string, err error)
)
// export for android
var (
DefaultSocketResolver SocketResolver = resolveSocketByNetlink
DefaultProcessNameResolver ProcessNameResolver = resolveProcessNameByProcSearch
)
</s> add </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int, int, error) {
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) { </s> remove uid = nativeEndian.Uint32(data[64:68])
inode = nativeEndian.Uint32(data[68:72])
</s> add uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return resolveProcessNameByProcSearch(inode, uid) | <mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
<mask> return DefaultProcessNameResolver(inode, uid)
<mask> }
<mask>
<mask> func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int, int, error) {
<mask> var family byte
<mask> var protocol byte
</s> Chore: add more details to process resolving (#2017) </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int, int, error) {
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) { </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { </s> remove type (
SocketResolver func(network string, ip net.IP, srcPort int) (inode, uid int, err error)
ProcessNameResolver func(inode, uid int) (name string, err error)
)
// export for android
var (
DefaultSocketResolver SocketResolver = resolveSocketByNetlink
DefaultProcessNameResolver ProcessNameResolver = resolveProcessNameByProcSearch
)
</s> add </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) { | <mask>
<mask> return DefaultProcessNameResolver(inode, uid)
<mask> }
<mask>
<mask> func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int, int, error) {
<mask> var family byte
<mask> var protocol byte
<mask>
<mask> switch network {
<mask> case TCP:
</s> Chore: add more details to process resolving (#2017) </s> remove return DefaultProcessNameResolver(inode, uid)
</s> add return resolveProcessNameByProcSearch(inode, uid) </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove type (
SocketResolver func(network string, ip net.IP, srcPort int) (inode, uid int, err error)
ProcessNameResolver func(inode, uid int) (name string, err error)
)
// export for android
var (
DefaultSocketResolver SocketResolver = resolveSocketByNetlink
DefaultProcessNameResolver ProcessNameResolver = resolveProcessNameByProcSearch
)
</s> add </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { </s> remove return int(uid), int(inode), nil
</s> add return uid, inode, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return 0, 0, fmt.Errorf("dial netlink: %w", err) | <mask> req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
<mask>
<mask> socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
<mask> if err != nil {
<mask> return 0, 0, err
<mask> }
<mask> defer syscall.Close(socket)
<mask>
<mask> syscall.SetNonblock(socket, true)
<mask> syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 50})
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("read response: %w", err) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("write request: %w", err) </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return 0, 0, fmt.Errorf("write request: %w", err) | <mask> return 0, 0, err
<mask> }
<mask>
<mask> if _, err := syscall.Write(socket, req); err != nil {
<mask> return 0, 0, err
<mask> }
<mask>
<mask> rb := pool.Get(pool.RelayBufferSize)
<mask> defer pool.Put(rb)
<mask>
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("read response: %w", err) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("dial netlink: %w", err) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return 0, 0, fmt.Errorf("read response: %w", err) | <mask> defer pool.Put(rb)
<mask>
<mask> n, err := syscall.Read(socket, rb)
<mask> if err != nil {
<mask> return 0, 0, err
<mask> }
<mask>
<mask> messages, err := syscall.ParseNetlinkMessage(rb[:n])
<mask> if err != nil {
<mask> return 0, 0, err
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("write request: %w", err) </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("dial netlink: %w", err) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return 0, 0, fmt.Errorf("parse netlink message: %w", err) | <mask> }
<mask>
<mask> messages, err := syscall.ParseNetlinkMessage(rb[:n])
<mask> if err != nil {
<mask> return 0, 0, err
<mask> } else if len(messages) == 0 {
<mask> return 0, 0, io.ErrUnexpectedEOF
<mask> }
<mask>
<mask> message := messages[0]
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("read response: %w", err) </s> remove return 0, 0, syscall.ESRCH
</s> add return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("write request: %w", err) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return 0, 0, fmt.Errorf("unexcepted netlink response") | <mask> messages, err := syscall.ParseNetlinkMessage(rb[:n])
<mask> if err != nil {
<mask> return 0, 0, err
<mask> } else if len(messages) == 0 {
<mask> return 0, 0, io.ErrUnexpectedEOF
<mask> }
<mask>
<mask> message := messages[0]
<mask> if message.Header.Type&syscall.NLMSG_ERROR != 0 {
<mask> return 0, 0, syscall.ESRCH
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) </s> remove return 0, 0, syscall.ESRCH
</s> add return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("read response: %w", err) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("write request: %w", err) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR") | <mask> }
<mask>
<mask> message := messages[0]
<mask> if message.Header.Type&syscall.NLMSG_ERROR != 0 {
<mask> return 0, 0, syscall.ESRCH
<mask> }
<mask>
<mask> uid, inode := unpackSocketDiagResponse(&messages[0])
<mask>
<mask> return int(uid), int(inode), nil
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return int(uid), int(inode), nil
</s> add return uid, inode, nil </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) </s> remove return "", syscall.ESRCH
</s> add return "", fmt.Errorf("process of uid(%d),inode(%d) not found", uid, inode) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
if uid < 0 || inode < 0 {
return 0, 0, fmt.Errorf("invalid uid(%d) or inode(%d)", uid, inode)
} | <mask> return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
<mask> }
<mask>
<mask> uid, inode := unpackSocketDiagResponse(&messages[0])
<mask>
<mask> return uid, inode, nil
<mask> }
<mask>
<mask> func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
</s> Chore: add more details to process resolving (#2017) </s> remove return int(uid), int(inode), nil
</s> add return uid, inode, nil </s> remove return 0, 0, syscall.ESRCH
</s> add return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR") </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove return "", syscall.ESRCH
</s> add return "", fmt.Errorf("process of uid(%d),inode(%d) not found", uid, inode) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return uid, inode, nil | <mask> }
<mask>
<mask> uid, inode := unpackSocketDiagResponse(&messages[0])
<mask>
<mask> return int(uid), int(inode), nil
<mask> }
<mask>
<mask> func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
<mask> s := make([]byte, 16)
<mask>
</s> Chore: add more details to process resolving (#2017) </s> remove return 0, 0, syscall.ESRCH
</s> add return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR") </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove uid = nativeEndian.Uint32(data[64:68])
inode = nativeEndian.Uint32(data[68:72])
</s> add uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72])) </s> remove return "", syscall.ESRCH
</s> add return "", fmt.Errorf("process of uid(%d),inode(%d) not found", uid, inode) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) { | <mask>
<mask> return buf
<mask> }
<mask>
<mask> func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid uint32) {
<mask> if len(msg.Data) < 72 {
<mask> return 0, 0
<mask> }
<mask>
<mask> data := msg.Data
</s> Chore: add more details to process resolving (#2017) </s> remove uid = nativeEndian.Uint32(data[64:68])
inode = nativeEndian.Uint32(data[68:72])
</s> add uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72])) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("parse netlink message: %w", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72])) | <mask> }
<mask>
<mask> data := msg.Data
<mask>
<mask> uid = nativeEndian.Uint32(data[64:68])
<mask> inode = nativeEndian.Uint32(data[68:72])
<mask>
<mask> return
<mask> }
<mask>
<mask> func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> Chore: add more details to process resolving (#2017) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { </s> remove func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid uint32) {
</s> add func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) { </s> remove type (
SocketResolver func(network string, ip net.IP, srcPort int) (inode, uid int, err error)
ProcessNameResolver func(inode, uid int) (name string, err error)
)
// export for android
var (
DefaultSocketResolver SocketResolver = resolveSocketByNetlink
DefaultProcessNameResolver ProcessNameResolver = resolveProcessNameByProcSearch
)
</s> add </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { | <mask>
<mask> return
<mask> }
<mask>
<mask> func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
<mask> files, err := os.ReadDir(pathProc)
<mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
</s> Chore: add more details to process resolving (#2017) </s> remove return DefaultProcessNameResolver(inode, uid)
</s> add return resolveProcessNameByProcSearch(inode, uid) </s> remove inode, uid, err := DefaultSocketResolver(network, ip, srcPort)
</s> add inode, uid, err := resolveSocketByNetlink(network, ip, srcPort) </s> remove uid = nativeEndian.Uint32(data[64:68])
inode = nativeEndian.Uint32(data[68:72])
</s> add uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72])) </s> remove return 0, 0, err
</s> add return 0, 0, fmt.Errorf("read response: %w", err) </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
return "", fmt.Errorf("process of uid(%d),inode(%d) not found", uid, inode) | <mask> }
<mask> }
<mask> }
<mask>
<mask> return "", syscall.ESRCH
<mask> }
<mask>
<mask> func splitCmdline(cmdline []byte) string {
<mask> idx := bytes.IndexFunc(cmdline, func(r rune) bool {
<mask> return unicode.IsControl(r) || unicode.IsSpace(r)
</s> Chore: add more details to process resolving (#2017) </s> remove func resolveProcessNameByProcSearch(inode, uid int) (string, error) {
</s> add func resolveProcessNameByProcSearch(inode, uid int32) (string, error) { </s> remove return 0, 0, syscall.ESRCH
</s> add return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR") </s> remove return 0, 0, io.ErrUnexpectedEOF
</s> add return 0, 0, fmt.Errorf("unexcepted netlink response") </s> remove return DefaultProcessNameResolver(inode, uid)
</s> add return resolveProcessNameByProcSearch(inode, uid) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/9683c297a74c07cf63f84a41f6ffa138a5adefca | component/process/process_linux.go |
<mask> Enable bool `yaml:"enable"`
<mask> IPv6 bool `yaml:"ipv6"`
<mask> NameServer []dns.NameServer `yaml:"nameserver"`
<mask> Fallback []dns.NameServer `yaml:"fallback"`
<mask> Hosts *trie.Trie `yaml:"-"`
<mask> Listen string `yaml:"listen"`
<mask> EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
<mask> FakeIPRange *fakeip.Pool
<mask> }
<mask>
</s> Feature: move hosts to the top </s> remove Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Hosts map[string]string `yaml:"hosts"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"`
</s> add Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` </s> remove Hosts *trie.Trie
</s> add </s> remove hosts *trie.Trie
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go | |
Hosts *trie.Trie | <mask> DNS *DNS
<mask> Experimental *Experimental
<mask> Rules []C.Rule
<mask> Users []auth.AuthUser
<mask> Proxies map[string]C.Proxy
<mask> }
</s> Feature: move hosts to the top </s> remove Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Hosts map[string]string `yaml:"hosts"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"`
</s> add Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} </s> remove if resolver.hosts != nil {
return withHost(resolver, withResolver(resolver))
</s> add if resolver.IsFakeIP() {
middlewares = append(middlewares, withFakeIP(resolver.pool)) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go |
Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` | <mask> Proxies map[string]C.Proxy
<mask> }
<mask>
<mask> type rawDNS struct {
<mask> Enable bool `yaml:"enable"`
<mask> IPv6 bool `yaml:"ipv6"`
<mask> NameServer []string `yaml:"nameserver"`
<mask> Hosts map[string]string `yaml:"hosts"`
<mask> Fallback []string `yaml:"fallback"`
<mask> Listen string `yaml:"listen"`
<mask> EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
<mask> FakeIPRange string `yaml:"fake-ip-range"`
<mask> }
<mask>
<mask> type rawConfig struct {
<mask> Port int `yaml:"port"`
<mask> SocksPort int `yaml:"socks-port"`
</s> Feature: move hosts to the top </s> remove Hosts *trie.Trie `yaml:"-"`
</s> add </s> remove Hosts *trie.Trie
</s> add </s> remove hosts *trie.Trie
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go |
Hosts map[string]string `yaml:"hosts"` | <mask> ExternalUI string `yaml:"external-ui"`
<mask> Secret string `yaml:"secret"`
<mask>
<mask> DNS rawDNS `yaml:"dns"`
<mask> Experimental Experimental `yaml:"experimental"`
<mask> Proxy []map[string]interface{} `yaml:"Proxy"`
<mask> ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
<mask> Rule []string `yaml:"Rule"`
<mask> }
</s> Feature: move hosts to the top </s> remove Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Hosts map[string]string `yaml:"hosts"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"`
</s> add Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` </s> remove Hosts *trie.Trie `yaml:"-"`
</s> add </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} </s> remove if resolver.hosts != nil {
return withHost(resolver, withResolver(resolver))
</s> add if resolver.IsFakeIP() {
middlewares = append(middlewares, withFakeIP(resolver.pool)) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go |
Hosts: map[string]string{}, | <mask> Mode: T.Rule,
<mask> Authentication: []string{},
<mask> LogLevel: log.INFO,
<mask> Rule: []string{},
<mask> Proxy: []map[string]interface{}{},
<mask> ProxyGroup: []map[string]interface{}{},
<mask> Experimental: Experimental{
</s> Feature: move hosts to the top </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Hosts map[string]string `yaml:"hosts"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"`
</s> add Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go |
<mask> },
<mask> DNS: rawDNS{
<mask> Enable: false,
<mask> FakeIPRange: "198.18.0.1/16",
<mask> Hosts: map[string]string{},
<mask> },
<mask> }
<mask> err = yaml.Unmarshal([]byte(data), &rawConfig)
<mask> return rawConfig, err
<mask> }
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go | |
hosts, err := parseHosts(rawCfg)
if err != nil {
return nil, err
}
config.Hosts = hosts
| <mask> config.DNS = dnsCfg
<mask>
<mask> config.Users = parseAuthentication(rawCfg.Authentication)
<mask>
<mask> return config, nil
<mask> }
</s> Feature: move hosts to the top </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove if resolver.hosts != nil {
return withHost(resolver, withResolver(resolver))
</s> add if resolver.IsFakeIP() {
middlewares = append(middlewares, withFakeIP(resolver.pool)) </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go |
func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
tree := trie.New()
if len(cfg.Hosts) != 0 {
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
}
return tree, nil
}
| <mask>
<mask> return rules, nil
<mask> }
<mask>
<mask> func hostWithDefaultPort(host string, defPort string) (string, error) {
<mask> if !strings.Contains(host, ":") {
<mask> host += ":"
<mask> }
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go |
<mask> if dnsCfg.Fallback, err = parseNameServer(cfg.Fallback); err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> if len(cfg.Hosts) != 0 {
<mask> tree := trie.New()
<mask> for domain, ipStr := range cfg.Hosts {
<mask> ip := net.ParseIP(ipStr)
<mask> if ip == nil {
<mask> return nil, fmt.Errorf("%s is not a valid IP", ipStr)
<mask> }
<mask> tree.Insert(domain, ip)
<mask> }
<mask> dnsCfg.Hosts = tree
<mask> }
<mask>
<mask> if cfg.EnhancedMode == dns.FAKEIP {
<mask> _, ipnet, err := net.ParseCIDR(cfg.FakeIPRange)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | config/config.go | |
if node := DefaultHosts.Search(host); node != nil {
return node.Data.(net.IP), nil
}
| <mask>
<mask> // ResolveIP with a host, return ip
<mask> func ResolveIP(host string) (net.IP, error) {
<mask> if DefaultResolver != nil {
<mask> if DefaultResolver.ipv6 {
<mask> return DefaultResolver.ResolveIP(host)
<mask> }
<mask> return DefaultResolver.ResolveIPv4(host)
<mask> }
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
</s> add </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/iputil.go |
<mask> package dns
<mask>
<mask> import (
<mask> "fmt"
<mask> "net"
<mask> "strings"
<mask>
<mask> "github.com/Dreamacro/clash/component/fakeip"
<mask> "github.com/Dreamacro/clash/log"
<mask>
</s> Feature: move hosts to the top </s> remove // DefaultResolver aim to resolve ip with host
</s> add // DefaultResolver aim to resolve ip </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | [
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go | |
type middleware func(next handler) handler | <mask>
<mask> type handler func(w D.ResponseWriter, r *D.Msg)
<mask>
<mask> func withFakeIP(fakePool *fakeip.Pool) middleware {
<mask> return func(next handler) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
</s> Feature: move hosts to the top </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} </s> remove func withHost(resolver *Resolver, next handler) handler {
hosts := resolver.hosts
if hosts == nil {
panic("dns/withHost: hosts should not be nil")
</s> add func compose(middlewares []middleware, endpoint handler) handler {
length := len(middlewares)
h := endpoint
for i := length - 1; i >= 0; i-- {
middleware := middlewares[i]
h = middleware(h) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} | <mask> )
<mask>
<mask> type handler func(w D.ResponseWriter, r *D.Msg)
<mask>
<mask> func withFakeIP(pool *fakeip.Pool) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask> host := strings.TrimRight(q.Name, ".")
<mask>
<mask> rr := &D.A{}
<mask> rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
<mask> ip := pool.Lookup(host)
<mask> rr.A = ip
<mask> msg := r.Copy()
<mask> msg.Answer = []D.RR{rr}
<mask>
<mask> setMsgTTL(msg, 1)
<mask> msg.SetReply(r)
<mask> w.WriteMsg(msg)
<mask> return
<mask> }
<mask> }
<mask>
<mask> func withResolver(resolver *Resolver) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
</s> Feature: move hosts to the top </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove func withHost(resolver *Resolver, next handler) handler {
hosts := resolver.hosts
if hosts == nil {
panic("dns/withHost: hosts should not be nil")
</s> add func compose(middlewares []middleware, endpoint handler) handler {
length := len(middlewares)
h := endpoint
for i := length - 1; i >= 0; i-- {
middleware := middlewares[i]
h = middleware(h) </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | [
"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/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
log.Debugln("[DNS Server] Exchange %s failed: %v", q.String(), err) | <mask> msg, err := resolver.Exchange(r)
<mask>
<mask> if err != nil {
<mask> q := r.Question[0]
<mask> qString := fmt.Sprintf("%s %s %s", q.Name, D.Class(q.Qclass).String(), D.Type(q.Qtype).String())
<mask> log.Debugln("[DNS Server] Exchange %s failed: %v", qString, err)
<mask> D.HandleFailed(w, r)
<mask> return
<mask> }
<mask> msg.SetReply(r)
<mask> w.WriteMsg(msg)
</s> Feature: move hosts to the top </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
func compose(middlewares []middleware, endpoint handler) handler {
length := len(middlewares)
h := endpoint
for i := length - 1; i >= 0; i-- {
middleware := middlewares[i]
h = middleware(h) | <mask> return
<mask> }
<mask> }
<mask>
<mask> func withHost(resolver *Resolver, next handler) handler {
<mask> hosts := resolver.hosts
<mask> if hosts == nil {
<mask> panic("dns/withHost: hosts should not be nil")
<mask> }
<mask>
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask> if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
</s> Feature: move hosts to the top </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
return h | <mask> if hosts == nil {
<mask> panic("dns/withHost: hosts should not be nil")
<mask> }
<mask>
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask> if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> domain := strings.TrimRight(q.Name, ".")
<mask> host := hosts.Search(domain)
<mask> if host == nil {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> ip := host.Data.(net.IP)
<mask> if q.Qtype == D.TypeAAAA && ip.To16() == nil {
<mask> next(w, r)
<mask> return
<mask> } else if q.Qtype == D.TypeA && ip.To4() == nil {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> var rr D.RR
<mask> if q.Qtype == D.TypeAAAA {
<mask> record := &D.AAAA{}
<mask> record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
<mask> record.AAAA = ip
<mask> rr = record
<mask> } else {
<mask> record := &D.A{}
<mask> record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
<mask> record.A = ip
<mask> rr = record
<mask> }
<mask>
<mask> msg := r.Copy()
<mask> msg.Answer = []D.RR{rr}
<mask> msg.SetReply(r)
<mask> w.WriteMsg(msg)
<mask> return
<mask> }
<mask> }
<mask>
<mask> func newHandler(resolver *Resolver) handler {
<mask> if resolver.IsFakeIP() {
<mask> return withFakeIP(resolver.pool)
</s> Feature: move hosts to the top </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} </s> remove func withHost(resolver *Resolver, next handler) handler {
hosts := resolver.hosts
if hosts == nil {
panic("dns/withHost: hosts should not be nil")
</s> add func compose(middlewares []middleware, endpoint handler) handler {
length := len(middlewares)
h := endpoint
for i := length - 1; i >= 0; i-- {
middleware := middlewares[i]
h = middleware(h) </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} | [
"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/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
middlewares := []middleware{} | <mask> }
<mask> }
<mask>
<mask> func newHandler(resolver *Resolver) handler {
<mask> if resolver.IsFakeIP() {
<mask> return withFakeIP(resolver.pool)
<mask> }
<mask>
<mask> if resolver.hosts != nil {
<mask> return withHost(resolver, withResolver(resolver))
<mask> }
<mask>
</s> Feature: move hosts to the top </s> remove if resolver.hosts != nil {
return withHost(resolver, withResolver(resolver))
</s> add if resolver.IsFakeIP() {
middlewares = append(middlewares, withFakeIP(resolver.pool)) </s> remove return withResolver(resolver)
</s> add return compose(middlewares, withResolver(resolver)) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove func withHost(resolver *Resolver, next handler) handler {
hosts := resolver.hosts
if hosts == nil {
panic("dns/withHost: hosts should not be nil")
</s> add func compose(middlewares []middleware, endpoint handler) handler {
length := len(middlewares)
h := endpoint
for i := length - 1; i >= 0; i-- {
middleware := middlewares[i]
h = middleware(h) </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
if resolver.IsFakeIP() {
middlewares = append(middlewares, withFakeIP(resolver.pool)) | <mask> if resolver.IsFakeIP() {
<mask> return withFakeIP(resolver.pool)
<mask> }
<mask>
<mask> if resolver.hosts != nil {
<mask> return withHost(resolver, withResolver(resolver))
<mask> }
<mask>
<mask> return withResolver(resolver)
<mask> }
</s> Feature: move hosts to the top </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} </s> remove return withResolver(resolver)
</s> add return compose(middlewares, withResolver(resolver)) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
return compose(middlewares, withResolver(resolver)) | <mask> if resolver.hosts != nil {
<mask> return withHost(resolver, withResolver(resolver))
<mask> }
<mask>
<mask> return withResolver(resolver)
<mask> }
</s> Feature: move hosts to the top </s> remove if resolver.hosts != nil {
return withHost(resolver, withResolver(resolver))
</s> add if resolver.IsFakeIP() {
middlewares = append(middlewares, withFakeIP(resolver.pool)) </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/middleware.go |
// DefaultResolver aim to resolve ip | <mask> "golang.org/x/sync/singleflight"
<mask> )
<mask>
<mask> var (
<mask> // DefaultResolver aim to resolve ip with host
<mask> DefaultResolver *Resolver
<mask> )
<mask>
<mask> var (
<mask> globalSessionCache = tls.NewLRUClientSessionCache(64)
</s> Feature: move hosts to the top </s> remove "fmt"
"net"
</s> add </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go |
// DefaultHosts aim to resolve hosts
DefaultHosts = trie.New() | <mask>
<mask> var (
<mask> // DefaultResolver aim to resolve ip
<mask> DefaultResolver *Resolver
<mask> )
<mask>
<mask> var (
<mask> globalSessionCache = tls.NewLRUClientSessionCache(64)
</s> Feature: move hosts to the top </s> remove // DefaultResolver aim to resolve ip with host
</s> add // DefaultResolver aim to resolve ip </s> remove "fmt"
"net"
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go |
<mask> type Resolver struct {
<mask> ipv6 bool
<mask> mapping bool
<mask> fakeip bool
<mask> hosts *trie.Trie
<mask> pool *fakeip.Pool
<mask> fallback []resolver
<mask> main []resolver
<mask> group singleflight.Group
<mask> cache *cache.Cache
</s> Feature: move hosts to the top </s> remove Hosts *trie.Trie
</s> add </s> remove Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Hosts map[string]string `yaml:"hosts"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"`
</s> add Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` </s> remove Hosts *trie.Trie `yaml:"-"`
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go | |
<mask> }
<mask>
<mask> // ResolveIP request with TypeA and TypeAAAA, priority return TypeAAAA
<mask> func (r *Resolver) ResolveIP(host string) (ip net.IP, err error) {
<mask> ip = net.ParseIP(host)
<mask> if ip != nil {
<mask> return ip, nil
<mask> }
<mask>
<mask> ch := make(chan net.IP)
<mask> go func() {
<mask> defer close(ch)
<mask> ip, err := r.resolveIP(host, D.TypeA)
<mask> if err != nil {
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go | |
return r.resolveIP(host, D.TypeA)
} | <mask> }
<mask>
<mask> // ResolveIPv4 request with TypeA
<mask> func (r *Resolver) ResolveIPv4(host string) (ip net.IP, err error) {
<mask> ip = net.ParseIP(host)
<mask> if ip != nil {
<mask> return ip, nil
<mask> }
<mask>
<mask> query := &D.Msg{}
<mask> query.SetQuestion(D.Fqdn(host), D.TypeA)
<mask>
<mask> msg, err := r.Exchange(query)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> ips := r.msgToIP(msg)
<mask> if len(ips) == 0 {
<mask> return nil, errIPNotFound
<mask> }
<mask>
<mask> ip = ips[0]
<mask> return
<mask> }
<mask>
</s> Feature: move hosts to the top </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
</s> add </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"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/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go |
// ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | <mask> if len(ips) == 0 {
<mask> return nil, errIPNotFound
<mask> }
<mask>
<mask> ip = ips[0]
<mask> return
<mask> }
<mask>
<mask> // Exchange a batch of dns request, and it use cache
<mask> func (r *Resolver) Exchange(m *D.Msg) (msg *D.Msg, err error) {
<mask> if len(m.Question) == 0 {
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go |
ip = net.ParseIP(host)
if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
}
}
| <mask> }
<mask>
<mask> func (r *Resolver) resolveIP(host string, dnsType uint16) (ip net.IP, err error) {
<mask> query := &D.Msg{}
<mask> query.SetQuestion(D.Fqdn(host), dnsType)
<mask>
<mask> msg, err := r.Exchange(query)
</s> Feature: move hosts to the top </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
</s> add </s> remove qString := fmt.Sprintf("%s %s %s", q.Name, D.Class(q.Qclass).String(), D.Type(q.Qtype).String())
log.Debugln("[DNS Server] Exchange %s failed: %v", qString, err)
</s> add log.Debugln("[DNS Server] Exchange %s failed: %v", q.String(), err) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go |
<mask> type Config struct {
<mask> Main, Fallback []NameServer
<mask> IPv6 bool
<mask> EnhancedMode EnhancedMode
<mask> Hosts *trie.Trie
<mask> Pool *fakeip.Pool
<mask> }
<mask>
<mask> func New(config Config) *Resolver {
<mask> once.Do(func() {
</s> Feature: move hosts to the top </s> remove Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Hosts map[string]string `yaml:"hosts"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"`
</s> add Enable bool `yaml:"enable"`
IPv6 bool `yaml:"ipv6"`
NameServer []string `yaml:"nameserver"`
Fallback []string `yaml:"fallback"`
Listen string `yaml:"listen"`
EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
FakeIPRange string `yaml:"fake-ip-range"` </s> remove Hosts *trie.Trie `yaml:"-"`
</s> add </s> remove hosts *trie.Trie
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go | |
<mask> main: transform(config.Main),
<mask> cache: cache.New(time.Second * 60),
<mask> mapping: config.EnhancedMode == MAPPING,
<mask> fakeip: config.EnhancedMode == FAKEIP,
<mask> hosts: config.Hosts,
<mask> pool: config.Pool,
<mask> }
<mask> if len(config.Fallback) != 0 {
<mask> r.fallback = transform(config.Fallback)
<mask> }
</s> Feature: move hosts to the top </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add </s> remove return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
domain := strings.TrimRight(q.Name, ".")
host := hosts.Search(domain)
if host == nil {
next(w, r)
return
}
ip := host.Data.(net.IP)
if q.Qtype == D.TypeAAAA && ip.To16() == nil {
next(w, r)
return
} else if q.Qtype == D.TypeA && ip.To4() == nil {
next(w, r)
return
}
var rr D.RR
if q.Qtype == D.TypeAAAA {
record := &D.AAAA{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeAAAA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.AAAA = ip
rr = record
} else {
record := &D.A{}
record.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
record.A = ip
rr = record
}
msg := r.Copy()
msg.Answer = []D.RR{rr}
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add return h </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} </s> remove ip = ips[0]
return
</s> add // ResolveIPv6 request with TypeAAAA
func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
return r.resolveIP(host, D.TypeAAAA) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | dns/resolver.go | |
trie "github.com/Dreamacro/clash/component/domain-trie" | <mask> import (
<mask> "github.com/Dreamacro/clash/component/auth"
<mask> "github.com/Dreamacro/clash/config"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/dns"
<mask> "github.com/Dreamacro/clash/log"
</s> Feature: move hosts to the top </s> remove "fmt"
"net"
</s> add </s> remove // DefaultResolver aim to resolve ip with host
</s> add // DefaultResolver aim to resolve ip </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | hub/executor/executor.go |
updateHosts(cfg.Hosts) | <mask> updateProxies(cfg.Proxies)
<mask> updateRules(cfg.Rules)
<mask> updateDNS(cfg.DNS)
<mask> updateExperimental(cfg.Experimental)
<mask> }
<mask>
<mask> func GetGeneral() *config.General {
</s> Feature: move hosts to the top </s> remove if resolver.IsFakeIP() {
return withFakeIP(resolver.pool)
}
</s> add middlewares := []middleware{} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | hub/executor/executor.go |
<mask> r := dns.New(dns.Config{
<mask> Main: c.NameServer,
<mask> Fallback: c.Fallback,
<mask> IPv6: c.IPv6,
<mask> Hosts: c.Hosts,
<mask> EnhancedMode: c.EnhancedMode,
<mask> Pool: c.FakeIPRange,
<mask> })
<mask> dns.DefaultResolver = r
<mask> if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> Feature: move hosts to the top </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add </s> remove func withFakeIP(pool *fakeip.Pool) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := pool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
</s> add func withFakeIP(fakePool *fakeip.Pool) middleware {
return func(next handler) handler {
return func(w D.ResponseWriter, r *D.Msg) {
q := r.Question[0]
if q.Qtype != D.TypeA && q.Qtype != D.TypeAAAA {
next(w, r)
return
}
host := strings.TrimRight(q.Name, ".")
rr := &D.A{}
rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
ip := fakePool.Lookup(host)
rr.A = ip
msg := r.Copy()
msg.Answer = []D.RR{rr}
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
} </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | hub/executor/executor.go | |
func updateHosts(tree *trie.Trie) {
dns.DefaultHosts = tree
}
| <mask> }
<mask>
<mask> func updateProxies(proxies map[string]C.Proxy) {
<mask> tunnel := T.Instance()
<mask> oldProxies := tunnel.Proxies()
<mask>
<mask> // close proxy group goroutine
<mask> for _, proxy := range oldProxies {
</s> Feature: move hosts to the top </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add </s> remove func withHost(resolver *Resolver, next handler) handler {
hosts := resolver.hosts
if hosts == nil {
panic("dns/withHost: hosts should not be nil")
</s> add func compose(middlewares []middleware, endpoint handler) handler {
length := len(middlewares)
h := endpoint
for i := length - 1; i >= 0; i-- {
middleware := middlewares[i]
h = middleware(h) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | hub/executor/executor.go |
if node := dns.DefaultHosts.Search(metadata.Host); node != nil {
ip := node.Data.(net.IP)
metadata.DstIP = &ip
resolved = true
}
| <mask>
<mask> var resolved bool
<mask> for _, rule := range t.rules {
<mask> if !resolved && t.shouldResolveIP(rule, metadata) {
<mask> ip, err := t.resolveIP(metadata.Host)
<mask> if err != nil {
<mask> if !t.ignoreResolveFail {
</s> Feature: move hosts to the top </s> remove if len(cfg.Hosts) != 0 {
tree := trie.New()
for domain, ipStr := range cfg.Hosts {
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s is not a valid IP", ipStr)
}
tree.Insert(domain, ip)
}
dnsCfg.Hosts = tree
}
</s> add </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
</s> add </s> remove ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
query := &D.Msg{}
query.SetQuestion(D.Fqdn(host), D.TypeA)
msg, err := r.Exchange(query)
if err != nil {
return nil, err
}
ips := r.msgToIP(msg)
if len(ips) == 0 {
return nil, errIPNotFound
}
</s> add return r.resolveIP(host, D.TypeA)
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a4abf46c3b9073c98e45079e6a51a2aad2a70b | tunnel/tunnel.go |
pool *snell.Pool | <mask> type Snell struct {
<mask> *Base
<mask> psk []byte
<mask> obfsOption *simpleObfsOption
<mask> version int
<mask> }
<mask>
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
version int | <mask> psk []byte
<mask> pool *snell.Pool
<mask> obfsOption *simpleObfsOption
<mask> }
<mask>
<mask> type SnellOption struct {
<mask> Name string `proxy:"name"`
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
Version int `proxy:"version,omitempty"` | <mask> Server string `proxy:"server"`
<mask> Port int `proxy:"port"`
<mask> Psk string `proxy:"psk"`
<mask> ObfsOpts map[string]interface{} `proxy:"obfs-opts,omitempty"`
<mask> }
<mask>
<mask> type streamOption struct {
<mask> psk []byte
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | <mask> Psk string `proxy:"psk"`
<mask> ObfsOpts map[string]interface{} `proxy:"obfs-opts,omitempty"`
<mask> }
<mask>
<mask> func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> switch s.obfsOption.Mode {
<mask> case "tls":
<mask> c = obfs.NewTLSObfs(c, s.obfsOption.Host)
<mask> case "http":
<mask> _, port, _ := net.SplitHostPort(s.addr)
<mask> c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c = obfs.NewTLSObfs(c, s.obfsOption.Host)
</s> add c = obfs.NewTLSObfs(c, option.obfsOption.Host) </s> remove _, port, _ := net.SplitHostPort(s.addr)
c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
</s> add _, port, _ := net.SplitHostPort(option.addr)
c = obfs.NewHTTPObfs(c, option.obfsOption.Host, port) </s> remove c = snell.StreamConn(c, s.psk)
</s> add return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) </s> remove err := snell.WriteHeader(c, metadata.String(), uint(port))
</s> add err := snell.WriteHeader(c, metadata.String(), uint(port), s.version) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
c = obfs.NewTLSObfs(c, option.obfsOption.Host) | <mask>
<mask> func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> switch s.obfsOption.Mode {
<mask> case "tls":
<mask> c = obfs.NewTLSObfs(c, s.obfsOption.Host)
<mask> case "http":
<mask> _, port, _ := net.SplitHostPort(s.addr)
<mask> c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
<mask> }
<mask> c = snell.StreamConn(c, s.psk)
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { </s> remove _, port, _ := net.SplitHostPort(s.addr)
c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
</s> add _, port, _ := net.SplitHostPort(option.addr)
c = obfs.NewHTTPObfs(c, option.obfsOption.Host, port) </s> remove c = snell.StreamConn(c, s.psk)
</s> add return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) </s> remove err := snell.WriteHeader(c, metadata.String(), uint(port))
</s> add err := snell.WriteHeader(c, metadata.String(), uint(port), s.version) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
_, port, _ := net.SplitHostPort(option.addr)
c = obfs.NewHTTPObfs(c, option.obfsOption.Host, port) | <mask> switch s.obfsOption.Mode {
<mask> case "tls":
<mask> c = obfs.NewTLSObfs(c, s.obfsOption.Host)
<mask> case "http":
<mask> _, port, _ := net.SplitHostPort(s.addr)
<mask> c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
<mask> }
<mask> c = snell.StreamConn(c, s.psk)
<mask> port, _ := strconv.Atoi(metadata.DstPort)
<mask> err := snell.WriteHeader(c, metadata.String(), uint(port))
<mask> return c, err
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c = obfs.NewTLSObfs(c, s.obfsOption.Host)
</s> add c = obfs.NewTLSObfs(c, option.obfsOption.Host) </s> remove c = snell.StreamConn(c, s.psk)
</s> add return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) </s> remove err := snell.WriteHeader(c, metadata.String(), uint(port))
</s> add err := snell.WriteHeader(c, metadata.String(), uint(port), s.version) </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) | <mask> case "http":
<mask> _, port, _ := net.SplitHostPort(s.addr)
<mask> c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
<mask> }
<mask> c = snell.StreamConn(c, s.psk)
<mask> port, _ := strconv.Atoi(metadata.DstPort)
<mask> err := snell.WriteHeader(c, metadata.String(), uint(port))
<mask> return c, err
<mask> }
<mask>
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove _, port, _ := net.SplitHostPort(s.addr)
c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
</s> add _, port, _ := net.SplitHostPort(option.addr)
c = obfs.NewHTTPObfs(c, option.obfsOption.Host, port) </s> remove err := snell.WriteHeader(c, metadata.String(), uint(port))
</s> add err := snell.WriteHeader(c, metadata.String(), uint(port), s.version) </s> remove c = obfs.NewTLSObfs(c, s.obfsOption.Host)
</s> add c = obfs.NewTLSObfs(c, option.obfsOption.Host) </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
err := snell.WriteHeader(c, metadata.String(), uint(port), s.version) | <mask> c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
<mask> }
<mask> c = snell.StreamConn(c, s.psk)
<mask> port, _ := strconv.Atoi(metadata.DstPort)
<mask> err := snell.WriteHeader(c, metadata.String(), uint(port))
<mask> return c, err
<mask> }
<mask>
<mask> func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> c, err := dialer.DialContext(ctx, "tcp", s.addr)
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c = snell.StreamConn(c, s.psk)
</s> add return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) </s> remove _, port, _ := net.SplitHostPort(s.addr)
c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
</s> add _, port, _ := net.SplitHostPort(option.addr)
c = obfs.NewHTTPObfs(c, option.obfsOption.Host, port) </s> remove c = obfs.NewTLSObfs(c, s.obfsOption.Host)
</s> add c = obfs.NewTLSObfs(c, option.obfsOption.Host) </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
if s.version == snell.Version2 {
c, err := s.pool.Get()
if err != nil {
return nil, err
}
port, _ := strconv.Atoi(metadata.DstPort)
err = snell.WriteHeader(c, metadata.String(), uint(port), s.version)
return NewConn(c, s), err
}
| <mask> }
<mask>
<mask> func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> c, err := dialer.DialContext(ctx, "tcp", s.addr)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", s.addr, err)
<mask> }
<mask> tcpKeepAlive(c)
<mask>
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove err := snell.WriteHeader(c, metadata.String(), uint(port))
</s> add err := snell.WriteHeader(c, metadata.String(), uint(port), s.version) </s> remove }, nil
</s> add version: option.Version,
}
if option.Version == snell.Version2 {
s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
c, err := dialer.DialContext(ctx, "tcp", addr)
if err != nil {
return nil, err
}
tcpKeepAlive(c)
return streamConn(c, streamOption{psk, option.Version, addr, obfsOption}), nil
})
}
return s, nil </s> remove c = snell.StreamConn(c, s.psk)
</s> add return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove return &Snell{
</s> add // backward compatible
if option.Version == 0 {
option.Version = snell.DefaultSnellVersion
}
if option.Version != snell.Version1 && option.Version != snell.Version2 {
return nil, fmt.Errorf("snell version error: %d", option.Version)
}
s := &Snell{ | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
// backward compatible
if option.Version == 0 {
option.Version = snell.DefaultSnellVersion
}
if option.Version != snell.Version1 && option.Version != snell.Version2 {
return nil, fmt.Errorf("snell version error: %d", option.Version)
}
s := &Snell{ | <mask> if obfsOption.Mode != "tls" && obfsOption.Mode != "http" {
<mask> return nil, fmt.Errorf("snell %s obfs mode error: %s", addr, obfsOption.Mode)
<mask> }
<mask>
<mask> return &Snell{
<mask> Base: &Base{
<mask> name: option.Name,
<mask> addr: addr,
<mask> tp: C.Snell,
<mask> },
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove }, nil
</s> add version: option.Version,
}
if option.Version == snell.Version2 {
s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
c, err := dialer.DialContext(ctx, "tcp", addr)
if err != nil {
return nil, err
}
tcpKeepAlive(c)
return streamConn(c, streamOption{psk, option.Version, addr, obfsOption}), nil
})
}
return s, nil </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} </s> remove func WriteHeader(conn net.Conn, host string, port uint) error {
</s> add func WriteHeader(conn net.Conn, host string, port uint, version int) error { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
version: option.Version,
}
if option.Version == snell.Version2 {
s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
c, err := dialer.DialContext(ctx, "tcp", addr)
if err != nil {
return nil, err
}
tcpKeepAlive(c)
return streamConn(c, streamOption{psk, option.Version, addr, obfsOption}), nil
})
}
return s, nil | <mask> tp: C.Snell,
<mask> },
<mask> psk: psk,
<mask> obfsOption: obfsOption,
<mask> }, nil
<mask> }
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return &Snell{
</s> add // backward compatible
if option.Version == 0 {
option.Version = snell.DefaultSnellVersion
}
if option.Version != snell.Version1 && option.Version != snell.Version2 {
return nil, fmt.Errorf("snell version error: %d", option.Version)
}
s := &Snell{ </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove func (sc *snellCipher) KeySize() int { return 32 }
</s> add func (sc *snellCipher) KeySize() int { return sc.keySize } | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | adapters/outbound/snell.go |
"crypto/aes" | <mask>
<mask> import (
<mask> "crypto/cipher"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/shadowaead"
<mask> "golang.org/x/crypto/argon2"
<mask> "golang.org/x/crypto/chacha20poly1305"
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove "golang.org/x/crypto/chacha20poly1305"
</s> add </s> remove CommandPing byte = 0
CommandConnect byte = 1
</s> add Version1 = 1
Version2 = 2
DefaultSnellVersion = Version1
)
const (
CommandPing byte = 0
CommandConnect byte = 1
CommandConnectV2 byte = 5 </s> remove github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a
</s> add github.com/Dreamacro/go-shadowsocks2 v0.1.6 | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
"github.com/Dreamacro/go-shadowsocks2/shadowaead" | <mask> "crypto/cipher"
<mask>
<mask> "golang.org/x/crypto/argon2"
<mask> "golang.org/x/crypto/chacha20poly1305"
<mask> )
<mask>
<mask> type snellCipher struct {
<mask> psk []byte
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
"golang.org/x/crypto/chacha20poly1305" | <mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/shadowaead"
<mask> "golang.org/x/crypto/argon2"
<mask> )
<mask>
<mask> type snellCipher struct {
<mask> psk []byte
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
keySize int | <mask> )
<mask>
<mask> type snellCipher struct {
<mask> psk []byte
<mask> makeAEAD func(key []byte) (cipher.AEAD, error)
<mask> }
<mask>
<mask> func (sc *snellCipher) KeySize() int { return sc.keySize }
<mask> func (sc *snellCipher) SaltSize() int { return 16 }
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (sc *snellCipher) KeySize() int { return 32 }
</s> add func (sc *snellCipher) KeySize() int { return sc.keySize } </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize())) </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
func (sc *snellCipher) KeySize() int { return sc.keySize } | <mask> psk []byte
<mask> makeAEAD func(key []byte) (cipher.AEAD, error)
<mask> }
<mask>
<mask> func (sc *snellCipher) KeySize() int { return 32 }
<mask> func (sc *snellCipher) SaltSize() int { return 16 }
<mask> func (sc *snellCipher) Encrypter(salt []byte) (cipher.AEAD, error) {
<mask> return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
<mask> }
<mask> func (sc *snellCipher) Decrypter(salt []byte) (cipher.AEAD, error) {
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize())) </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize())) | <mask>
<mask> func (sc *snellCipher) KeySize() int { return 32 }
<mask> func (sc *snellCipher) SaltSize() int { return 16 }
<mask> func (sc *snellCipher) Encrypter(salt []byte) (cipher.AEAD, error) {
<mask> return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
<mask> }
<mask> func (sc *snellCipher) Decrypter(salt []byte) (cipher.AEAD, error) {
<mask> return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
<mask> }
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (sc *snellCipher) KeySize() int { return 32 }
</s> add func (sc *snellCipher) KeySize() int { return sc.keySize } </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} | <mask> func (sc *snellCipher) Encrypter(salt []byte) (cipher.AEAD, error) {
<mask> return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
<mask> }
<mask> func (sc *snellCipher) Decrypter(salt []byte) (cipher.AEAD, error) {
<mask> return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
<mask> }
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize())) </s> remove func (sc *snellCipher) KeySize() int { return 32 }
</s> add func (sc *snellCipher) KeySize() int { return sc.keySize } </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/cipher.go |
<mask> "net"
<mask> "sync"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/shadowaead"
<mask> "golang.org/x/crypto/chacha20poly1305"
<mask> )
<mask>
<mask> const (
<mask> CommandPing byte = 0
<mask> CommandConnect byte = 1
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove CommandPing byte = 0
CommandConnect byte = 1
</s> add Version1 = 1
Version2 = 2
DefaultSnellVersion = Version1
)
const (
CommandPing byte = 0
CommandConnect byte = 1
CommandConnectV2 byte = 5 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go | |
Version1 = 1
Version2 = 2
DefaultSnellVersion = Version1
)
const (
CommandPing byte = 0
CommandConnect byte = 1
CommandConnectV2 byte = 5 | <mask> "golang.org/x/crypto/chacha20poly1305"
<mask> )
<mask>
<mask> const (
<mask> CommandPing byte = 0
<mask> CommandConnect byte = 1
<mask>
<mask> CommandTunnel byte = 0
<mask> CommandError byte = 2
<mask>
<mask> Version byte = 1
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove "golang.org/x/crypto/chacha20poly1305"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go |
CommandPong byte = 1 | <mask>
<mask> CommandTunnel byte = 0
<mask> CommandError byte = 2
<mask>
<mask> Version byte = 1
<mask> )
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove CommandPing byte = 0
CommandConnect byte = 1
</s> add Version1 = 1
Version2 = 2
DefaultSnellVersion = Version1
)
const (
CommandPing byte = 0
CommandConnect byte = 1
CommandConnectV2 byte = 5 </s> remove "golang.org/x/crypto/chacha20poly1305"
</s> add </s> remove return &Snell{
</s> add // backward compatible
if option.Version == 0 {
option.Version = snell.DefaultSnellVersion
}
if option.Version != snell.Version1 && option.Version != snell.Version2 {
return nil, fmt.Errorf("snell version error: %d", option.Version)
}
s := &Snell{ | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go |
endSignal = []byte{} | <mask> )
<mask>
<mask> var (
<mask> bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
<mask> )
<mask>
<mask> type Snell struct {
<mask> net.Conn
<mask> buffer [1]byte
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go |
func WriteHeader(conn net.Conn, host string, port uint, version int) error { | <mask>
<mask> return 0, fmt.Errorf("server reported code: %d, message: %s", errcode, string(msg))
<mask> }
<mask>
<mask> func WriteHeader(conn net.Conn, host string, port uint) error {
<mask> buf := bufferPool.Get().(*bytes.Buffer)
<mask> buf.Reset()
<mask> defer bufferPool.Put(buf)
<mask> buf.WriteByte(Version)
<mask> buf.WriteByte(CommandConnect)
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove buf.WriteByte(CommandConnect)
</s> add if version == Version2 {
buf.WriteByte(CommandConnectV2)
} else {
buf.WriteByte(CommandConnect)
} </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { </s> remove return &Snell{
</s> add // backward compatible
if option.Version == 0 {
option.Version = snell.DefaultSnellVersion
}
if option.Version != snell.Version1 && option.Version != snell.Version2 {
return nil, fmt.Errorf("snell version error: %d", option.Version)
}
s := &Snell{ </s> remove c = snell.StreamConn(c, s.psk)
</s> add return snell.StreamConn(c, option.psk, option.version)
}
func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go |
if version == Version2 {
buf.WriteByte(CommandConnectV2)
} else {
buf.WriteByte(CommandConnect)
} | <mask> buf := bufferPool.Get().(*bytes.Buffer)
<mask> buf.Reset()
<mask> defer bufferPool.Put(buf)
<mask> buf.WriteByte(Version)
<mask> buf.WriteByte(CommandConnect)
<mask>
<mask> // clientID length & id
<mask> buf.WriteByte(0)
<mask>
<mask> // host & port
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func WriteHeader(conn net.Conn, host string, port uint) error {
</s> add func WriteHeader(conn net.Conn, host string, port uint, version int) error { </s> remove github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a
</s> add github.com/Dreamacro/go-shadowsocks2 v0.1.6 </s> remove return &Snell{
</s> add // backward compatible
if option.Version == 0 {
option.Version = snell.DefaultSnellVersion
}
if option.Version != snell.Version1 && option.Version != snell.Version2 {
return nil, fmt.Errorf("snell version error: %d", option.Version)
}
s := &Snell{ </s> remove func StreamConn(conn net.Conn, psk []byte) net.Conn {
cipher := &snellCipher{psk, chacha20poly1305.New}
</s> add // HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go |
// HalfClose works only on version2
func HalfClose(conn net.Conn) error {
if _, err := conn.Write(endSignal); err != nil {
return err
}
if s, ok := conn.(*Snell); ok {
s.reply = false
}
return nil
}
func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
var cipher shadowaead.Cipher
if version == Version2 {
cipher = NewAES128GCM(psk)
} else {
cipher = NewChacha20Poly1305(psk)
} | <mask>
<mask> return nil
<mask> }
<mask>
<mask> func StreamConn(conn net.Conn, psk []byte) net.Conn {
<mask> cipher := &snellCipher{psk, chacha20poly1305.New}
<mask> return &Snell{Conn: shadowaead.NewConn(conn, cipher)}
<mask> }
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize()))
}
func snellKDF(psk, salt []byte, keySize int) []byte {
// snell use a special kdf function
return argon2.IDKey(psk, salt, 3, 8, 1, 32)[:keySize]
}
func aesGCM(key []byte) (cipher.AEAD, error) {
blk, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
return cipher.NewGCM(blk)
}
func NewAES128GCM(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 16,
makeAEAD: aesGCM,
}
}
func NewChacha20Poly1305(psk []byte) shadowaead.Cipher {
return &snellCipher{
psk: psk,
keySize: 32,
makeAEAD: chacha20poly1305.New,
} </s> remove func (sc *snellCipher) KeySize() int { return 32 }
</s> add func (sc *snellCipher) KeySize() int { return sc.keySize } </s> remove }, nil
</s> add version: option.Version,
}
if option.Version == snell.Version2 {
s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
c, err := dialer.DialContext(ctx, "tcp", addr)
if err != nil {
return nil, err
}
tcpKeepAlive(c)
return streamConn(c, streamOption{psk, option.Version, addr, obfsOption}), nil
})
}
return s, nil </s> remove return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
</s> add return sc.makeAEAD(snellKDF(sc.psk, salt, sc.KeySize())) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | component/snell/snell.go |
github.com/Dreamacro/go-shadowsocks2 v0.1.6 | <mask>
<mask> go 1.14
<mask>
<mask> require (
<mask> github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a
<mask> github.com/eapache/queue v1.1.0 // indirect
<mask> github.com/go-chi/chi v4.1.2+incompatible
<mask> github.com/go-chi/cors v1.1.1
<mask> github.com/go-chi/render v1.0.1
<mask> github.com/gofrs/uuid v3.3.0+incompatible
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove 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> add github.com/Dreamacro/go-shadowsocks2 v0.1.6 h1:PysSf9sLT3Qn8jhlin5v7Rk68gOQG4K5BZFY1nxLGxI=
github.com/Dreamacro/go-shadowsocks2 v0.1.6/go.mod h1:LSXCjyHesPY3pLjhwff1mQX72ItcBT/N2xNC685cYeU= </s> remove buf.WriteByte(CommandConnect)
</s> add if version == Version2 {
buf.WriteByte(CommandConnectV2)
} else {
buf.WriteByte(CommandConnect)
} </s> remove "golang.org/x/crypto/chacha20poly1305"
</s> add </s> remove CommandPing byte = 0
CommandConnect byte = 1
</s> add Version1 = 1
Version2 = 2
DefaultSnellVersion = Version1
)
const (
CommandPing byte = 0
CommandConnect byte = 1
CommandConnectV2 byte = 5 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | go.mod |
github.com/Dreamacro/go-shadowsocks2 v0.1.6 h1:PysSf9sLT3Qn8jhlin5v7Rk68gOQG4K5BZFY1nxLGxI=
github.com/Dreamacro/go-shadowsocks2 v0.1.6/go.mod h1:LSXCjyHesPY3pLjhwff1mQX72ItcBT/N2xNC685cYeU= | <mask> github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a h1:JhQFrFOkCpRB8qsN6PrzHFzjy/8iQpFFk5cbOiplh6s=
<mask> github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a/go.mod h1:LSXCjyHesPY3pLjhwff1mQX72ItcBT/N2xNC685cYeU=
<mask> github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
<mask> github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
<mask> github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
<mask> github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc=
<mask> github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove github.com/Dreamacro/go-shadowsocks2 v0.1.6-0.20200722122336-8e5c7db4f96a
</s> add github.com/Dreamacro/go-shadowsocks2 v0.1.6 </s> remove golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
</s> add | [
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | go.sum |
<mask> github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
<mask> github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
<mask> github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
<mask> github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
<mask> github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
<mask> github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
<mask> github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
<mask> github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
<mask> github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
<mask> github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
</s> add </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | go.sum | |
<mask> golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20191224085550-c709ea063b76/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
<mask> golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed h1:J22ig1FUekjjkmZUM7pTKixYm8DvrYsvrBZdunYeIuQ=
<mask> golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
<mask> golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
</s> Feature: support snell v2 (#952)
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
switch s.obfsOption.Mode {
</s> add type streamOption struct {
psk []byte
version int
addr string
obfsOption *simpleObfsOption
}
func streamConn(c net.Conn, option streamOption) *snell.Snell {
switch option.obfsOption.Mode { </s> remove c = obfs.NewTLSObfs(c, s.obfsOption.Host)
</s> add c = obfs.NewTLSObfs(c, option.obfsOption.Host) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/96a8259c42797d3b2548c95b0790d1e9a4cbd266 | go.sum | |
type httpListener struct {
net.Listener
address string
closed bool
}
func NewHttpProxy(addr string) (*httpListener, error) { | <mask> var (
<mask> tun = tunnel.Instance()
<mask> )
<mask>
<mask> func NewHttpProxy(addr string) (chan<- struct{}, <-chan struct{}, error) {
<mask> l, err := net.Listen("tcp", addr)
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
</s> Fix: goroutine leak while closing proxy (#43)
* Fix: goroutine leak while closing proxy
* Chore: improve proxy architecture
* Fix: stack overflow </s> remove func NewSocksProxy(addr string) (chan<- struct{}, <-chan struct{}, error) {
</s> add type sockListener struct {
net.Listener
address string
closed bool
}
func NewSocksProxy(addr string) (*sockListener, error) { </s> remove func NewRedirProxy(addr string) (chan<- struct{}, <-chan struct{}, error) {
</s> add type redirListener struct {
net.Listener
address string
closed bool
}
func NewRedirProxy(addr string) (*redirListener, error) { </s> remove return nil, nil, err
</s> add return nil, err </s> remove return nil, nil, err
</s> add return nil, err </s> remove return nil, nil, err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/970643b14443a3eab1a62c2a1016be6a4bb502cd | proxy/http/server.go |
return nil, err | <mask>
<mask> func NewHttpProxy(addr string) (chan<- struct{}, <-chan struct{}, error) {
<mask> l, err := net.Listen("tcp", addr)
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> done := make(chan struct{})
<mask> closed := make(chan struct{})
<mask>
</s> Fix: goroutine leak while closing proxy (#43)
* Fix: goroutine leak while closing proxy
* Chore: improve proxy architecture
* Fix: stack overflow </s> remove return nil, nil, err
</s> add return nil, err </s> remove return nil, nil, err
</s> add return nil, err </s> remove func NewHttpProxy(addr string) (chan<- struct{}, <-chan struct{}, error) {
</s> add type httpListener struct {
net.Listener
address string
closed bool
}
func NewHttpProxy(addr string) (*httpListener, error) { </s> remove
done := make(chan struct{})
closed := make(chan struct{})
</s> add hl := &httpListener{l, addr, false} </s> remove
done := make(chan struct{})
closed := make(chan struct{})
</s> add rl := &redirListener{l, addr, false} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/970643b14443a3eab1a62c2a1016be6a4bb502cd | proxy/http/server.go |
hl := &httpListener{l, addr, false} | <mask> l, err := net.Listen("tcp", addr)
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> done := make(chan struct{})
<mask> closed := make(chan struct{})
<mask>
<mask> go func() {
<mask> log.Infoln("HTTP proxy listening at: %s", addr)
<mask> for {
<mask> c, err := l.Accept()
</s> Fix: goroutine leak while closing proxy (#43)
* Fix: goroutine leak while closing proxy
* Chore: improve proxy architecture
* Fix: stack overflow </s> remove
done := make(chan struct{})
closed := make(chan struct{})
</s> add rl := &redirListener{l, addr, false} </s> remove done := make(chan struct{})
closed := make(chan struct{})
</s> add sl := &sockListener{l, addr, false} </s> remove return nil, nil, err
</s> add return nil, err </s> remove return nil, nil, err
</s> add return nil, err </s> remove return nil, nil, err
</s> add return nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/970643b14443a3eab1a62c2a1016be6a4bb502cd | proxy/http/server.go |
c, err := hl.Accept() | <mask>
<mask> go func() {
<mask> log.Infoln("HTTP proxy listening at: %s", addr)
<mask> for {
<mask> c, err := l.Accept()
<mask> if err != nil {
<mask> if _, open := <-done; !open {
<mask> break
<mask> }
<mask> continue
</s> Fix: goroutine leak while closing proxy (#43)
* Fix: goroutine leak while closing proxy
* Chore: improve proxy architecture
* Fix: stack overflow </s> remove if _, open := <-done; !open {
</s> add if hl.closed { </s> remove if _, open := <-done; !open {
</s> add if sl.closed { </s> remove if _, open := <-done; !open {
</s> add if rl.closed { </s> remove
done := make(chan struct{})
closed := make(chan struct{})
</s> add hl := &httpListener{l, addr, false} </s> remove done := make(chan struct{})
closed := make(chan struct{})
</s> add sl := &sockListener{l, addr, false} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/970643b14443a3eab1a62c2a1016be6a4bb502cd | proxy/http/server.go |
if hl.closed { | <mask> log.Infoln("HTTP proxy listening at: %s", addr)
<mask> for {
<mask> c, err := l.Accept()
<mask> if err != nil {
<mask> if _, open := <-done; !open {
<mask> break
<mask> }
<mask> continue
<mask> }
<mask> go handleConn(c)
</s> Fix: goroutine leak while closing proxy (#43)
* Fix: goroutine leak while closing proxy
* Chore: improve proxy architecture
* Fix: stack overflow </s> remove c, err := l.Accept()
</s> add c, err := hl.Accept() </s> remove if _, open := <-done; !open {
</s> add if sl.closed { </s> remove if _, open := <-done; !open {
</s> add if rl.closed { </s> remove
done := make(chan struct{})
closed := make(chan struct{})
</s> add hl := &httpListener{l, addr, false} </s> remove done := make(chan struct{})
closed := make(chan struct{})
</s> add sl := &sockListener{l, addr, false} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/970643b14443a3eab1a62c2a1016be6a4bb502cd | proxy/http/server.go |
return hl, nil
}
func (l *httpListener) Close() {
l.closed = true
l.Listener.Close()
} | <mask> go handleConn(c)
<mask> }
<mask> }()
<mask>
<mask> go func() {
<mask> <-done
<mask> l.Close()
<mask> closed <- struct{}{}
<mask> }()
<mask>
<mask> return done, closed, nil
<mask> }
<mask>
<mask> func handleConn(conn net.Conn) {
</s> Fix: goroutine leak while closing proxy (#43)
* Fix: goroutine leak while closing proxy
* Chore: improve proxy architecture
* Fix: stack overflow </s> remove go func() {
<-done
l.Close()
closed <- struct{}{}
}()
</s> add return sl, nil
}
func (l *sockListener) Close() {
l.closed = true
l.Listener.Close()
} </s> remove go func() {
<-done
l.Close()
closed <- struct{}{}
}()
</s> add return rl, nil
}
func (l *redirListener) Close() {
l.closed = true
l.Listener.Close()
} </s> remove return done, closed, nil
</s> add func (l *httpListener) Address() string {
return l.address </s> remove return done, closed, nil
</s> add func (l *redirListener) Address() string {
return l.address </s> remove return done, closed, nil
</s> add func (l *sockListener) Address() string {
return l.address | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/970643b14443a3eab1a62c2a1016be6a4bb502cd | proxy/http/server.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.