docstring_tokens stringlengths 0 76.5k | code_tokens stringlengths 75 1.81M | label_window listlengths 4 2.12k | html_url stringlengths 74 116 | file_name stringlengths 3 311 |
|---|---|---|---|---|
if resolver.IsFakeIP(metadata.DstIP) { | <mask> }
<mask>
<mask> // make a fAddr if requset ip is fakeip
<mask> var fAddr net.Addr
<mask> if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
<mask> fAddr = metadata.UDPAddr()
<mask> }
<mask>
<mask> if err := preHandleMetadata(metadata); err != nil {
<mask> log.Debugln("[Metadata PreHandle] error: %s", err)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove D.HandleFailed(w, r)
return
</s> add return msg, err </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go |
opts := parseURLTestOption(config)
group = NewURLTest(groupName, providers, opts...) | <mask>
<mask> var group C.ProxyAdapter
<mask> switch groupOption.Type {
<mask> case "url-test":
<mask> group = NewURLTest(groupName, providers)
<mask> case "select":
<mask> group = NewSelector(groupName, providers)
<mask> case "fallback":
<mask> group = NewFallback(groupName, providers)
<mask> case "load-balance":
</s> Feature: add tolerance for url-test </s> remove func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
return &URLTest{
</s> add func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/parser.go |
type urlTestOption func(*URLTest)
func urlTestWithTolerance(tolerance uint16) urlTestOption {
return func(u *URLTest) {
u.tolerance = tolerance
}
}
| <mask> )
<mask>
<mask> type URLTest struct {
<mask> *outbound.Base
<mask> tolerance uint16
<mask> lastDelay uint16
<mask> fastNode C.Proxy
<mask> single *singledo.Single
</s> Feature: add tolerance for url-test </s> remove func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
return &URLTest{
</s> add func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ </s> remove group = NewURLTest(groupName, providers)
</s> add opts := parseURLTestOption(config)
group = NewURLTest(groupName, providers, opts...) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/urltest.go |
tolerance uint16
lastDelay uint16
fastNode C.Proxy | <mask> type URLTest struct {
<mask> *outbound.Base
<mask> single *singledo.Single
<mask> fastSingle *singledo.Single
<mask> providers []provider.ProxyProvider
<mask> }
<mask>
<mask> func (u *URLTest) Now() string {
</s> Feature: add tolerance for url-test </s> remove func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
return &URLTest{
</s> add func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ </s> remove group = NewURLTest(groupName, providers)
</s> add opts := parseURLTestOption(config)
group = NewURLTest(groupName, providers, opts...) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/urltest.go |
// tolerance
if u.tolerance != 0 && u.fastNode != nil {
if u.fastNode.LastDelay() < u.lastDelay+u.tolerance {
return u.fastNode, nil
}
}
| <mask>
<mask> func (u *URLTest) fast() C.Proxy {
<mask> elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
<mask> proxies := u.proxies()
<mask> fast := proxies[0]
<mask> min := fast.LastDelay()
<mask> for _, proxy := range proxies[1:] {
</s> Feature: add tolerance for url-test </s> remove func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
return &URLTest{
</s> add func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ </s> remove group = NewURLTest(groupName, providers)
</s> add opts := parseURLTestOption(config)
group = NewURLTest(groupName, providers, opts...) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/urltest.go |
u.fastNode = fast
u.lastDelay = fast.LastDelay() | <mask> }
<mask> }
<mask> return fast, nil
<mask> })
<mask>
<mask> return elm.(C.Proxy)
</s> Feature: add tolerance for url-test </s> remove func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
return &URLTest{
</s> add func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/urltest.go |
func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ | <mask> "all": all,
<mask> })
<mask> }
<mask>
<mask> func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
<mask> return &URLTest{
<mask> Base: outbound.NewBase(name, "", C.URLTest, false),
<mask> single: singledo.NewSingle(defaultGetProxiesDuration),
<mask> fastSingle: singledo.NewSingle(time.Second * 10),
<mask> providers: providers,
<mask> }
</s> Feature: add tolerance for url-test | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/urltest.go |
for _, option := range options {
option(urlTest)
}
return urlTest | <mask> single: singledo.NewSingle(defaultGetProxiesDuration),
<mask> fastSingle: singledo.NewSingle(time.Second * 10),
<mask> providers: providers,
<mask> }
<mask> }
</s> Feature: add tolerance for url-test </s> remove func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
return &URLTest{
</s> add func parseURLTestOption(config map[string]interface{}) []urlTestOption {
opts := []urlTestOption{}
// tolerance
if elm, ok := config["tolerance"]; ok {
if tolerance, ok := elm.(int); ok {
opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
}
}
return opts
}
func NewURLTest(name string, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
urlTest := &URLTest{ | [
"keep",
"keep",
"keep",
"add",
"keep"
] | https://github.com/Dreamacro/clash/commit/5628f97da113a523fdf26af4041e465234d83c84 | adapters/outboundgroup/urltest.go |
"crypto/tls" | <mask> import (
<mask> "context"
<mask> "encoding/json"
<mask> "fmt"
<mask> "net"
<mask> "strconv"
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove // vmess use stream-oriented udp, so clash needs a net.UDPAddr
</s> add // vmess use stream-oriented udp with a special address, so we needs a net.UDPAddr | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
"github.com/Dreamacro/clash/component/gun" | <mask>
<mask> "github.com/Dreamacro/clash/component/dialer"
<mask> "github.com/Dreamacro/clash/component/trojan"
<mask> C "github.com/Dreamacro/clash/constant"
<mask>
<mask> "golang.org/x/net/http2"
<mask> )
<mask>
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
"golang.org/x/net/http2" | <mask> "github.com/Dreamacro/clash/component/trojan"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type Trojan struct {
<mask> *Base
<mask> instance *trojan.Trojan
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
// for gun mux
gunTLSConfig *tls.Config
gunConfig *gun.Config
transport *http2.Transport | <mask>
<mask> type Trojan struct {
<mask> *Base
<mask> instance *trojan.Trojan
<mask> }
<mask>
<mask> type TrojanOption struct {
<mask> Name string `proxy:"name"`
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` | <mask> instance *trojan.Trojan
<mask> }
<mask>
<mask> type TrojanOption struct {
<mask> Name string `proxy:"name"`
<mask> Server string `proxy:"server"`
<mask> Port int `proxy:"port"`
<mask> Password string `proxy:"password"`
<mask> ALPN []string `proxy:"alpn,omitempty"`
<mask> SNI string `proxy:"sni,omitempty"`
<mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> UDP bool `proxy:"udp,omitempty"`
<mask> }
<mask>
<mask> func (t *Trojan) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> c, err := t.instance.StreamConn(c)
<mask> if err != nil {
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c, err := t.instance.StreamConn(c)
</s> add var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
| [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
| <mask> UDP bool `proxy:"udp,omitempty"`
<mask> }
<mask>
<mask> func (t *Trojan) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> c, err := t.instance.StreamConn(c)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
<mask>
<mask> err = t.instance.WriteHeader(c, trojan.CommandTCP, serializesSocksAddr(metadata))
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
// gun transport, TODO: Optimize mux dial code
if t.transport != nil {
c, err := gun.StreamGunWithTransport(t.transport, t.gunConfig)
if err != nil {
return nil, err
}
if err = t.instance.WriteHeader(c, trojan.CommandTCP, serializesSocksAddr(metadata)); err != nil {
c.Close()
return nil, err
}
return NewConn(c, t), nil
}
| <mask> return c, err
<mask> }
<mask>
<mask> func (t *Trojan) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> c, err := dialer.DialContext(ctx, "tcp", t.addr)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c, err := t.instance.StreamConn(c)
</s> add var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
</s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
// gun transport, TODO: Optimize mux dial code
if t.transport != nil {
c, err := gun.StreamGunWithTransport(t.transport, t.gunConfig)
if err != nil {
return nil, err
}
if err = t.instance.WriteHeader(c, trojan.CommandUDP, serializesSocksAddr(metadata)); err != nil {
c.Close()
return nil, err
}
pc := t.instance.PacketConn(c)
return newPacketConn(pc, t), err
}
| <mask> }
<mask>
<mask> func (t *Trojan) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
<mask> ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
<mask> defer cancel()
<mask> c, err := dialer.DialContext(ctx, "tcp", t.addr)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
<mask> }
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c, err := t.instance.StreamConn(c)
</s> add var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
</s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
t := &Trojan{ | <mask> if option.SNI != "" {
<mask> tOption.ServerName = option.SNI
<mask> }
<mask>
<mask> return &Trojan{
<mask> Base: &Base{
<mask> name: option.Name,
<mask> addr: addr,
<mask> tp: C.Trojan,
<mask> udp: option.UDP,
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return &Vmess{
</s> add v := &Vmess{ </s> remove if option.Network == "h2" && !option.TLS {
return nil, fmt.Errorf("TLS must be true with h2 network")
</s> add switch option.Network {
case "h2", "grpc":
if !option.TLS {
return nil, fmt.Errorf("TLS must be true with h2/grpc network")
} </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
}
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | <mask> tp: C.Trojan,
<mask> udp: option.UDP,
<mask> },
<mask> instance: trojan.New(tOption),
<mask> }, nil
<mask> }
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return &Trojan{
</s> add t := &Trojan{ </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil </s> remove return &Vmess{
</s> add v := &Vmess{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/trojan.go |
"crypto/tls" | <mask>
<mask> import (
<mask> "context"
<mask> "errors"
<mask> "fmt"
<mask> "net"
<mask> "net/http"
<mask> "strconv"
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove // vmess use stream-oriented udp, so clash needs a net.UDPAddr
</s> add // vmess use stream-oriented udp with a special address, so we needs a net.UDPAddr | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
"github.com/Dreamacro/clash/component/gun" | <mask> "strconv"
<mask> "strings"
<mask>
<mask> "github.com/Dreamacro/clash/component/dialer"
<mask> "github.com/Dreamacro/clash/component/resolver"
<mask> "github.com/Dreamacro/clash/component/vmess"
<mask> C "github.com/Dreamacro/clash/constant"
<mask>
<mask> "golang.org/x/net/http2"
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
"golang.org/x/net/http2" | <mask> "github.com/Dreamacro/clash/component/gun"
<mask> "github.com/Dreamacro/clash/component/resolver"
<mask> "github.com/Dreamacro/clash/component/vmess"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type Vmess struct {
<mask> *Base
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
// for gun mux
gunTLSConfig *tls.Config
gunConfig *gun.Config
transport *http2.Transport | <mask> type Vmess struct {
<mask> *Base
<mask> client *vmess.Client
<mask> option *VmessOption
<mask> }
<mask>
<mask> type VmessOption struct {
<mask> Name string `proxy:"name"`
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` | <mask> UDP bool `proxy:"udp,omitempty"`
<mask> Network string `proxy:"network,omitempty"`
<mask> HTTPOpts HTTPOptions `proxy:"http-opts,omitempty"`
<mask> HTTP2Opts HTTP2Options `proxy:"h2-opts,omitempty"`
<mask> WSPath string `proxy:"ws-path,omitempty"`
<mask> WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
<mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> ServerName string `proxy:"servername,omitempty"`
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` </s> remove c, err := t.instance.StreamConn(c)
</s> add var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
| [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
type GrpcOptions struct {
GrpcServiceName string `proxy:"grpc-service-name,omitempty"`
}
| <mask> Host []string `proxy:"host,omitempty"`
<mask> Path string `proxy:"path,omitempty"`
<mask> }
<mask>
<mask> func (v *Vmess) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> var err error
<mask> switch v.option.Network {
<mask> case "ws":
<mask> host, port, _ := net.SplitHostPort(v.addr)
<mask> wsOpts := &vmess.WebsocketConfig{
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove c, err := t.instance.StreamConn(c)
</s> add var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
</s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
ALPN []string `proxy:"alpn,omitempty"`
SNI string `proxy:"sni,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
UDP bool `proxy:"udp,omitempty"`
Network string `proxy:"network,omitempty"`
GrpcOpts GrpcOptions `proxy:"grpc-opts,omitempty"` </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
case "grpc":
c, err = gun.StreamGunWithConn(c, v.gunTLSConfig, v.gunConfig) | <mask> }
<mask>
<mask> c, err = vmess.StreamH2Conn(c, h2Opts)
<mask> default:
<mask> // handle TLS
<mask> if v.option.TLS {
<mask> host, _, _ := net.SplitHostPort(v.addr)
<mask> tlsOpts := &vmess.TLSConfig{
<mask> Host: host,
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
// gun transport, TODO: Optimize mux dial code
if v.transport != nil {
c, err := gun.StreamGunWithTransport(v.transport, v.gunConfig)
if err != nil {
return nil, err
}
c, err = v.client.StreamConn(c, parseVmessAddr(metadata))
if err != nil {
return nil, err
}
return NewConn(c, v), nil
}
| <mask> return v.client.StreamConn(c, parseVmessAddr(metadata))
<mask> }
<mask>
<mask> func (v *Vmess) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> c, err := dialer.DialContext(ctx, "tcp", v.addr)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
<mask> }
<mask> tcpKeepAlive(c)
<mask>
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
// vmess use stream-oriented udp with a special address, so we needs a net.UDPAddr | <mask> return NewConn(c, v), err
<mask> }
<mask>
<mask> func (v *Vmess) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
<mask> // vmess use stream-oriented udp, so clash needs a net.UDPAddr
<mask> if !metadata.Resolved() {
<mask> ip, err := resolver.ResolveIP(metadata.Host)
<mask> if err != nil {
<mask> return nil, errors.New("can't resolve ip")
<mask> }
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
// gun transport, TODO: Optimize mux dial code
if v.transport != nil {
c, err := gun.StreamGunWithTransport(v.transport, v.gunConfig)
if err != nil {
return nil, err
}
c, err = v.client.StreamConn(c, parseVmessAddr(metadata))
if err != nil {
return nil, err
}
return newPacketConn(&vmessPacketConn{Conn: c, rAddr: metadata.UDPAddr()}, v), nil
}
| <mask> }
<mask> metadata.DstIP = ip
<mask> }
<mask>
<mask> ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
<mask> defer cancel()
<mask> c, err := dialer.DialContext(ctx, "tcp", v.addr)
<mask> if err != nil {
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
switch option.Network {
case "h2", "grpc":
if !option.TLS {
return nil, fmt.Errorf("TLS must be true with h2/grpc network")
} | <mask> })
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> if option.Network == "h2" && !option.TLS {
<mask> return nil, fmt.Errorf("TLS must be true with h2 network")
<mask> }
<mask>
<mask> return &Vmess{
<mask> Base: &Base{
<mask> name: option.Name,
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove return &Vmess{
</s> add v := &Vmess{ </s> remove return &Trojan{
</s> add t := &Trojan{ </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
v := &Vmess{ | <mask> if option.Network == "h2" && !option.TLS {
<mask> return nil, fmt.Errorf("TLS must be true with h2 network")
<mask> }
<mask>
<mask> return &Vmess{
<mask> Base: &Base{
<mask> name: option.Name,
<mask> addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
<mask> tp: C.Vmess,
<mask> udp: option.UDP,
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove if option.Network == "h2" && !option.TLS {
return nil, fmt.Errorf("TLS must be true with h2 network")
</s> add switch option.Network {
case "h2", "grpc":
if !option.TLS {
return nil, fmt.Errorf("TLS must be true with h2/grpc network")
} </s> remove return &Trojan{
</s> add t := &Trojan{ </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil </s> remove // vmess use stream-oriented udp, so clash needs a net.UDPAddr
</s> add // vmess use stream-oriented udp with a special address, so we needs a net.UDPAddr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
}
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", v.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
gunConfig := &gun.Config{
ServiceName: v.option.GrpcOpts.GrpcServiceName,
Host: v.option.ServerName,
}
tlsConfig := &tls.Config{
InsecureSkipVerify: v.option.SkipCertVerify,
ServerName: v.option.ServerName,
}
if v.option.ServerName == "" {
host, _, _ := net.SplitHostPort(v.addr)
tlsConfig.ServerName = host
gunConfig.Host = host
}
v.gunTLSConfig = tlsConfig
v.gunConfig = gunConfig
v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
}
return v, nil | <mask> udp: option.UDP,
<mask> },
<mask> client: client,
<mask> option: &option,
<mask> }, nil
<mask> }
<mask>
<mask> func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
<mask> var addrType byte
<mask> var addr []byte
</s> Feature: add gRPC Transport for vmess/trojan (#1287)
Co-authored-by: eMeab <32988354+eMeab@users.noreply.github.com>
Co-authored-by: Dreamacro <8615343+Dreamacro@users.noreply.github.com> </s> remove }, nil
</s> add }
if option.Network == "grpc" {
dialFn := func(network, addr string) (net.Conn, error) {
c, err := dialer.DialContext(context.Background(), "tcp", t.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
}
tcpKeepAlive(c)
return c, nil
}
tlsConfig := &tls.Config{
NextProtos: option.ALPN,
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: tOption.SkipCertVerify,
ServerName: tOption.ServerName,
ClientSessionCache: getClientSessionCache(),
}
t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
t.gunTLSConfig = tlsConfig
t.gunConfig = &gun.Config{
ServiceName: option.GrpcOpts.GrpcServiceName,
Host: tOption.ServerName,
}
}
return t, nil </s> remove c, err := t.instance.StreamConn(c)
</s> add var err error
if t.transport != nil {
c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
} else {
c, err = t.instance.StreamConn(c)
}
</s> remove return &Trojan{
</s> add t := &Trojan{ </s> remove return &Vmess{
</s> add v := &Vmess{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/573316bcde9583ab42ecd0bfaffaeaec2f6d8c3b | adapters/outbound/vmess.go |
c, err := dialTimeout("tcp", address, tcpTimeout) | <mask> if metadata.DstIP != nil {
<mask> address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort)
<mask> }
<mask>
<mask> c, err := net.DialTimeout("tcp", address, tcpTimeout)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> tcpKeepAlive(c)
<mask> return c, nil
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/direct.go |
addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask> return pc, addr, nil
<mask> }
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/direct.go |
c, err := dialTimeout("tcp", h.addr, tcpTimeout) | <mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> }
<mask>
<mask> func (h *Http) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
<mask> if err == nil && h.tls {
<mask> cc := tls.Client(c, h.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
<mask> }
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/http.go |
c, err := dialTimeout("tcp", ss.server, tcpTimeout) | <mask> SkipCertVerify bool `obfs:"skip-cert-verify,omitempty"`
<mask> }
<mask>
<mask> func (ss *ShadowSocks) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %s", ss.server, err.Error())
<mask> }
<mask> tcpKeepAlive(c)
<mask> switch ss.obfsMode {
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/shadowsocks.go |
addr, err := resolveUDPAddr("udp", ss.server) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> addr, err := net.ResolveUDPAddr("udp", ss.server)
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/shadowsocks.go |
c, err := dialTimeout("tcp", ss.addr, tcpTimeout) | <mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> }
<mask>
<mask> func (ss *Socks5) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
<mask>
<mask> if err == nil && ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/socks5.go |
c, err := dialTimeout("tcp", ss.addr, tcpTimeout) | <mask> return c, nil
<mask> }
<mask>
<mask> func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
<mask> c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
<mask>
<mask> if err == nil && ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/socks5.go |
"github.com/Dreamacro/clash/dns" | <mask>
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> const (
<mask> tcpTimeout = 5 * time.Second
<mask> )
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove main: transform(config.Main),
</s> add </s> remove if t.resolver.IsFakeIP() {
</s> add if dns.DefaultResolver.IsFakeIP() { </s> remove host, exist := t.resolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/util.go |
c, err := dialTimeout("tcp", v.server, tcpTimeout) | <mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> }
<mask>
<mask> func (v *Vmess) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error", v.server)
<mask> }
<mask> tcpKeepAlive(c)
<mask> c, err = v.client.New(c, parseVmessAddr(metadata))
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/vmess.go |
c, err := dialTimeout("tcp", v.server, tcpTimeout) | <mask> return c, err
<mask> }
<mask>
<mask> func (v *Vmess) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
<mask> c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
<mask> if err != nil {
<mask> return nil, nil, fmt.Errorf("%s connect error", v.server)
<mask> }
<mask> tcpKeepAlive(c)
<mask> c, err = v.client.New(c, parseVmessAddr(metadata))
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | adapters/outbound/vmess.go |
IPv6: cfg.IPv6, | <mask>
<mask> dnsCfg := &DNS{
<mask> Enable: cfg.Enable,
<mask> Listen: cfg.Listen,
<mask> EnhancedMode: cfg.EnhancedMode,
<mask> }
<mask> var err error
<mask> if dnsCfg.NameServer, err = parseNameServer(cfg.NameServer); err != nil {
<mask> return nil, err
<mask> }
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", v.server, tcpTimeout) </s> remove T.Instance().SetResolver(r)
</s> add dns.DefaultResolver = r | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | config/config.go |
var (
// DefaultResolver aim to resolve ip with host
DefaultResolver *Resolver
)
| <mask> geoip2 "github.com/oschwald/geoip2-golang"
<mask> )
<mask>
<mask> var (
<mask> globalSessionCache = tls.NewLRUClientSessionCache(64)
<mask>
<mask> mmdb *geoip2.Reader
<mask> once sync.Once
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove if t.resolver.IsFakeIP() {
</s> add if dns.DefaultResolver.IsFakeIP() { </s> remove host, exist := t.resolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go |
ip = net.ParseIP(host)
if ip != nil {
return ip, nil
}
| <mask>
<mask> // ResolveIP request with TypeA and TypeAAAA, priority return TypeAAAA
<mask> func (r *Resolver) ResolveIP(host string) (ip net.IP, err error) {
<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: custom dns ipv4/ipv6 dual stack </s> remove close(ch)
</s> add </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go |
defer close(ch) | <mask> }
<mask>
<mask> ch := make(chan net.IP)
<mask> go func() {
<mask> ip, err := r.resolveIP(host, D.TypeA)
<mask> if err != nil {
<mask> return
<mask> }
<mask> ch <- ip
<mask> }()
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove close(ch)
</s> add </s> remove ip, closed := <-ch
if closed {
</s> add ip, open := <-ch
if !open { </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go |
<mask> ch := make(chan net.IP)
<mask> go func() {
<mask> ip, err := r.resolveIP(host, D.TypeA)
<mask> if err != nil {
<mask> close(ch)
<mask> return
<mask> }
<mask> ch <- ip
<mask> }()
<mask>
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove ip, closed := <-ch
if closed {
</s> add ip, open := <-ch
if !open { </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go | |
ip, open := <-ch
if !open { | <mask> }()
<mask> return
<mask> }
<mask>
<mask> ip, closed := <-ch
<mask> if closed {
<mask> return nil, errors.New("can't found ip")
<mask> }
<mask>
<mask> return ip, nil
<mask> }
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove close(ch)
</s> add </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go |
<mask> mmdb, _ = geoip2.Open(C.Path.MMDB())
<mask> })
<mask>
<mask> r := &Resolver{
<mask> main: transform(config.Main),
<mask> ipv6: config.IPv6,
<mask> cache: cache.New(time.Second * 60),
<mask> mapping: config.EnhancedMode == MAPPING,
<mask> fakeip: config.EnhancedMode == FAKEIP,
<mask> pool: config.Pool,
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove T.Instance().SetResolver(nil)
</s> add dns.DefaultResolver = nil </s> remove T.Instance().SetResolver(r)
</s> add dns.DefaultResolver = r </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go | |
main: transform(config.Main), | <mask> r := &Resolver{
<mask> ipv6: config.IPv6,
<mask> cache: cache.New(time.Second * 60),
<mask> mapping: config.EnhancedMode == MAPPING,
<mask> fakeip: config.EnhancedMode == FAKEIP,
<mask> pool: config.Pool,
<mask> }
<mask> if len(config.Fallback) != 0 {
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove main: transform(config.Main),
</s> add </s> remove T.Instance().SetResolver(nil)
</s> add dns.DefaultResolver = nil </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil </s> remove T.Instance().SetResolver(r)
</s> add dns.DefaultResolver = r | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | dns/resolver.go |
dns.DefaultResolver = nil | <mask> }
<mask>
<mask> func updateDNS(c *config.DNS) {
<mask> if c.Enable == false {
<mask> T.Instance().SetResolver(nil)
<mask> dns.ReCreateServer("", nil)
<mask> return
<mask> }
<mask> r := dns.New(dns.Config{
<mask> Main: c.NameServer,
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove ip, closed := <-ch
if closed {
</s> add ip, open := <-ch
if !open { </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove log.Infoln("DNS server listening at: %s", c.Listen)
</s> add if c.Listen != "" {
log.Infoln("DNS server listening at: %s", c.Listen)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | hub/executor/executor.go |
dns.DefaultResolver = r | <mask> IPv6: c.IPv6,
<mask> EnhancedMode: c.EnhancedMode,
<mask> Pool: c.FakeIPRange,
<mask> })
<mask> T.Instance().SetResolver(r)
<mask> if err := dns.ReCreateServer(c.Listen, r); err != nil {
<mask> log.Errorln("Start DNS server error: %s", err.Error())
<mask> return
<mask> }
<mask> log.Infoln("DNS server listening at: %s", c.Listen)
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove log.Infoln("DNS server listening at: %s", c.Listen)
</s> add if c.Listen != "" {
log.Infoln("DNS server listening at: %s", c.Listen)
} </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | hub/executor/executor.go |
if c.Listen != "" {
log.Infoln("DNS server listening at: %s", c.Listen)
} | <mask> if err := dns.ReCreateServer(c.Listen, r); err != nil {
<mask> log.Errorln("Start DNS server error: %s", err.Error())
<mask> return
<mask> }
<mask> log.Infoln("DNS server listening at: %s", c.Listen)
<mask> }
<mask>
<mask> func updateProxies(proxies map[string]C.Proxy) {
<mask> tunnel := T.Instance()
<mask> oldProxies := tunnel.Proxies()
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove T.Instance().SetResolver(r)
</s> add dns.DefaultResolver = r </s> remove c, err := net.DialTimeout("tcp", ss.server, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.server, tcpTimeout) </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | hub/executor/executor.go |
<mask> rules []C.Rule
<mask> proxies map[string]C.Proxy
<mask> configMux *sync.RWMutex
<mask> traffic *C.Traffic
<mask> resolver *dns.Resolver
<mask>
<mask> // experimental features
<mask> ignoreResolveFail bool
<mask>
<mask> // Outbound Rule
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove // SetResolver change the resolver of tunnel
func (t *Tunnel) SetResolver(resolver *dns.Resolver) {
t.resolver = resolver
}
func (t *Tunnel) hasResolver() bool {
return t.resolver != nil
}
</s> add </s> remove host, exist := t.resolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | tunnel/tunnel.go | |
<mask> func (t *Tunnel) SetMode(mode Mode) {
<mask> t.mode = mode
<mask> }
<mask>
<mask> // SetResolver change the resolver of tunnel
<mask> func (t *Tunnel) SetResolver(resolver *dns.Resolver) {
<mask> t.resolver = resolver
<mask> }
<mask>
<mask> func (t *Tunnel) hasResolver() bool {
<mask> return t.resolver != nil
<mask> }
<mask>
<mask> func (t *Tunnel) process() {
<mask> queue := t.queue.Out()
<mask> for {
<mask> elm := <-queue
<mask> conn := elm.(C.ServerAdapter)
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil </s> remove log.Infoln("DNS server listening at: %s", c.Listen)
</s> add if c.Listen != "" {
log.Infoln("DNS server listening at: %s", c.Listen)
} </s> remove host, exist := t.resolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | tunnel/tunnel.go | |
return dns.ResolveIP(host) | <mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) resolveIP(host string) (net.IP, error) {
<mask> if t.resolver == nil {
<mask> ipAddr, err := net.ResolveIPAddr("ip", host)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> return ipAddr.IP, nil
<mask> }
<mask>
<mask> return t.resolver.ResolveIP(host)
<mask> }
<mask>
<mask> func (t *Tunnel) needLookupIP(metadata *C.Metadata) bool {
<mask> return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
<mask> }
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil </s> remove // SetResolver change the resolver of tunnel
func (t *Tunnel) SetResolver(resolver *dns.Resolver) {
t.resolver = resolver
}
func (t *Tunnel) hasResolver() bool {
return t.resolver != nil
}
</s> add </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove addr, err := net.ResolveUDPAddr("udp", ss.server)
</s> add addr, err := resolveUDPAddr("udp", ss.server) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | tunnel/tunnel.go |
return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil | <mask> return t.resolver.ResolveIP(host)
<mask> }
<mask>
<mask> func (t *Tunnel) needLookupIP(metadata *C.Metadata) bool {
<mask> return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
<mask> }
<mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> metadata := localConn.Metadata()
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove // SetResolver change the resolver of tunnel
func (t *Tunnel) SetResolver(resolver *dns.Resolver) {
t.resolver = resolver
}
func (t *Tunnel) hasResolver() bool {
return t.resolver != nil
}
</s> add </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) </s> remove c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", ss.addr, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | tunnel/tunnel.go |
host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP) | <mask> }
<mask>
<mask> // preprocess enhanced-mode metadata
<mask> if t.needLookupIP(metadata) {
<mask> host, exist := t.resolver.IPToHost(*metadata.DstIP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if t.resolver.IsFakeIP() {
<mask> metadata.DstIP = nil
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove if t.resolver.IsFakeIP() {
</s> add if dns.DefaultResolver.IsFakeIP() { </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | tunnel/tunnel.go |
if dns.DefaultResolver.IsFakeIP() { | <mask> host, exist := t.resolver.IPToHost(*metadata.DstIP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if t.resolver.IsFakeIP() {
<mask> metadata.DstIP = nil
<mask> }
<mask> }
<mask> }
<mask>
</s> Feature: custom dns ipv4/ipv6 dual stack </s> remove host, exist := t.resolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP) </s> remove c, err := net.DialTimeout("tcp", address, tcpTimeout)
</s> add c, err := dialTimeout("tcp", address, tcpTimeout) </s> remove if t.resolver == nil {
ipAddr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return ipAddr.IP, nil
}
return t.resolver.ResolveIP(host)
</s> add return dns.ResolveIP(host) </s> remove T.Instance().SetResolver(nil)
</s> add dns.DefaultResolver = nil </s> remove c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
</s> add c, err := dialTimeout("tcp", h.addr, tcpTimeout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/57fdd223f1079af84582c6152ba108d366a6a161 | tunnel/tunnel.go |
BindAddress string `json:"bind-address"` | <mask> RedirPort int `json:"redir-port"`
<mask> Authentication []string `json:"authentication"`
<mask> AllowLan bool `json:"allow-lan"`
<mask> Mode T.Mode `json:"mode"`
<mask> LogLevel log.LogLevel `json:"log-level"`
<mask> ExternalController string `json:"-"`
<mask> ExternalUI string `json:"-"`
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"`
</s> add Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
BindAddress *string `json:"bind-address"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"` </s> remove Port int `json:"port"`
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | config/config.go |
BindAddress string `yaml:"bind-address"` | <mask> SocksPort int `yaml:"socks-port"`
<mask> RedirPort int `yaml:"redir-port"`
<mask> Authentication []string `yaml:"authentication"`
<mask> AllowLan bool `yaml:"allow-lan"`
<mask> Mode T.Mode `yaml:"mode"`
<mask> LogLevel log.LogLevel `yaml:"log-level"`
<mask> ExternalController string `yaml:"external-controller"`
<mask> ExternalUI string `yaml:"external-ui"`
<mask> Secret string `yaml:"secret"`
<mask>
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove Port int `json:"port"`
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"`
</s> add Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
BindAddress *string `json:"bind-address"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"` </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | config/config.go |
BindAddress: "*", | <mask>
<mask> // config with some default value
<mask> rawConfig := &rawConfig{
<mask> AllowLan: false,
<mask> Mode: T.Rule,
<mask> Authentication: []string{},
<mask> LogLevel: log.INFO,
<mask> Rule: []string{},
<mask> Proxy: []map[string]interface{}{},
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | config/config.go |
bindAddress := cfg.BindAddress | <mask> socksPort := cfg.SocksPort
<mask> redirPort := cfg.RedirPort
<mask> allowLan := cfg.AllowLan
<mask> externalController := cfg.ExternalController
<mask> externalUI := cfg.ExternalUI
<mask> secret := cfg.Secret
<mask> mode := cfg.Mode
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | config/config.go |
BindAddress: bindAddress, | <mask> SocksPort: socksPort,
<mask> RedirPort: redirPort,
<mask> AllowLan: allowLan,
<mask> Mode: mode,
<mask> LogLevel: logLevel,
<mask> ExternalController: externalController,
<mask> ExternalUI: externalUI,
<mask> Secret: secret,
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove return fmt.Sprintf(":%d", port)
</s> add if host == "*" {
return fmt.Sprintf(":%d", port)
} else {
return fmt.Sprintf("%s:%d", host, port)
} </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | config/config.go |
BindAddress: P.BindAddress(), | <mask> RedirPort: ports.RedirPort,
<mask> Authentication: authenticator,
<mask> AllowLan: P.AllowLan(),
<mask> Mode: T.Instance().Mode(),
<mask> LogLevel: log.Level(),
<mask> }
<mask>
<mask> return general
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"`
</s> add Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
BindAddress *string `json:"bind-address"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"` </s> remove return fmt.Sprintf(":%d", port)
</s> add if host == "*" {
return fmt.Sprintf(":%d", port)
} else {
return fmt.Sprintf("%s:%d", host, port)
} </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | hub/executor/executor.go |
bindAddress := general.BindAddress
P.SetBindAddress(bindAddress)
| <mask> P.SetAllowLan(allowLan)
<mask>
<mask> if err := P.ReCreateHTTP(general.Port); err != nil {
<mask> log.Errorln("Start HTTP server error: %s", err.Error())
<mask> }
<mask>
<mask> if err := P.ReCreateSocks(general.SocksPort); err != nil {
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove if portIsZero(addr) {
return nil
}
</s> add </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | hub/executor/executor.go |
Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
BindAddress *string `json:"bind-address"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"` | <mask> return r
<mask> }
<mask>
<mask> type configSchema struct {
<mask> Port *int `json:"port"`
<mask> SocksPort *int `json:"socks-port"`
<mask> RedirPort *int `json:"redir-port"`
<mask> AllowLan *bool `json:"allow-lan"`
<mask> Mode *T.Mode `json:"mode"`
<mask> LogLevel *log.LogLevel `json:"log-level"`
<mask> }
<mask>
<mask> func getConfigs(w http.ResponseWriter, r *http.Request) {
<mask> general := executor.GetGeneral()
<mask> render.JSON(w, r, general)
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove Port int `json:"port"`
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | hub/route/configs.go |
if general.BindAddress != nil {
P.SetBindAddress(*general.BindAddress)
}
| <mask> if general.AllowLan != nil {
<mask> P.SetAllowLan(*general.AllowLan)
<mask> }
<mask>
<mask> ports := P.GetPorts()
<mask> P.ReCreateHTTP(pointerOrDefault(general.Port, ports.Port))
<mask> P.ReCreateSocks(pointerOrDefault(general.SocksPort, ports.SocksPort))
<mask> P.ReCreateRedir(pointerOrDefault(general.RedirPort, ports.RedirPort))
<mask>
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | hub/route/configs.go |
allowLan = false
bindAddress = "*" | <mask> "github.com/Dreamacro/clash/proxy/socks"
<mask> )
<mask>
<mask> var (
<mask> allowLan = false
<mask>
<mask> socksListener *socks.SockListener
<mask> socksUDPListener *socks.SockUDPListener
<mask> httpListener *http.HttpListener
<mask> redirListener *redir.RedirListener
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove if portIsZero(addr) {
return nil
}
</s> add </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
func BindAddress() string {
return bindAddress
}
| <mask> func AllowLan() bool {
<mask> return allowLan
<mask> }
<mask>
<mask> func SetAllowLan(al bool) {
<mask> allowLan = al
<mask> }
<mask>
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { </s> remove return fmt.Sprintf(":%d", port)
</s> add if host == "*" {
return fmt.Sprintf(":%d", port)
} else {
return fmt.Sprintf("%s:%d", host, port)
} </s> remove if portIsZero(addr) {
return nil
}
</s> add </s> remove allowLan = false
</s> add allowLan = false
bindAddress = "*" | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
func SetBindAddress(host string) {
bindAddress = host
}
| <mask> func SetAllowLan(al bool) {
<mask> allowLan = al
<mask> }
<mask>
<mask> func ReCreateHTTP(port int) error {
<mask> addr := genAddr(bindAddress, port, allowLan)
<mask>
<mask> if httpListener != nil {
<mask> if httpListener.Address() == addr {
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
addr := genAddr(bindAddress, port, allowLan) | <mask> Address() string
<mask> }
<mask>
<mask> type Ports struct {
<mask> Port int `json:"port"`
<mask> SocksPort int `json:"socks-port"`
<mask> RedirPort int `json:"redir-port"`
<mask> MixedPort int `json:"mixed-port"`
<mask> }
<mask>
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"`
</s> add Port *int `json:"port"`
SocksPort *int `json:"socks-port"`
RedirPort *int `json:"redir-port"`
AllowLan *bool `json:"allow-lan"`
BindAddress *string `json:"bind-address"`
Mode *T.Mode `json:"mode"`
LogLevel *log.LogLevel `json:"log-level"` </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
addr := genAddr(bindAddress, port, allowLan) | <mask> return nil
<mask> }
<mask>
<mask> func ReCreateSocks(port int) error {
<mask> addr := genAddr(port, allowLan)
<mask>
<mask> if socksListener != nil {
<mask> if socksListener.Address() == addr {
<mask> return nil
<mask> }
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) </s> remove if portIsZero(addr) {
return nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
return reCreateSocksUDP(addr) | <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> return reCreateSocksUDP(port)
<mask> }
<mask>
<mask> func reCreateSocksUDP(port int) error {
<mask> addr := genAddr(port, allowLan)
<mask>
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove if portIsZero(addr) {
return nil
}
</s> add </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
func reCreateSocksUDP(addr string) error { | <mask>
<mask> return reCreateSocksUDP(port)
<mask> }
<mask>
<mask> func reCreateSocksUDP(port int) error {
<mask> addr := genAddr(port, allowLan)
<mask>
<mask> if socksUDPListener != nil {
<mask> if socksUDPListener.Address() == addr {
<mask> return nil
<mask> }
<mask> socksUDPListener.Close()
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove if portIsZero(addr) {
return nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
<mask> socksUDPListener.Close()
<mask> socksUDPListener = nil
<mask> }
<mask>
<mask> if portIsZero(addr) {
<mask> return nil
<mask> }
<mask>
<mask> var err error
<mask> socksUDPListener, err = socks.NewSocksUDPProxy(addr)
<mask> if err != nil {
<mask> return err
<mask> }
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove allowLan = false
</s> add allowLan = false
bindAddress = "*" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go | |
addr := genAddr(bindAddress, port, allowLan) | <mask> return nil
<mask> }
<mask>
<mask> func ReCreateRedir(port int) error {
<mask> addr := genAddr(port, allowLan)
<mask>
<mask> if redirListener != nil {
<mask> if redirListener.Address() == addr {
<mask> return nil
<mask> }
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove addr := genAddr(port, allowLan)
</s> add addr := genAddr(bindAddress, port, allowLan) </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove return reCreateSocksUDP(port)
</s> add return reCreateSocksUDP(addr) </s> remove if portIsZero(addr) {
return nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
func genAddr(host string, port int, allowLan bool) string { | <mask> }
<mask> return false
<mask> }
<mask>
<mask> func genAddr(port int, allowLan bool) string {
<mask> if allowLan {
<mask> return fmt.Sprintf(":%d", port)
<mask> }
<mask> return fmt.Sprintf("127.0.0.1:%d", port)
<mask> }
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove return fmt.Sprintf(":%d", port)
</s> add if host == "*" {
return fmt.Sprintf(":%d", port)
} else {
return fmt.Sprintf("%s:%d", host, port)
} </s> remove allowLan = false
</s> add allowLan = false
bindAddress = "*" </s> remove if portIsZero(addr) {
return nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
if host == "*" {
return fmt.Sprintf(":%d", port)
} else {
return fmt.Sprintf("%s:%d", host, port)
} | <mask> }
<mask>
<mask> func genAddr(port int, allowLan bool) string {
<mask> if allowLan {
<mask> return fmt.Sprintf(":%d", port)
<mask> }
<mask> return fmt.Sprintf("127.0.0.1:%d", port)
<mask> }
</s> Feature: support customizing bind-address when allow-lan is true (#255) </s> remove func genAddr(port int, allowLan bool) string {
</s> add func genAddr(host string, port int, allowLan bool) string { </s> remove func reCreateSocksUDP(port int) error {
addr := genAddr(port, allowLan)
</s> add func reCreateSocksUDP(addr string) error { </s> remove Port int `json:"port"`
</s> add addr := genAddr(bindAddress, port, allowLan) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5829c3d5be39a5472f04d4bd9a640cfcc77b3323 | proxy/listener.go |
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) | <mask> // StreamConn implements C.ProxyAdapter
<mask> func (h *Http) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> if h.tlsConfig != nil {
<mask> cc := tls.Client(c, h.tlsConfig)
<mask> err := cc.Handshake()
<mask> c = cc
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
<mask> }
<mask> }
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err = cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err = cc.HandshakeContext(ctx) </s> remove dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
</s> add dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | adapter/outbound/http.go |
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) | <mask> // StreamConn implements C.ProxyAdapter
<mask> func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
<mask> if ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err := cc.Handshake()
<mask> c = cc
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
<mask> }
<mask> }
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err = cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err = cc.HandshakeContext(ctx) </s> remove dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
</s> add dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | adapter/outbound/socks5.go |
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err = cc.HandshakeContext(ctx) | <mask> }
<mask>
<mask> if ss.tls {
<mask> cc := tls.Client(c, ss.tlsConfig)
<mask> err = cc.Handshake()
<mask> c = cc
<mask> }
<mask>
<mask> defer safeConnClose(c, err)
<mask>
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add </s> remove dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
</s> add dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | adapter/outbound/socks5.go |
golang.org/x/net v0.0.0-20220812174116-3211cb980234 | <mask> go.etcd.io/bbolt v1.3.6
<mask> go.uber.org/atomic v1.9.0
<mask> go.uber.org/automaxprocs v1.5.1
<mask> golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d
<mask> golang.org/x/net v0.0.0-20220706163947-c90051bbdb60
<mask> golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f
<mask> golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e
<mask> gopkg.in/yaml.v3 v3.0.1
<mask> )
<mask>
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60 h1:8NSylCMxLW4JvserAndSgFL7aPli6A68yf0bYFTcWCM=
golang.org/x/net v0.0.0-20220706163947-c90051bbdb60/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 h1:RDqmgfe7SvlMWoqC3xwQ2blLO3fcWcxMa3eBLRdRW7E=
golang.org/x/net v0.0.0-20220812174116-3211cb980234/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e h1:CsOuNlbOuf0mzxJIefr6Q4uAUetRUwZE4qt7VfzP+xo=
golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 h1:WIoqL4EROvwiPdUtaip4VcDdpZ4kha7wBWZrbVKCIZg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= </s> remove C "github.com/Dreamacro/clash/constant"
</s> add </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | go.mod |
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 | <mask> go.uber.org/automaxprocs v1.5.1
<mask> golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d
<mask> golang.org/x/net v0.0.0-20220706163947-c90051bbdb60
<mask> golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f
<mask> golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e
<mask> gopkg.in/yaml.v3 v3.0.1
<mask> )
<mask>
<mask> require (
<mask> github.com/davecgh/go-spew v1.1.1 // indirect
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60 h1:8NSylCMxLW4JvserAndSgFL7aPli6A68yf0bYFTcWCM=
golang.org/x/net v0.0.0-20220706163947-c90051bbdb60/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 h1:RDqmgfe7SvlMWoqC3xwQ2blLO3fcWcxMa3eBLRdRW7E=
golang.org/x/net v0.0.0-20220812174116-3211cb980234/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e h1:CsOuNlbOuf0mzxJIefr6Q4uAUetRUwZE4qt7VfzP+xo=
golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 h1:WIoqL4EROvwiPdUtaip4VcDdpZ4kha7wBWZrbVKCIZg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= </s> remove C "github.com/Dreamacro/clash/constant"
</s> add </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | go.mod |
golang.org/x/net v0.0.0-20220812174116-3211cb980234 h1:RDqmgfe7SvlMWoqC3xwQ2blLO3fcWcxMa3eBLRdRW7E=
golang.org/x/net v0.0.0-20220812174116-3211cb980234/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= | <mask> golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
<mask> golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
<mask> golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
<mask> golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
<mask> golang.org/x/net v0.0.0-20220706163947-c90051bbdb60 h1:8NSylCMxLW4JvserAndSgFL7aPli6A68yf0bYFTcWCM=
<mask> golang.org/x/net v0.0.0-20220706163947-c90051bbdb60/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
<mask> golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
<mask> golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
<mask> golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f h1:Ax0t5p6N38Ga0dThY21weqDEyz2oklo4IvDkpigvkD8=
<mask> golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
<mask> golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e h1:CsOuNlbOuf0mzxJIefr6Q4uAUetRUwZE4qt7VfzP+xo=
golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 h1:WIoqL4EROvwiPdUtaip4VcDdpZ4kha7wBWZrbVKCIZg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | go.sum |
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 h1:WIoqL4EROvwiPdUtaip4VcDdpZ4kha7wBWZrbVKCIZg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= | <mask> golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20210525143221-35b2ab0089ea/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e h1:CsOuNlbOuf0mzxJIefr6Q4uAUetRUwZE4qt7VfzP+xo=
<mask> golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
<mask> golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
<mask> golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
<mask> golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
<mask> golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60 h1:8NSylCMxLW4JvserAndSgFL7aPli6A68yf0bYFTcWCM=
golang.org/x/net v0.0.0-20220706163947-c90051bbdb60/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 h1:RDqmgfe7SvlMWoqC3xwQ2blLO3fcWcxMa3eBLRdRW7E=
golang.org/x/net v0.0.0-20220812174116-3211cb980234/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | go.sum |
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> C "github.com/Dreamacro/clash/constant"
<mask>
<mask> "go.uber.org/atomic"
<mask> "golang.org/x/net/http2"
<mask> )
<mask>
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove golang.org/x/net v0.0.0-20220706163947-c90051bbdb60
</s> add golang.org/x/net v0.0.0-20220812174116-3211cb980234 </s> remove golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e
</s> add golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add </s> remove dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
</s> add dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | transport/gun/gun.go | |
dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { | <mask> return nil
<mask> }
<mask>
<mask> func NewHTTP2Client(dialFn DialFn, tlsConfig *tls.Config) *http2.Transport {
<mask> dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
<mask> pconn, err := dialFn(network, addr)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add </s> remove err = cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err = cc.HandshakeContext(ctx) </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | transport/gun/gun.go |
<mask> return nil, err
<mask> }
<mask>
<mask> cn := tls.Client(pconn, cfg)
<mask>
<mask> // fix tls handshake not timeout
<mask> ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
<mask> defer cancel()
<mask> if err := cn.HandshakeContext(ctx); err != nil {
<mask> pconn.Close()
<mask> return nil, err
<mask> }
<mask> state := cn.ConnectionState()
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err = cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err = cc.HandshakeContext(ctx) </s> remove dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
</s> add dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { </s> remove DialTLS: dialFunc,
</s> add DialTLSContext: dialFunc, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | transport/gun/gun.go | |
DialTLSContext: dialFunc, | <mask> return cn, nil
<mask> }
<mask>
<mask> return &http2.Transport{
<mask> DialTLS: dialFunc,
<mask> TLSClientConfig: tlsConfig,
<mask> AllowHTTP: false,
<mask> DisableCompression: true,
<mask> PingTimeout: 0,
<mask> }
</s> Chore: http2 should use DialTLSContext and some tls handshake should with context </s> remove
// fix tls handshake not timeout
ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
</s> add </s> remove dialFunc := func(network, addr string, cfg *tls.Config) (net.Conn, error) {
</s> add dialFunc := func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err := cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err := cc.HandshakeContext(ctx) </s> remove err = cc.Handshake()
</s> add ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
defer cancel()
err = cc.HandshakeContext(ctx) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5940f627948b9d2b0ca3e985bff6b28ee63f64c3 | transport/gun/gun.go |
<mask> func NewConn(c net.Conn, a C.ProxyAdapter) C.Conn {
<mask> return &conn{c, []string{a.Name()}}
<mask> }
<mask>
<mask> type PacketConn interface {
<mask> net.PacketConn
<mask> WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
<mask> }
<mask>
<mask> type packetConn struct {
<mask> PacketConn
<mask> chain C.Chain
<mask> }
<mask>
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove PacketConn
</s> add net.PacketConn </s> remove func newPacketConn(pc PacketConn, a C.ProxyAdapter) C.PacketConn {
</s> add func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn { </s> remove WriteWithMetadata(p []byte, metadata *Metadata) (n int, err error)
</s> add // Deprecate WriteWithMetadata because of remote resolve DNS cause TURN failed
// WriteWithMetadata(p []byte, metadata *Metadata) (n int, err error) </s> remove
type trojanPacketConn struct {
net.PacketConn
conn net.Conn
}
func (tpc *trojanPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return trojan.WritePacket(tpc.conn, serializesSocksAddr(metadata), p)
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/base.go | |
net.PacketConn | <mask> WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
<mask> }
<mask>
<mask> type packetConn struct {
<mask> PacketConn
<mask> chain C.Chain
<mask> }
<mask>
<mask> func (c *packetConn) Chains() C.Chain {
<mask> return c.chain
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove type PacketConn interface {
net.PacketConn
WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
}
</s> add </s> remove func newPacketConn(pc PacketConn, a C.ProxyAdapter) C.PacketConn {
</s> add func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn { </s> remove
type trojanPacketConn struct {
net.PacketConn
conn net.Conn
}
func (tpc *trojanPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return trojan.WritePacket(tpc.conn, serializesSocksAddr(metadata), p)
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add </s> remove func (uc *vmessPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return uc.Conn.Write(p)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/base.go |
func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn { | <mask> func (c *packetConn) AppendToChains(a C.ProxyAdapter) {
<mask> c.chain = append(c.chain, a.Name())
<mask> }
<mask>
<mask> func newPacketConn(pc PacketConn, a C.ProxyAdapter) C.PacketConn {
<mask> return &packetConn{pc, []string{a.Name()}}
<mask> }
<mask>
<mask> type Proxy struct {
<mask> C.ProxyAdapter
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove type PacketConn interface {
net.PacketConn
WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
}
</s> add </s> remove PacketConn
</s> add net.PacketConn </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add </s> remove
type trojanPacketConn struct {
net.PacketConn
conn net.Conn
}
func (tpc *trojanPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return trojan.WritePacket(tpc.conn, serializesSocksAddr(metadata), p)
}
</s> add </s> remove if _, err := pc.WriteWithMetadata(packet.Data(), metadata); err != nil {
return
</s> add // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/base.go |
<mask> "context"
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/component/dialer"
<mask> "github.com/Dreamacro/clash/component/resolver"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type Direct struct {
<mask> *Base
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove type PacketConn interface {
net.PacketConn
WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
}
</s> add </s> remove PacketConn
</s> add net.PacketConn </s> remove func newPacketConn(pc PacketConn, a C.ProxyAdapter) C.PacketConn {
</s> add func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/direct.go | |
<mask> type directPacketConn struct {
<mask> net.PacketConn
<mask> }
<mask>
<mask> func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
<mask> if !metadata.Resolved() {
<mask> ip, err := resolver.ResolveIP(metadata.Host)
<mask> if err != nil {
<mask> return 0, err
<mask> }
<mask> metadata.DstIP = ip
<mask> }
<mask> return dp.WriteTo(p, metadata.UDPAddr())
<mask> }
<mask>
<mask> func NewDirect() *Direct {
<mask> return &Direct{
<mask> Base: &Base{
<mask> name: "DIRECT",
<mask> tp: C.Direct,
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove if _, err := pc.WriteWithMetadata(packet.Data(), metadata); err != nil {
return
</s> add // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip </s> remove func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
}
</s> add </s> remove func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet, uc.rAddr)
}
</s> add </s> remove func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) {
</s> add func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) error { | [
"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/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/direct.go | |
<mask> }
<mask> return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
<mask> }
<mask>
<mask> func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
<mask> packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
<mask> if err != nil {
<mask> return
<mask> }
<mask> return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
<mask> }
<mask>
<mask> func (spc *ssPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> n, _, e := spc.PacketConn.ReadFrom(b)
<mask> if e != nil {
<mask> return 0, nil, e
<mask> }
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet, uc.rAddr)
}
</s> add </s> remove func (uc *vmessPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return uc.Conn.Write(p)
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add </s> remove func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) {
</s> add func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) error { </s> remove if _, err := pc.WriteWithMetadata(packet.Data(), metadata); err != nil {
return
</s> add // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/shadowsocks.go | |
<mask> }
<mask> return uc.PacketConn.WriteTo(packet, uc.rAddr)
<mask> }
<mask>
<mask> func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
<mask> packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
<mask> if err != nil {
<mask> return
<mask> }
<mask> return uc.PacketConn.WriteTo(packet, uc.rAddr)
<mask> }
<mask>
<mask> func (uc *socksPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> n, _, e := uc.PacketConn.ReadFrom(b)
<mask> if e != nil {
<mask> return 0, nil, e
<mask> }
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
}
</s> add </s> remove func (uc *vmessPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return uc.Conn.Write(p)
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add </s> remove func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) {
</s> add func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) error { </s> remove if _, err := pc.WriteWithMetadata(packet.Data(), metadata); err != nil {
return
</s> add // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/socks5.go | |
return newPacketConn(pc, t), err | <mask> return nil, err
<mask> }
<mask>
<mask> pc := t.instance.PacketConn(c)
<mask> return newPacketConn(&trojanPacketConn{pc, c}, t), err
<mask> }
<mask>
<mask> func (t *Trojan) MarshalJSON() ([]byte, error) {
<mask> return json.Marshal(map[string]string{
<mask> "type": t.Type().String(),
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
}
</s> add </s> remove func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet, uc.rAddr)
}
</s> add </s> remove func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) {
</s> add func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) error { </s> remove if _, err := pc.WriteWithMetadata(packet.Data(), metadata); err != nil {
return
</s> add // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip </s> remove func (uc *vmessPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return uc.Conn.Write(p)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/trojan.go |
<mask> },
<mask> instance: trojan.New(tOption),
<mask> }, nil
<mask> }
<mask>
<mask> type trojanPacketConn struct {
<mask> net.PacketConn
<mask> conn net.Conn
<mask> }
<mask>
<mask> func (tpc *trojanPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
<mask> return trojan.WritePacket(tpc.conn, serializesSocksAddr(metadata), p)
<mask> }
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove PacketConn
</s> add net.PacketConn </s> remove type PacketConn interface {
net.PacketConn
WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add </s> remove func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
}
</s> add </s> remove func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet, uc.rAddr)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/trojan.go | |
<mask> func (uc *vmessPacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
<mask> return uc.Conn.Write(b)
<mask> }
<mask>
<mask> func (uc *vmessPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
<mask> return uc.Conn.Write(p)
<mask> }
<mask>
<mask> func (uc *vmessPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> n, err := uc.Conn.Read(b)
<mask> return n, uc.rAddr, err
<mask> }
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet, uc.rAddr)
}
</s> add </s> remove func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
if err != nil {
return
}
return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
}
</s> add </s> remove func (ut *udpTracker) WriteWithMetadata(p []byte, metadata *C.Metadata) (int, error) {
n, err := ut.PacketConn.WriteWithMetadata(p, metadata)
upload := int64(n)
ut.manager.Upload() <- upload
ut.UploadTotal += upload
return n, err
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | adapters/outbound/vmess.go | |
// Deprecate WriteWithMetadata because of remote resolve DNS cause TURN failed
// WriteWithMetadata(p []byte, metadata *Metadata) (n int, err error) | <mask>
<mask> type PacketConn interface {
<mask> net.PacketConn
<mask> Connection
<mask> WriteWithMetadata(p []byte, metadata *Metadata) (n int, err error)
<mask> }
<mask>
<mask> type ProxyAdapter interface {
<mask> Name() string
<mask> Type() AdapterType
</s> Change: local resolve DNS in UDP request due to TURN failed </s> remove type PacketConn interface {
net.PacketConn
WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
}
</s> add </s> remove PacketConn
</s> add net.PacketConn </s> remove
type trojanPacketConn struct {
net.PacketConn
conn net.Conn
}
func (tpc *trojanPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return trojan.WritePacket(tpc.conn, serializesSocksAddr(metadata), p)
}
</s> add </s> remove func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return 0, err
}
metadata.DstIP = ip
}
return dp.WriteTo(p, metadata.UDPAddr())
}
</s> add </s> remove func (uc *vmessPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
return uc.Conn.Write(p)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/59bda1d5473ad6e5109372ba0594d38c782481e3 | constant/adapters.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.