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 |
|---|---|---|---|---|
return nil, fmt.Errorf("%s: %w", groupName, errMissHealthCheck) | <mask> providers = append(providers, pd)
<mask> providersMap[groupName] = pd
<mask> } else {
<mask> if groupOption.URL == "" || groupOption.Interval == 0 {
<mask> return nil, errMissHealthCheck
<mask> }
<mask>
<mask> hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy)
<mask> pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
<mask> if err != nil {
</s> Chore: more parse proxy group error detail </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, errMissProxy
</s> add return nil, fmt.Errorf("%s: %w", groupName, errMissProxy) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd4912749001dab1bc0c2056b69966f54b6a904 | adapter/outboundgroup/parser.go |
return nil, fmt.Errorf("%s: %w", groupName, err) | <mask>
<mask> hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy)
<mask> pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> providers = append(providers, pd)
<mask> providersMap[groupName] = pd
<mask> }
</s> Chore: more parse proxy group error detail </s> remove return nil, errMissHealthCheck
</s> add return nil, fmt.Errorf("%s: %w", groupName, errMissHealthCheck) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, errMissProxy
</s> add return nil, fmt.Errorf("%s: %w", groupName, errMissProxy) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd4912749001dab1bc0c2056b69966f54b6a904 | adapter/outboundgroup/parser.go |
return nil, fmt.Errorf("%s: %w", groupName, err) | <mask>
<mask> if len(groupOption.Use) != 0 {
<mask> list, err := getProviders(providersMap, groupOption.Use)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> providers = append(providers, list...)
<mask> }
<mask>
<mask> var group C.ProxyAdapter
</s> Chore: more parse proxy group error detail </s> remove return nil, errMissProxy
</s> add return nil, fmt.Errorf("%s: %w", groupName, errMissProxy) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, errMissHealthCheck
</s> add return nil, fmt.Errorf("%s: %w", groupName, errMissHealthCheck) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd4912749001dab1bc0c2056b69966f54b6a904 | adapter/outboundgroup/parser.go |
return nil, fmt.Errorf("%s %w: %s", groupName, errType, groupOption.Type) | <mask> return NewLoadBalance(groupOption, providers, strategy)
<mask> case "relay":
<mask> group = NewRelay(groupOption, providers)
<mask> default:
<mask> return nil, fmt.Errorf("%w: %s", errType, groupOption.Type)
<mask> }
<mask>
<mask> return group, nil
<mask> }
<mask>
</s> Chore: more parse proxy group error detail </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) </s> remove return nil, errMissHealthCheck
</s> add return nil, fmt.Errorf("%s: %w", groupName, errMissHealthCheck) </s> remove return nil, err
</s> add return nil, fmt.Errorf("%s: %w", groupName, err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd4912749001dab1bc0c2056b69966f54b6a904 | adapter/outboundgroup/parser.go |
addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask> return newPacketConn(pc, d), addr, nil
<mask> }
</s> Fix: some UDP issues (#265) </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return nil, nil, err
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove return
</s> add return nil, nil, err </s> remove return newPacketConn(&fakeUDPConn{Conn: c}, v), c.RemoteAddr(), nil
</s> add return newPacketConn(&vmessUDPConn{Conn: c}, v), c.RemoteAddr(), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/direct.go |
addr := metadata.RemoteAddress() | <mask> func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
<mask> var buf bytes.Buffer
<mask> var err error
<mask>
<mask> addr := net.JoinHostPort(metadata.String(), metadata.DstPort)
<mask> buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
<mask> buf.WriteString("Host: " + metadata.String() + "\r\n")
<mask> buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
<mask>
<mask> if h.user != "" && h.pass != "" {
</s> Fix: some UDP issues (#265) </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove return
</s> add return nil, nil, err </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/http.go |
<mask> "fmt"
<mask> "net"
<mask> "strconv"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/common/structure"
<mask> obfs "github.com/Dreamacro/clash/component/simple-obfs"
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> v2rayObfs "github.com/Dreamacro/clash/component/v2ray-plugin"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Fix: some UDP issues (#265) </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add </s> remove queue: channels.NewInfiniteChannel(),
</s> add tcpQueue: channels.NewInfiniteChannel(),
udpQueue: channels.NewInfiniteChannel(),
natTable: nat.New(), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/shadowsocks.go | |
targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> pc = ss.cipher.PacketConn(pc)
<mask> return newPacketConn(&ssUDPConn{PacketConn: pc, rAddr: targetAddr}, ss), addr, nil
<mask> }
</s> Fix: some UDP issues (#265) </s> remove addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove return
</s> add return nil, nil, err </s> remove return newPacketConn(&fakeUDPConn{Conn: c}, v), c.RemoteAddr(), nil
</s> add return newPacketConn(&vmessUDPConn{Conn: c}, v), c.RemoteAddr(), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/shadowsocks.go |
rAddr socks5.Addr | <mask> }
<mask>
<mask> type ssUDPConn struct {
<mask> net.PacketConn
<mask> rAddr net.Addr
<mask> }
<mask>
<mask> func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
</s> Fix: some UDP issues (#265) </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove target string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/shadowsocks.go |
func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) | <mask> net.PacketConn
<mask> rAddr net.Addr
<mask> }
<mask>
<mask> func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
<mask> rAddr := socks5.ParseAddr(uc.rAddr.String())
<mask> copy(buf[len(rAddr):], b)
<mask> copy(buf, rAddr)
<mask> return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
<mask> }
<mask>
<mask> func (uc *ssUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> n, a, e := uc.PacketConn.ReadFrom(b)
<mask> addr := socks5.SplitAddr(b[:n])
</s> Fix: some UDP issues (#265) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/shadowsocks.go |
targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) | <mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
<mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> pc, err := net.ListenPacket("udp", "")
<mask> if err != nil {
<mask> return
</s> Fix: some UDP issues (#265) </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return nil, nil, err
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) </s> remove packet, err := socks5.EncodeUDPPacket(c.target, b)
</s> add packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/socks5.go |
rAddr socks5.Addr | <mask> }
<mask>
<mask> type socksUDPConn struct {
<mask> net.PacketConn
<mask> rAddr net.Addr
<mask> tcpConn net.Conn
<mask> }
<mask>
<mask> func (uc *socksUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
<mask> packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> Fix: some UDP issues (#265) </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove packet, err := socks5.EncodeUDPPacket(c.target, b)
</s> add packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/socks5.go |
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) | <mask> tcpConn net.Conn
<mask> }
<mask>
<mask> func (uc *socksUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
<mask> packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
<mask> if err != nil {
<mask> return
<mask> }
<mask> return uc.PacketConn.WriteTo(packet, addr)
<mask> }
</s> Fix: some UDP issues (#265) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove packet, err := socks5.EncodeUDPPacket(c.target, b)
</s> add packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add </s> remove func handleSocksUDP(c net.PacketConn, packet []byte, remoteAddr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(packet)
</s> add func handleSocksUDP(pc net.PacketConn, buf []byte, addr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/socks5.go |
if e != nil {
return 0, nil, e
} | <mask> func (uc *socksUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> n, a, e := uc.PacketConn.ReadFrom(b)
<mask> addr, payload, err := socks5.DecodeUDPPacket(b)
<mask> if err != nil {
<mask> return 0, nil, err
<mask> }
<mask> // due to DecodeUDPPacket is mutable, record addr length
</s> Fix: some UDP issues (#265) </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add </s> remove return n - len(addr) - 3, a, e
</s> add return n - addrLength - 3, a, nil | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/socks5.go |
// due to DecodeUDPPacket is mutable, record addr length
addrLength := len(addr) | <mask> if err != nil {
<mask> return 0, nil, err
<mask> }
<mask> copy(b, payload)
<mask> return n - addrLength - 3, a, nil
<mask> }
<mask>
<mask> func (uc *socksUDPConn) Close() error {
</s> Fix: some UDP issues (#265) </s> remove return n - len(addr) - 3, a, e
</s> add return n - addrLength - 3, a, nil </s> remove return
</s> add return nil, nil, err </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/socks5.go |
return n - addrLength - 3, a, nil | <mask> if err != nil {
<mask> return 0, nil, err
<mask> }
<mask> copy(b, payload)
<mask> return n - len(addr) - 3, a, e
<mask> }
<mask>
<mask> func (uc *socksUDPConn) Close() error {
<mask> uc.tcpConn.Close()
<mask> return uc.PacketConn.Close()
</s> Fix: some UDP issues (#265) </s> remove return
</s> add return nil, nil, err </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/socks5.go |
<mask> }
<mask> return bytes.Join(buf, nil)
<mask> }
<mask>
<mask> type fakeUDPConn struct {
<mask> net.Conn
<mask> }
<mask>
<mask> func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
<mask> return fuc.Conn.Write(b)
<mask> }
<mask>
<mask> func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
<mask> n, err := fuc.Conn.Read(b)
<mask> return n, fuc.RemoteAddr(), err
<mask> }
<mask>
<mask> func dialTimeout(network, address string, timeout time.Duration) (net.Conn, error) {
<mask> host, port, err := net.SplitHostPort(address)
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Fix: some UDP issues (#265) </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/util.go | |
return newPacketConn(&vmessUDPConn{Conn: c}, v), c.RemoteAddr(), nil | <mask> c, err = v.client.New(c, parseVmessAddr(metadata))
<mask> if err != nil {
<mask> return nil, nil, fmt.Errorf("new vmess client error: %v", err)
<mask> }
<mask> return newPacketConn(&fakeUDPConn{Conn: c}, v), c.RemoteAddr(), nil
<mask> }
<mask>
<mask> func NewVmess(option VmessOption) (*Vmess, error) {
<mask> security := strings.ToLower(option.Cipher)
<mask> client, err := vmess.NewClient(vmess.Config{
</s> Fix: some UDP issues (#265) </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return nil, nil, err
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | adapters/outbound/vmess.go |
// DecodeUDPPacket split `packet` to addr payload, and this function is mutable with `packet` | <mask> }
<mask>
<mask> func DecodeUDPPacket(packet []byte) (addr Addr, payload []byte, err error) {
<mask> if len(packet) < 5 {
<mask> err = errors.New("insufficient length of packet")
<mask> return
</s> Fix: some UDP issues (#265) </s> remove func EncodeUDPPacket(addr string, payload []byte) (packet []byte, err error) {
rAddr := ParseAddr(addr)
if rAddr == nil {
err = errors.New("cannot parse addr")
</s> add func EncodeUDPPacket(addr Addr, payload []byte) (packet []byte, err error) {
if addr == nil {
err = errors.New("address is invalid") </s> remove payload = bytes.Join([][]byte{packet[3+len(addr):]}, []byte{})
</s> add payload = packet[3+len(addr):] </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | component/socks5/socks5.go |
payload = packet[3+len(addr):] | <mask> if addr == nil {
<mask> err = errors.New("failed to read UDP header")
<mask> }
<mask>
<mask> payload = bytes.Join([][]byte{packet[3+len(addr):]}, []byte{})
<mask> return
<mask> }
<mask>
<mask> func EncodeUDPPacket(addr string, payload []byte) (packet []byte, err error) {
<mask> rAddr := ParseAddr(addr)
</s> Fix: some UDP issues (#265) </s> remove func EncodeUDPPacket(addr string, payload []byte) (packet []byte, err error) {
rAddr := ParseAddr(addr)
if rAddr == nil {
err = errors.New("cannot parse addr")
</s> add func EncodeUDPPacket(addr Addr, payload []byte) (packet []byte, err error) {
if addr == nil {
err = errors.New("address is invalid") </s> remove packet = bytes.Join([][]byte{{0, 0, 0}, rAddr, payload}, []byte{})
</s> add packet = bytes.Join([][]byte{{0, 0, 0}, addr, payload}, []byte{}) </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | component/socks5/socks5.go |
func EncodeUDPPacket(addr Addr, payload []byte) (packet []byte, err error) {
if addr == nil {
err = errors.New("address is invalid") | <mask> payload = bytes.Join([][]byte{packet[3+len(addr):]}, []byte{})
<mask> return
<mask> }
<mask>
<mask> func EncodeUDPPacket(addr string, payload []byte) (packet []byte, err error) {
<mask> rAddr := ParseAddr(addr)
<mask> if rAddr == nil {
<mask> err = errors.New("cannot parse addr")
<mask> return
<mask> }
<mask> packet = bytes.Join([][]byte{{0, 0, 0}, rAddr, payload}, []byte{})
<mask> return
<mask> }
</s> Fix: some UDP issues (#265) </s> remove packet = bytes.Join([][]byte{{0, 0, 0}, rAddr, payload}, []byte{})
</s> add packet = bytes.Join([][]byte{{0, 0, 0}, addr, payload}, []byte{}) </s> remove payload = bytes.Join([][]byte{packet[3+len(addr):]}, []byte{})
</s> add payload = packet[3+len(addr):] </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | component/socks5/socks5.go |
packet = bytes.Join([][]byte{{0, 0, 0}, addr, payload}, []byte{}) | <mask> if rAddr == nil {
<mask> err = errors.New("cannot parse addr")
<mask> return
<mask> }
<mask> packet = bytes.Join([][]byte{{0, 0, 0}, rAddr, payload}, []byte{})
<mask> return
<mask> }
</s> Fix: some UDP issues (#265) </s> remove func EncodeUDPPacket(addr string, payload []byte) (packet []byte, err error) {
rAddr := ParseAddr(addr)
if rAddr == nil {
err = errors.New("cannot parse addr")
</s> add func EncodeUDPPacket(addr Addr, payload []byte) (packet []byte, err error) {
if addr == nil {
err = errors.New("address is invalid") </s> remove payload = bytes.Join([][]byte{packet[3+len(addr):]}, []byte{})
</s> add payload = packet[3+len(addr):] </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return nil, nil, err
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) </s> remove return
</s> add return nil, nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | component/socks5/socks5.go |
func (m *Metadata) RemoteAddress() string {
return net.JoinHostPort(m.String(), m.DstPort)
}
| <mask> }
<mask>
<mask> func (m *Metadata) String() string {
<mask> if m.Host != "" {
<mask> return m.Host
<mask> } else if m.DstIP != nil {
<mask> return m.DstIP.String()
<mask> } else {
</s> Fix: some UDP issues (#265) </s> remove if m.Host == "" {
</s> add if m.Host != "" {
return m.Host
} else if m.DstIP != nil { </s> remove return m.Host
</s> add </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
</s> add wg.Wait()
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | constant/metadata.go |
if m.Host != "" {
return m.Host
} else if m.DstIP != nil { | <mask> Host string
<mask> }
<mask>
<mask> func (m *Metadata) String() string {
<mask> if m.Host == "" {
<mask> return m.DstIP.String()
<mask> }
<mask> return m.Host
<mask> }
<mask>
</s> Fix: some UDP issues (#265) </s> remove return m.Host
</s> add </s> remove func handleSocksUDP(c net.PacketConn, packet []byte, remoteAddr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(packet)
</s> add func handleSocksUDP(pc net.PacketConn, buf []byte, addr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(buf) </s> remove }
func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
buffer := bytes.NewBuffer(buf)
return &fakeConn{
PacketConn: conn,
target: target,
buffer: buffer,
remoteAddr: remoteAddr,
}
</s> add bufRef []byte | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | constant/metadata.go |
} else {
return "<nil>" | <mask> return m.Host
<mask> } else if m.DstIP != nil {
<mask> return m.DstIP.String()
<mask> }
<mask> }
<mask>
<mask> func (m *Metadata) Valid() bool {
<mask> return m.Host != "" || m.DstIP != nil
<mask> }
</s> Fix: some UDP issues (#265) </s> remove return m.Host
</s> add </s> remove if m.Host == "" {
</s> add if m.Host != "" {
return m.Host
} else if m.DstIP != nil { </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | constant/metadata.go |
<mask> func (m *Metadata) String() string {
<mask> if m.Host == "" {
<mask> return m.DstIP.String()
<mask> }
<mask> return m.Host
<mask> }
<mask>
<mask> func (m *Metadata) Valid() bool {
<mask> return m.Host != "" || m.DstIP != nil
<mask> }
</s> Fix: some UDP issues (#265) </s> remove if m.Host == "" {
</s> add if m.Host != "" {
return m.Host
} else if m.DstIP != nil { </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | constant/metadata.go | |
"bytes" | <mask> package socks
<mask>
<mask> import (
<mask> "net"
<mask>
<mask> adapters "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/component/socks5"
</s> Fix: some UDP issues (#265) </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
<mask> adapters "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask> )
<mask>
<mask> var (
<mask> _ = tunnel.NATInstance()
<mask> )
<mask>
<mask> type SockUDPListener struct {
<mask> net.PacketConn
<mask> address string
</s> Fix: some UDP issues (#265) </s> remove target string
</s> add </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go | |
<mask> }
<mask>
<mask> sl := &SockUDPListener{l, addr, false}
<mask> go func() {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
<mask> for {
<mask> n, remoteAddr, err := l.ReadFrom(buf)
<mask> if err != nil {
<mask> if sl.closed {
<mask> break
</s> Fix: some UDP issues (#265) </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go | |
buf := pool.BufPool.Get().([]byte) | <mask> sl := &SockUDPListener{l, addr, false}
<mask> go func() {
<mask> for {
<mask> n, remoteAddr, err := l.ReadFrom(buf)
<mask> if err != nil {
<mask> pool.BufPool.Put(buf[:cap(buf)])
<mask> if sl.closed {
</s> Fix: some UDP issues (#265) </s> remove buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
</s> add </s> remove addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
pool.BufPool.Put(buf[:cap(buf)]) | <mask> for {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> n, remoteAddr, err := l.ReadFrom(buf)
<mask> if err != nil {
<mask> if sl.closed {
<mask> break
<mask> }
<mask> continue
</s> Fix: some UDP issues (#265) </s> remove buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
</s> add </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
handleSocksUDP(l, buf[:n], remoteAddr) | <mask> break
<mask> }
<mask> continue
<mask> }
<mask> go handleSocksUDP(l, buf[:n], remoteAddr)
<mask> }
<mask> }()
<mask>
<mask> return sl, nil
<mask> }
</s> Fix: some UDP issues (#265) </s> remove queue := t.queue.Out()
for {
elm := <-queue
</s> add go func() {
queue := t.udpQueue.Out()
for elm := range queue {
conn := elm.(C.ServerAdapter)
t.handleUDPConn(conn)
}
}()
queue := t.tcpQueue.Out()
for elm := range queue { </s> remove buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
func handleSocksUDP(pc net.PacketConn, buf []byte, addr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(buf) | <mask> func (l *SockUDPListener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handleSocksUDP(c net.PacketConn, packet []byte, remoteAddr net.Addr) {
<mask> target, payload, err := socks5.DecodeUDPPacket(packet)
<mask> if err != nil {
<mask> // Unresolved UDP packet, do nothing
<mask> return
<mask> }
<mask> conn := newfakeConn(c, target.String(), remoteAddr, payload)
</s> Fix: some UDP issues (#265) </s> remove // Unresolved UDP packet, do nothing
</s> add // Unresolved UDP packet, return buffer to the pool
pool.BufPool.Put(buf[:cap(buf)]) </s> remove conn := newfakeConn(c, target.String(), remoteAddr, payload)
</s> add conn := &fakeConn{
PacketConn: pc,
remoteAddr: addr,
targetAddr: target,
buffer: bytes.NewBuffer(payload),
bufRef: buf,
} </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove }
func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
buffer := bytes.NewBuffer(buf)
return &fakeConn{
PacketConn: conn,
target: target,
buffer: buffer,
remoteAddr: remoteAddr,
}
</s> add bufRef []byte </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
// Unresolved UDP packet, return buffer to the pool
pool.BufPool.Put(buf[:cap(buf)]) | <mask>
<mask> func handleSocksUDP(c net.PacketConn, packet []byte, remoteAddr net.Addr) {
<mask> target, payload, err := socks5.DecodeUDPPacket(packet)
<mask> if err != nil {
<mask> // Unresolved UDP packet, do nothing
<mask> return
<mask> }
<mask> conn := newfakeConn(c, target.String(), remoteAddr, payload)
<mask> tun.Add(adapters.NewSocket(target, conn, C.SOCKS, C.UDP))
<mask> }
</s> Fix: some UDP issues (#265) </s> remove func handleSocksUDP(c net.PacketConn, packet []byte, remoteAddr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(packet)
</s> add func handleSocksUDP(pc net.PacketConn, buf []byte, addr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(buf) </s> remove conn := newfakeConn(c, target.String(), remoteAddr, payload)
</s> add conn := &fakeConn{
PacketConn: pc,
remoteAddr: addr,
targetAddr: target,
buffer: bytes.NewBuffer(payload),
bufRef: buf,
} </s> remove }
func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
buffer := bytes.NewBuffer(buf)
return &fakeConn{
PacketConn: conn,
target: target,
buffer: buffer,
remoteAddr: remoteAddr,
}
</s> add bufRef []byte </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
conn := &fakeConn{
PacketConn: pc,
remoteAddr: addr,
targetAddr: target,
buffer: bytes.NewBuffer(payload),
bufRef: buf,
} | <mask> if err != nil {
<mask> // Unresolved UDP packet, do nothing
<mask> return
<mask> }
<mask> conn := newfakeConn(c, target.String(), remoteAddr, payload)
<mask> tun.Add(adapters.NewSocket(target, conn, C.SOCKS, C.UDP))
<mask> }
</s> Fix: some UDP issues (#265) </s> remove // Unresolved UDP packet, do nothing
</s> add // Unresolved UDP packet, return buffer to the pool
pool.BufPool.Put(buf[:cap(buf)]) </s> remove func handleSocksUDP(c net.PacketConn, packet []byte, remoteAddr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(packet)
</s> add func handleSocksUDP(pc net.PacketConn, buf []byte, addr net.Addr) {
target, payload, err := socks5.DecodeUDPPacket(buf) </s> remove packet, err := socks5.EncodeUDPPacket(c.target, b)
</s> add packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/udp.go |
"github.com/Dreamacro/clash/common/pool" | <mask> "bytes"
<mask> "net"
<mask>
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> )
<mask>
<mask> type fakeConn struct {
<mask> net.PacketConn
</s> Fix: some UDP issues (#265) </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add </s> remove target string
</s> add </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/utils.go |
<mask> )
<mask>
<mask> type fakeConn struct {
<mask> net.PacketConn
<mask> target string
<mask> remoteAddr net.Addr
<mask> buffer *bytes.Buffer
<mask> }
<mask>
<mask> func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
</s> Fix: some UDP issues (#265) </s> remove }
func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
buffer := bytes.NewBuffer(buf)
return &fakeConn{
PacketConn: conn,
target: target,
buffer: buffer,
remoteAddr: remoteAddr,
}
</s> add bufRef []byte </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/utils.go | |
targetAddr socks5.Addr | <mask> net.PacketConn
<mask> remoteAddr net.Addr
<mask> buffer *bytes.Buffer
<mask> bufRef []byte
<mask> }
<mask>
<mask> func (c *fakeConn) Read(b []byte) (n int, err error) {
</s> Fix: some UDP issues (#265) </s> remove }
func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
buffer := bytes.NewBuffer(buf)
return &fakeConn{
PacketConn: conn,
target: target,
buffer: buffer,
remoteAddr: remoteAddr,
}
</s> add bufRef []byte </s> remove target string
</s> add </s> remove packet, err := socks5.EncodeUDPPacket(c.target, b)
</s> add packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/utils.go |
bufRef []byte | <mask> net.PacketConn
<mask> target string
<mask> remoteAddr net.Addr
<mask> buffer *bytes.Buffer
<mask> }
<mask>
<mask> func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
<mask> buffer := bytes.NewBuffer(buf)
<mask> return &fakeConn{
<mask> PacketConn: conn,
<mask> target: target,
<mask> buffer: buffer,
<mask> remoteAddr: remoteAddr,
<mask> }
<mask> }
<mask>
<mask> func (c *fakeConn) Read(b []byte) (n int, err error) {
<mask> return c.buffer.Read(b)
<mask> }
</s> Fix: some UDP issues (#265) </s> remove target string
</s> add </s> remove packet, err := socks5.EncodeUDPPacket(c.target, b)
</s> add packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) </s> remove conn := newfakeConn(c, target.String(), remoteAddr, payload)
</s> add conn := &fakeConn{
PacketConn: pc,
remoteAddr: addr,
targetAddr: target,
buffer: bytes.NewBuffer(payload),
bufRef: buf,
} </s> remove // Unresolved UDP packet, do nothing
</s> add // Unresolved UDP packet, return buffer to the pool
pool.BufPool.Put(buf[:cap(buf)]) | [
"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/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/utils.go |
packet, err := socks5.EncodeUDPPacket(c.targetAddr, b) | <mask> return c.buffer.Read(b)
<mask> }
<mask>
<mask> func (c *fakeConn) Write(b []byte) (n int, err error) {
<mask> packet, err := socks5.EncodeUDPPacket(c.target, b)
<mask> if err != nil {
<mask> return
<mask> }
<mask> return c.PacketConn.WriteTo(packet, c.remoteAddr)
<mask> }
</s> Fix: some UDP issues (#265) </s> remove packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
</s> add packet, err := socks5.EncodeUDPPacket(uc.rAddr, b) </s> remove }
func newfakeConn(conn net.PacketConn, target string, remoteAddr net.Addr, buf []byte) *fakeConn {
buffer := bytes.NewBuffer(buf)
return &fakeConn{
PacketConn: conn,
target: target,
buffer: buffer,
remoteAddr: remoteAddr,
}
</s> add bufRef []byte </s> remove func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
rAddr := socks5.ParseAddr(uc.rAddr.String())
copy(buf[len(rAddr):], b)
copy(buf, rAddr)
return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
</s> add func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
packet, err := socks5.EncodeUDPPacket(uc.rAddr, b)
if err != nil {
return
}
return uc.PacketConn.WriteTo(packet[3:], addr) </s> remove rAddr net.Addr
</s> add rAddr socks5.Addr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | proxy/socks/utils.go |
func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { | <mask> }
<mask> t.traffic.Up() <- int64(n)
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
<mask>
<mask> for {
<mask> n, _, err := pc.ReadFrom(buf)
</s> Fix: some UDP issues (#265) </s> remove buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/connection.go |
defer t.natTable.Delete(key)
defer pc.Close() | <mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
<mask>
<mask> for {
<mask> pc.SetReadDeadline(time.Now().Add(timeout))
<mask> n, _, err := pc.ReadFrom(buf)
<mask> if err != nil {
<mask> return
</s> Fix: some UDP issues (#265) </s> remove buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
</s> add </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/connection.go |
pc.SetReadDeadline(time.Now().Add(timeout)) | <mask> defer pc.Close()
<mask>
<mask> for {
<mask> n, _, err := pc.ReadFrom(buf)
<mask> if err != nil {
<mask> return
<mask> }
<mask>
</s> Fix: some UDP issues (#265) </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { </s> remove buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf[:cap(buf)])
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/connection.go |
"github.com/Dreamacro/clash/component/nat" | <mask> "time"
<mask>
<mask> InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/dns"
<mask> "github.com/Dreamacro/clash/log"
<mask>
<mask> channels "gopkg.in/eapache/channels.v1"
</s> Fix: some UDP issues (#265) </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add </s> remove queue: channels.NewInfiniteChannel(),
</s> add tcpQueue: channels.NewInfiniteChannel(),
udpQueue: channels.NewInfiniteChannel(),
natTable: nat.New(), | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
// default timeout for UDP session
udpTimeout = 60 * time.Second | <mask> var (
<mask> tunnel *Tunnel
<mask> once sync.Once
<mask> )
<mask>
<mask> // Tunnel handle relay inbound proxy and outbound proxy
<mask> type Tunnel struct {
<mask> tcpQueue *channels.InfiniteChannel
<mask> udpQueue *channels.InfiniteChannel
</s> Fix: some UDP issues (#265) </s> remove queue *channels.InfiniteChannel
</s> add tcpQueue *channels.InfiniteChannel
udpQueue *channels.InfiniteChannel
natTable *nat.Table </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add </s> remove target string
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
tcpQueue *channels.InfiniteChannel
udpQueue *channels.InfiniteChannel
natTable *nat.Table | <mask> )
<mask>
<mask> // Tunnel handle relay inbound proxy and outbound proxy
<mask> type Tunnel struct {
<mask> queue *channels.InfiniteChannel
<mask> rules []C.Rule
<mask> proxies map[string]C.Proxy
<mask> configMux *sync.RWMutex
<mask> traffic *C.Traffic
<mask>
</s> Fix: some UDP issues (#265) </s> remove t.queue.In() <- req
</s> add switch req.Metadata().NetWork {
case C.TCP:
t.tcpQueue.In() <- req
case C.UDP:
t.udpQueue.In() <- req
} </s> remove "github.com/Dreamacro/clash/tunnel"
)
var (
_ = tunnel.NATInstance()
</s> add </s> remove target string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
switch req.Metadata().NetWork {
case C.TCP:
t.tcpQueue.In() <- req
case C.UDP:
t.udpQueue.In() <- req
} | <mask> }
<mask>
<mask> // Add request to queue
<mask> func (t *Tunnel) Add(req C.ServerAdapter) {
<mask> t.queue.In() <- req
<mask> }
<mask>
<mask> // Traffic return traffic of all connections
<mask> func (t *Tunnel) Traffic() *C.Traffic {
<mask> return t.traffic
</s> Fix: some UDP issues (#265) </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove go t.handleConn(conn)
</s> add go t.handleTCPConn(conn) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
go func() {
queue := t.udpQueue.Out()
for elm := range queue {
conn := elm.(C.ServerAdapter)
t.handleUDPConn(conn)
}
}()
queue := t.tcpQueue.Out()
for elm := range queue { | <mask> t.mode = mode
<mask> }
<mask>
<mask> func (t *Tunnel) process() {
<mask> queue := t.queue.Out()
<mask> for {
<mask> elm := <-queue
<mask> conn := elm.(C.ServerAdapter)
<mask> go t.handleConn(conn)
<mask> }
<mask> }
<mask>
</s> Fix: some UDP issues (#265) </s> remove go t.handleConn(conn)
</s> add go t.handleTCPConn(conn) </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
go t.handleTCPConn(conn) | <mask> queue := t.queue.Out()
<mask> for {
<mask> elm := <-queue
<mask> conn := elm.(C.ServerAdapter)
<mask> go t.handleConn(conn)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) resolveIP(host string) (net.IP, error) {
<mask> return dns.ResolveIP(host)
</s> Fix: some UDP issues (#265) </s> remove queue := t.queue.Out()
for {
elm := <-queue
</s> add go func() {
queue := t.udpQueue.Out()
for elm := range queue {
conn := elm.(C.ServerAdapter)
t.handleUDPConn(conn)
}
}()
queue := t.tcpQueue.Out()
for elm := range queue { </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn) {
</s> add func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) { </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { | <mask> func (t *Tunnel) needLookupIP(metadata *C.Metadata) bool {
<mask> return dns.DefaultResolver != nil && (dns.DefaultResolver.IsMapping() || dns.DefaultResolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
<mask> }
<mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer func() {
<mask> var conn net.Conn
<mask> switch adapter := localConn.(type) {
<mask> case *InboundAdapter.HTTPAdapter:
<mask> conn = adapter.Conn
<mask> case *InboundAdapter.SocketAdapter:
<mask> conn = adapter.Conn
<mask> }
<mask> if _, ok := conn.(*net.TCPConn); ok {
<mask> localConn.Close()
<mask> }
<mask> }()
<mask>
<mask> metadata := localConn.Metadata()
<mask> if !metadata.Valid() {
<mask> log.Warnln("[Metadata] not valid: %#v", metadata)
<mask> return
<mask> }
<mask>
<mask> // preprocess enhanced-mode metadata
<mask> if t.needLookupIP(metadata) {
<mask> host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP)
<mask> if exist {
<mask> metadata.Host = host
</s> Fix: some UDP issues (#265) </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc)
</s> add func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
defer localConn.Close()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove queue := t.queue.Out()
for {
elm := <-queue
</s> add go func() {
queue := t.udpQueue.Out()
for elm := range queue {
conn := elm.(C.ServerAdapter)
t.handleUDPConn(conn)
}
}()
queue := t.tcpQueue.Out()
for elm := range queue { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep"... | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
return nil, nil, err | <mask> default:
<mask> var err error
<mask> proxy, rule, err = t.match(metadata)
<mask> if err != nil {
<mask> return
<mask> }
<mask> }
<mask>
<mask> switch metadata.NetWork {
<mask> case C.TCP:
</s> Fix: some UDP issues (#265) </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
return proxy, rule, nil
} | <mask> return nil, nil, err
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
<mask> metadata := localConn.Metadata()
<mask> if !metadata.Valid() {
<mask> log.Warnln("[Metadata] not valid: %#v", metadata)
</s> Fix: some UDP issues (#265) </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc)
</s> add func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
defer localConn.Close()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
defer func() {
var conn net.Conn
switch adapter := localConn.(type) {
case *InboundAdapter.HTTPAdapter:
conn = adapter.Conn
case *InboundAdapter.SocketAdapter:
conn = adapter.Conn
}
if _, ok := conn.(*net.TCPConn); ok {
localConn.Close()
}
}()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return
}
</s> add func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) { </s> remove addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
</s> add addr, err := resolveUDPAddr("udp", metadata.RemoteAddress()) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return | <mask> return
<mask> }
<mask> }
<mask>
<mask> switch metadata.NetWork {
<mask> case C.TCP:
<mask> t.handleTCPConn(localConn, metadata, proxy, rule)
<mask> case C.UDP:
<mask> t.handleUDPConn(localConn, metadata, proxy, rule)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> pc, addr := natTable.Get(localConn.RemoteAddr())
</s> Fix: some UDP issues (#265) </s> remove }
</s> add </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove return
</s> add return nil, nil, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
<mask> t.handleTCPConn(localConn, metadata, proxy, rule)
<mask> case C.UDP:
<mask> t.handleUDPConn(localConn, metadata, proxy, rule)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> pc, addr := natTable.Get(localConn.RemoteAddr())
<mask> if pc == nil {
<mask> rawPc, nAddr, err := proxy.DialUDP(metadata)
</s> Fix: some UDP issues (#265) </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go | |
src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) | <mask> t.handleUDPConn(localConn, metadata, proxy, rule)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> pc, addr := natTable.Get(localConn.RemoteAddr())
<mask> if pc == nil {
<mask> rawPc, nAddr, err := proxy.DialUDP(metadata)
<mask> addr = nAddr
<mask> pc = rawPc
<mask> if err != nil {
<mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
<mask> return
<mask> }
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
<mask> } else {
</s> Fix: some UDP issues (#265) </s> remove if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
</s> add wg.Wait()
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr) </s> remove }
</s> add </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
wg.Wait()
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr) | <mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
<mask> return
<mask> }
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
<mask> } else {
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
<mask> }
<mask>
<mask> natTable.Set(localConn.RemoteAddr(), pc, addr)
<mask> go t.handleUDPToLocal(localConn, pc)
<mask> }
</s> Fix: some UDP issues (#265) </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc)
</s> add func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
defer localConn.Close()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add </s> remove targetAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
if err != nil {
return
</s> add targetAddr := socks5.ParseAddr(metadata.RemoteAddress())
if targetAddr == nil {
return nil, nil, fmt.Errorf("parse address error: %v:%v", metadata.String(), metadata.DstPort) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
}()
} | <mask> t.handleUDPToRemote(localConn, pc, addr)
<mask> }
<mask>
<mask> func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask>
<mask> metadata := localConn.Metadata()
<mask> if !metadata.Valid() {
</s> Fix: some UDP issues (#265) </s> remove natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc)
</s> add func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
defer localConn.Close()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
defer localConn.Close()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return | <mask> } else {
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
<mask> }
<mask>
<mask> natTable.Set(localConn.RemoteAddr(), pc, addr)
<mask> go t.handleUDPToLocal(localConn, pc)
<mask> }
<mask>
<mask> t.handleUDPToRemote(localConn, pc, addr)
<mask> }
<mask>
</s> Fix: some UDP issues (#265) </s> remove if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
</s> add wg.Wait()
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr) </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} | <mask> natTable.Set(localConn.RemoteAddr(), pc, addr)
<mask> go t.handleUDPToLocal(localConn, pc)
<mask> }
<mask>
<mask> t.handleUDPToRemote(localConn, pc, addr)
<mask> }
<mask>
<mask> func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> remoteConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
</s> Fix: some UDP issues (#265) </s> remove func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
</s> add </s> remove if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
</s> add wg.Wait()
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr) </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove natTable.Set(localConn.RemoteAddr(), pc, addr)
go t.handleUDPToLocal(localConn, pc)
</s> add func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter) {
defer localConn.Close()
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return </s> remove }
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
<mask>
<mask> t.handleUDPToRemote(localConn, pc, addr)
<mask> }
<mask>
<mask> func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> remoteConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
<mask> return
<mask> }
</s> Fix: some UDP issues (#265) </s> remove t.handleUDPToRemote(localConn, pc, addr)
}
</s> add proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %v", err)
return
} </s> remove func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
pc, addr := natTable.Get(localConn.RemoteAddr())
if pc == nil {
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
return
</s> add src := localConn.RemoteAddr().String()
dst := metadata.RemoteAddress()
key := src + "-" + dst
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr)
return
}
lockKey := key + "-lock"
wg, loaded := t.natTable.GetOrCreateLock(lockKey)
go func() {
if !loaded {
wg.Add(1)
proxy, rule, err := t.resolveMetadata(metadata)
if err != nil {
log.Warnln("Parse metadata failed: %s", err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
rawPc, nAddr, err := proxy.DialUDP(metadata)
if err != nil {
log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
t.natTable.Delete(lockKey)
wg.Done()
return
}
pc = rawPc
addr = nAddr
if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
}
t.natTable.Set(key, pc, addr)
t.natTable.Delete(lockKey)
wg.Done()
go t.handleUDPToLocal(localConn, pc, key, udpTimeout) </s> remove if rule != nil {
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
} else {
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
</s> add wg.Wait()
pc, addr := t.natTable.Get(key)
if pc != nil {
t.handleUDPToRemote(localConn, pc, addr) </s> remove }
</s> add </s> remove switch metadata.NetWork {
case C.TCP:
t.handleTCPConn(localConn, metadata, proxy, rule)
case C.UDP:
t.handleUDPConn(localConn, metadata, proxy, rule)
</s> add func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter) {
metadata := localConn.Metadata()
if !metadata.Valid() {
log.Warnln("[Metadata] not valid: %#v", metadata)
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go | |
tcpQueue: channels.NewInfiniteChannel(),
udpQueue: channels.NewInfiniteChannel(),
natTable: nat.New(), | <mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> return &Tunnel{
<mask> queue: channels.NewInfiniteChannel(),
<mask> proxies: make(map[string]C.Proxy),
<mask> configMux: &sync.RWMutex{},
<mask> traffic: C.NewTraffic(time.Second),
<mask> mode: Rule,
<mask> }
</s> Fix: some UDP issues (#265) </s> remove return m.Host
</s> add </s> remove type fakeUDPConn struct {
net.Conn
}
func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return fuc.Conn.Write(b)
}
func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, err := fuc.Conn.Read(b)
return n, fuc.RemoteAddr(), err
}
</s> add </s> remove if m.Host == "" {
</s> add if m.Host != "" {
return m.Host
} else if m.DstIP != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4cd8b6f24fb3c5f2b344f4cdc7a8552abb00435a | tunnel/tunnel.go |
err, _, _ := syscall.SyscallN(fn, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0) | <mask>
<mask> func getTransportTable(fn uintptr, family int, class int) ([]byte, error) {
<mask> for size, buf := uint32(8), make([]byte, 8); ; {
<mask> ptr := unsafe.Pointer(&buf[0])
<mask> err, _, _ := syscall.SyscallN(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0)
<mask>
<mask> switch err {
<mask> case 0:
<mask> return buf, nil
<mask> case uintptr(syscall.ERROR_INSUFFICIENT_BUFFER):
</s> Fix: SyscallN should not use nargs </s> remove queryProcName, 4,
</s> add queryProcName, </s> remove 0, 0)
</s> add ) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4dfba73e5cd015f610ba6864546426e72db605a2 | component/process/process_windows.go |
queryProcName, | <mask>
<mask> buf := make([]uint16, syscall.MAX_LONG_PATH)
<mask> size := uint32(len(buf))
<mask> r1, _, err := syscall.SyscallN(
<mask> queryProcName, 4,
<mask> uintptr(h),
<mask> uintptr(1),
<mask> uintptr(unsafe.Pointer(&buf[0])),
<mask> uintptr(unsafe.Pointer(&size)),
<mask> 0, 0)
</s> Fix: SyscallN should not use nargs </s> remove err, _, _ := syscall.SyscallN(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0)
</s> add err, _, _ := syscall.SyscallN(fn, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0) </s> remove 0, 0)
</s> add ) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4dfba73e5cd015f610ba6864546426e72db605a2 | component/process/process_windows.go |
) | <mask> uintptr(h),
<mask> uintptr(1),
<mask> uintptr(unsafe.Pointer(&buf[0])),
<mask> uintptr(unsafe.Pointer(&size)),
<mask> 0, 0)
<mask> if r1 == 0 {
<mask> return "", err
<mask> }
<mask> return syscall.UTF16ToString(buf[:size]), nil
<mask> }
</s> Fix: SyscallN should not use nargs </s> remove queryProcName, 4,
</s> add queryProcName, </s> remove err, _, _ := syscall.SyscallN(fn, 6, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0)
</s> add err, _, _ := syscall.SyscallN(fn, uintptr(ptr), uintptr(unsafe.Pointer(&size)), 0, uintptr(family), uintptr(class), 0) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4dfba73e5cd015f610ba6864546426e72db605a2 | component/process/process_windows.go |
all: linux macos freebsd win64 | <mask> NAME=clash
<mask> BINDIR=bin
<mask> GOBUILD=CGO_ENABLED=0 go build -ldflags '-w -s'
<mask>
<mask> all: linux macos win64
<mask>
<mask> linux:
<mask> GOARCH=amd64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
<mask>
<mask> macos:
</s> Feature: add freebsd release (#80)
add freebsd support </s> remove releases: linux macos win64
</s> add releases: linux macos freebsd win64 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e91118a0512a352a93b99b5bfd5b37668001dc6 | Makefile |
freebsd:
GOARCH=amd64 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
| <mask>
<mask> macos:
<mask> GOARCH=amd64 GOOS=darwin $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
<mask>
<mask> win64:
<mask> GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
<mask>
<mask> releases: linux macos freebsd win64
<mask> chmod +x $(BINDIR)/$(NAME)-*
<mask> gzip $(BINDIR)/$(NAME)-linux
</s> Feature: add freebsd release (#80)
add freebsd support </s> remove releases: linux macos win64
</s> add releases: linux macos freebsd win64 </s> remove all: linux macos win64
</s> add all: linux macos freebsd win64 | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e91118a0512a352a93b99b5bfd5b37668001dc6 | Makefile |
releases: linux macos freebsd win64 | <mask>
<mask> win64:
<mask> GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
<mask>
<mask> releases: linux macos win64
<mask> chmod +x $(BINDIR)/$(NAME)-*
<mask> gzip $(BINDIR)/$(NAME)-linux
<mask> gzip $(BINDIR)/$(NAME)-macos
<mask> zip -m -j $(BINDIR)/$(NAME)-win64.zip $(BINDIR)/$(NAME)-win64.exe
<mask>
</s> Feature: add freebsd release (#80)
add freebsd support </s> remove all: linux macos win64
</s> add all: linux macos freebsd win64 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e91118a0512a352a93b99b5bfd5b37668001dc6 | Makefile |
gzip $(BINDIR)/$(NAME)-freebsd | <mask> chmod +x $(BINDIR)/$(NAME)-*
<mask> gzip $(BINDIR)/$(NAME)-linux
<mask> gzip $(BINDIR)/$(NAME)-macos
<mask> zip -m -j $(BINDIR)/$(NAME)-win64.zip $(BINDIR)/$(NAME)-win64.exe
<mask>
<mask> clean:
<mask> rm $(BINDIR)/*
</s> Feature: add freebsd release (#80)
add freebsd support </s> remove releases: linux macos win64
</s> add releases: linux macos freebsd win64 </s> remove all: linux macos win64
</s> add all: linux macos freebsd win64 | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e91118a0512a352a93b99b5bfd5b37668001dc6 | Makefile |
"bytes" | <mask> import (
<mask> "bufio"
<mask> "crypto/tls"
<mask> "encoding/binary"
<mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net"
</s> Fix: grpc transport concurrent write </s> remove buffers := net.Buffers{grpcHeader, protobufHeader, b}
_, err = buffers.WriteTo(g.writer)
</s> add buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
defer buf.Reset()
buf.Write(grpcHeader)
buf.Write(protobufHeader[:varuintSize+1])
buf.Write(b)
_, err = g.writer.Write(buf.Bytes()) </s> remove grpcPayloadLen := uint32(len(protobufHeader) + len(b))
</s> add grpcPayloadLen := uint32(varuintSize + 1 + len(b)) </s> remove protobufHeader := appendUleb128([]byte{0x0A}, uint64(len(b)))
</s> add protobufHeader := [binary.MaxVarintLen64 + 1]byte{0x0A}
varuintSize := binary.PutUvarint(protobufHeader[1:], uint64(len(b))) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e9e4b6cde5d40066d7112add42b5943af4608e5 | component/gun/gun.go |
bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }} | <mask> defaultHeader = http.Header{
<mask> "content-type": []string{"application/grpc"},
<mask> "user-agent": []string{"grpc-go/1.36.0"},
<mask> }
<mask> )
<mask>
<mask> type DialFn = func(network, addr string) (net.Conn, error)
<mask>
<mask> type Conn struct {
<mask> response *http.Response
</s> Fix: grpc transport concurrent write </s> remove buffers := net.Buffers{grpcHeader, protobufHeader, b}
_, err = buffers.WriteTo(g.writer)
</s> add buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
defer buf.Reset()
buf.Write(grpcHeader)
buf.Write(protobufHeader[:varuintSize+1])
buf.Write(b)
_, err = g.writer.Write(buf.Bytes()) </s> remove grpcPayloadLen := uint32(len(protobufHeader) + len(b))
</s> add grpcPayloadLen := uint32(varuintSize + 1 + len(b)) </s> remove protobufHeader := appendUleb128([]byte{0x0A}, uint64(len(b)))
</s> add protobufHeader := [binary.MaxVarintLen64 + 1]byte{0x0A}
varuintSize := binary.PutUvarint(protobufHeader[1:], uint64(len(b))) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e9e4b6cde5d40066d7112add42b5943af4608e5 | component/gun/gun.go |
protobufHeader := [binary.MaxVarintLen64 + 1]byte{0x0A}
varuintSize := binary.PutUvarint(protobufHeader[1:], uint64(len(b))) | <mask> return n, nil
<mask> }
<mask>
<mask> func (g *Conn) Write(b []byte) (n int, err error) {
<mask> protobufHeader := appendUleb128([]byte{0x0A}, uint64(len(b)))
<mask> grpcHeader := make([]byte, 5)
<mask> grpcPayloadLen := uint32(len(protobufHeader) + len(b))
<mask> binary.BigEndian.PutUint32(grpcHeader[1:5], grpcPayloadLen)
<mask>
<mask> buffers := net.Buffers{grpcHeader, protobufHeader, b}
</s> Fix: grpc transport concurrent write </s> remove grpcPayloadLen := uint32(len(protobufHeader) + len(b))
</s> add grpcPayloadLen := uint32(varuintSize + 1 + len(b)) </s> remove buffers := net.Buffers{grpcHeader, protobufHeader, b}
_, err = buffers.WriteTo(g.writer)
</s> add buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
defer buf.Reset()
buf.Write(grpcHeader)
buf.Write(protobufHeader[:varuintSize+1])
buf.Write(b)
_, err = g.writer.Write(buf.Bytes()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e9e4b6cde5d40066d7112add42b5943af4608e5 | component/gun/gun.go |
grpcPayloadLen := uint32(varuintSize + 1 + len(b)) | <mask>
<mask> func (g *Conn) Write(b []byte) (n int, err error) {
<mask> protobufHeader := appendUleb128([]byte{0x0A}, uint64(len(b)))
<mask> grpcHeader := make([]byte, 5)
<mask> grpcPayloadLen := uint32(len(protobufHeader) + len(b))
<mask> binary.BigEndian.PutUint32(grpcHeader[1:5], grpcPayloadLen)
<mask>
<mask> buffers := net.Buffers{grpcHeader, protobufHeader, b}
<mask> _, err = buffers.WriteTo(g.writer)
<mask> if err == io.ErrClosedPipe && g.err != nil {
</s> Fix: grpc transport concurrent write </s> remove protobufHeader := appendUleb128([]byte{0x0A}, uint64(len(b)))
</s> add protobufHeader := [binary.MaxVarintLen64 + 1]byte{0x0A}
varuintSize := binary.PutUvarint(protobufHeader[1:], uint64(len(b))) </s> remove buffers := net.Buffers{grpcHeader, protobufHeader, b}
_, err = buffers.WriteTo(g.writer)
</s> add buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
defer buf.Reset()
buf.Write(grpcHeader)
buf.Write(protobufHeader[:varuintSize+1])
buf.Write(b)
_, err = g.writer.Write(buf.Bytes()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e9e4b6cde5d40066d7112add42b5943af4608e5 | component/gun/gun.go |
buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
defer buf.Reset()
buf.Write(grpcHeader)
buf.Write(protobufHeader[:varuintSize+1])
buf.Write(b)
_, err = g.writer.Write(buf.Bytes()) | <mask> grpcHeader := make([]byte, 5)
<mask> grpcPayloadLen := uint32(len(protobufHeader) + len(b))
<mask> binary.BigEndian.PutUint32(grpcHeader[1:5], grpcPayloadLen)
<mask>
<mask> buffers := net.Buffers{grpcHeader, protobufHeader, b}
<mask> _, err = buffers.WriteTo(g.writer)
<mask> if err == io.ErrClosedPipe && g.err != nil {
<mask> err = g.err
<mask> }
<mask>
<mask> return len(b), err
</s> Fix: grpc transport concurrent write </s> remove grpcPayloadLen := uint32(len(protobufHeader) + len(b))
</s> add grpcPayloadLen := uint32(varuintSize + 1 + len(b)) </s> remove protobufHeader := appendUleb128([]byte{0x0A}, uint64(len(b)))
</s> add protobufHeader := [binary.MaxVarintLen64 + 1]byte{0x0A}
varuintSize := binary.PutUvarint(protobufHeader[1:], uint64(len(b))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4e9e4b6cde5d40066d7112add42b5943af4608e5 | component/gun/gun.go |
log.Warnln(
"[UDP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | <mask> defer cancel()
<mask> rawPc, err := proxy.ListenPacketContext(ctx, metadata.Pure())
<mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
<mask> } else {
<mask> log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
<mask> }
<mask> return
<mask> }
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Warnln("[UDP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) | <mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
<mask> } else {
<mask> log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
<mask> }
<mask> return
<mask> }
<mask> pCtx.InjectPacketConn(rawPc)
<mask> pc := statistic.NewUDPTracker(rawPc, statistic.DefaultManager, metadata, rule)
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[UDP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) | <mask> pc := statistic.NewUDPTracker(rawPc, statistic.DefaultManager, metadata, rule)
<mask>
<mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> default:
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) </s> remove log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
</s> add log.Infoln(
"[UDP] %s --> %s doesn't match any rule using DIRECT",
metadata.SourceAddress(),
metadata.RemoteAddress(),
) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Infoln(
"[UDP] %s --> %s doesn't match any rule using DIRECT",
metadata.SourceAddress(),
metadata.RemoteAddress(),
) | <mask> log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> default:
<mask> log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> }
<mask>
<mask> oAddr, _ := netip.AddrFromSlice(metadata.DstIP)
<mask> oAddr = oAddr.Unmap()
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, oAddr, fAddr)
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
</s> add log.Infoln(
"[TCP] %s --> %s doesn't match any rule using DIRECT",
metadata.SourceAddress(),
metadata.RemoteAddress(),
) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | <mask> defer cancel()
<mask> remoteConn, err := proxy.DialContext(ctx, metadata.Pure())
<mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
<mask> } else {
<mask> log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
<mask> }
<mask> return
<mask> }
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[UDP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) | <mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
<mask> } else {
<mask> log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
<mask> }
<mask> return
<mask> }
<mask> remoteConn = statistic.NewTCPTracker(remoteConn, statistic.DefaultManager, metadata, rule)
<mask> defer remoteConn.Close()
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[UDP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) | <mask> defer remoteConn.Close()
<mask>
<mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> case mode == Direct:
<mask> log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> default:
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
</s> add log.Infoln(
"[TCP] %s --> %s doesn't match any rule using DIRECT",
metadata.SourceAddress(),
metadata.RemoteAddress(),
) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) %s --> %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.SourceAddress(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
log.Infoln(
"[TCP] %s --> %s doesn't match any rule using DIRECT",
metadata.SourceAddress(),
metadata.RemoteAddress(),
) | <mask> log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> case mode == Direct:
<mask> log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> default:
<mask> log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> }
<mask>
<mask> handleSocket(connCtx, remoteConn)
<mask> }
<mask>
</s> Chore: show the source ip in log (#2284)
Co-authored-by: Li Feng <fengli@smartx.com> </s> remove log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln(
"[TCP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
remoteConn.Chains().String(),
) </s> remove log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
</s> add log.Infoln(
"[UDP] %s --> %s doesn't match any rule using DIRECT",
metadata.SourceAddress(),
metadata.RemoteAddress(),
) </s> remove log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln(
"[UDP] %s --> %s match %s(%s) using %s",
metadata.SourceAddress(),
metadata.RemoteAddress(),
rule.RuleType().String(),
rule.Payload(),
rawPc.Chains().String(),
) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[TCP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error())
</s> add log.Warnln(
"[UDP] dial %s %s --> %s error: %s",
proxy.Name(),
metadata.SourceAddress(),
metadata.RemoteAddress(),
err.Error(),
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/4f291fa513509ed7907f64e5eaba7058716a5950 | tunnel/tunnel.go |
- gci | <mask> disable-all: true
<mask> enable:
<mask> - gofumpt
<mask> - gosimple
<mask> - govet
<mask> - ineffassign
<mask> - misspell
</s> Chore: add some linters and clean up the code </s> remove - staticcheck
</s> add - gosimple </s> remove - gci
</s> add - ineffassign
- misspell
- staticcheck
- unconvert
- unused
- usestdlibvars </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove Method: "PUT",
</s> add Method: http.MethodPut, </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | .golangci.yaml |
- gosimple | <mask> linters:
<mask> disable-all: true
<mask> enable:
<mask> - gofumpt
<mask> - staticcheck
<mask> - govet
<mask> - gci
<mask>
<mask> linters-settings:
<mask> gci:
</s> Chore: add some linters and clean up the code </s> remove - gci
</s> add - ineffassign
- misspell
- staticcheck
- unconvert
- unused
- usestdlibvars </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove Method: "PUT",
</s> add Method: http.MethodPut, </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | .golangci.yaml |
- ineffassign
- misspell
- staticcheck
- unconvert
- unused
- usestdlibvars | <mask> enable:
<mask> - gofumpt
<mask> - staticcheck
<mask> - govet
<mask> - gci
<mask>
<mask> linters-settings:
<mask> gci:
<mask> custom-order: true
<mask> sections:
</s> Chore: add some linters and clean up the code </s> remove - staticcheck
</s> add - gosimple </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove Method: "PUT",
</s> add Method: http.MethodPut, </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | .golangci.yaml |
addrType = vmess.AtypIPv4 | <mask> var addrType byte
<mask> var addr []byte
<mask> switch metadata.AddrType() {
<mask> case socks5.AtypIPv4:
<mask> addrType = byte(vmess.AtypIPv4)
<mask> addr = make([]byte, net.IPv4len)
<mask> copy(addr[:], metadata.DstIP.To4())
<mask> case socks5.AtypIPv6:
<mask> addrType = byte(vmess.AtypIPv6)
<mask> addr = make([]byte, net.IPv6len)
</s> Chore: add some linters and clean up the code </s> remove addrType = byte(vmess.AtypIPv6)
</s> add addrType = vmess.AtypIPv6 </s> remove addrType = byte(vmess.AtypDomainName)
</s> add addrType = vmess.AtypDomainName </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove Method: "PUT",
</s> add Method: http.MethodPut, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | adapter/outbound/vmess.go |
addrType = vmess.AtypIPv6 | <mask> addrType = byte(vmess.AtypIPv4)
<mask> addr = make([]byte, net.IPv4len)
<mask> copy(addr[:], metadata.DstIP.To4())
<mask> case socks5.AtypIPv6:
<mask> addrType = byte(vmess.AtypIPv6)
<mask> addr = make([]byte, net.IPv6len)
<mask> copy(addr[:], metadata.DstIP.To16())
<mask> case socks5.AtypDomainName:
<mask> addrType = byte(vmess.AtypDomainName)
<mask> addr = make([]byte, len(metadata.Host)+1)
</s> Chore: add some linters and clean up the code </s> remove addrType = byte(vmess.AtypIPv4)
</s> add addrType = vmess.AtypIPv4 </s> remove addrType = byte(vmess.AtypDomainName)
</s> add addrType = vmess.AtypDomainName </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove Method: "PUT",
</s> add Method: http.MethodPut, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | adapter/outbound/vmess.go |
addrType = vmess.AtypDomainName | <mask> addrType = byte(vmess.AtypIPv6)
<mask> addr = make([]byte, net.IPv6len)
<mask> copy(addr[:], metadata.DstIP.To16())
<mask> case socks5.AtypDomainName:
<mask> addrType = byte(vmess.AtypDomainName)
<mask> addr = make([]byte, len(metadata.Host)+1)
<mask> addr[0] = byte(len(metadata.Host))
<mask> copy(addr[1:], []byte(metadata.Host))
<mask> }
<mask>
</s> Chore: add some linters and clean up the code </s> remove addrType = byte(vmess.AtypIPv6)
</s> add addrType = vmess.AtypIPv6 </s> remove addrType = byte(vmess.AtypIPv4)
</s> add addrType = vmess.AtypIPv4 </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) </s> remove if ok := authenticator.Verify(string(user), string(pass)); !ok {
</s> add if ok := authenticator.Verify(user, pass); !ok { </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | adapter/outbound/vmess.go |
log.Warnln("All PROCESS-NAMES rules will be skipped") | <mask> once.Do(func() {
<mask> err := initWin32API()
<mask> if err != nil {
<mask> log.Errorln("Initialize PROCESS-NAME failed: %s", err.Error())
<mask> log.Warnln("All PROCESS-NAMES rules will be skiped")
<mask> return
<mask> }
<mask> })
<mask> family := windows.AF_INET
<mask> if ip.To4() == nil {
</s> Chore: add some linters and clean up the code </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove if ok := authenticator.Verify(string(user), string(pass)); !ok {
</s> add if ok := authenticator.Verify(user, pass); !ok { </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) </s> remove addrType = byte(vmess.AtypDomainName)
</s> add addrType = vmess.AtypDomainName | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | component/process/process_windows.go |
req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) | <mask> func (ho *HTTPObfs) Write(b []byte) (int, error) {
<mask> if ho.firstRequest {
<mask> randBytes := make([]byte, 16)
<mask> rand.Read(randBytes)
<mask> req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
<mask> req.Header.Set("User-Agent", fmt.Sprintf("curl/7.%d.%d", mathRand.Int()%54, mathRand.Int()%2))
<mask> req.Header.Set("Upgrade", "websocket")
<mask> req.Header.Set("Connection", "Upgrade")
<mask> req.Host = ho.host
<mask> if ho.port != "80" {
</s> Chore: add some linters and clean up the code </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove log.Warnln("All PROCESS-NAMES rules will be skiped")
</s> add log.Warnln("All PROCESS-NAMES rules will be skipped") </s> remove addrType = byte(vmess.AtypIPv6)
</s> add addrType = vmess.AtypIPv6 </s> remove addrType = byte(vmess.AtypDomainName)
</s> add addrType = vmess.AtypDomainName </s> remove if ok := authenticator.Verify(string(user), string(pass)); !ok {
</s> add if ok := authenticator.Verify(user, pass); !ok { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | transport/simple-obfs/http.go |
if ok := authenticator.Verify(user, pass); !ok { | <mask> }
<mask> pass := string(authBuf[:passLen])
<mask>
<mask> // Verify
<mask> if ok := authenticator.Verify(string(user), string(pass)); !ok {
<mask> rw.Write([]byte{1, 1})
<mask> err = ErrAuth
<mask> return
<mask> }
<mask>
</s> Chore: add some linters and clean up the code </s> remove log.Warnln("All PROCESS-NAMES rules will be skiped")
</s> add log.Warnln("All PROCESS-NAMES rules will be skipped") </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) </s> remove Method: "PUT",
</s> add Method: http.MethodPut, </s> remove addrType = byte(vmess.AtypDomainName)
</s> add addrType = vmess.AtypDomainName | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | transport/socks5/socks5.go |
buf.WriteByte(byte(p<<4) | vc.security) | <mask> buf.WriteByte(vc.option)
<mask>
<mask> p := mathRand.Intn(16)
<mask> // P Sec Reserve Cmd
<mask> buf.WriteByte(byte(p<<4) | byte(vc.security))
<mask> buf.WriteByte(0)
<mask> if vc.dst.UDP {
<mask> buf.WriteByte(CommandUDP)
<mask> } else {
<mask> buf.WriteByte(CommandTCP)
</s> Chore: add some linters and clean up the code </s> remove if ok := authenticator.Verify(string(user), string(pass)); !ok {
</s> add if ok := authenticator.Verify(user, pass); !ok { </s> remove Method: "PUT",
</s> add Method: http.MethodPut, </s> remove log.Warnln("All PROCESS-NAMES rules will be skiped")
</s> add log.Warnln("All PROCESS-NAMES rules will be skipped") </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | transport/vmess/conn.go |
Method: http.MethodPut, | <mask> host := hc.cfg.Hosts[rand.Intn(len(hc.cfg.Hosts))]
<mask> path := hc.cfg.Path
<mask> // TODO: connect use VMess Host instead of H2 Host
<mask> req := http.Request{
<mask> Method: "PUT",
<mask> Host: host,
<mask> URL: &url.URL{
<mask> Scheme: "https",
<mask> Host: host,
<mask> Path: path,
</s> Chore: add some linters and clean up the code </s> remove req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
</s> add req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) </s> remove if ok := authenticator.Verify(string(user), string(pass)); !ok {
</s> add if ok := authenticator.Verify(user, pass); !ok { </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) </s> remove log.Warnln("All PROCESS-NAMES rules will be skiped")
</s> add log.Warnln("All PROCESS-NAMES rules will be skipped") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | transport/vmess/h2.go |
req, _ := http.NewRequest(http.MethodGet, u, bytes.NewBuffer(b)) | <mask> host = header[rand.Intn(len(header))]
<mask> }
<mask>
<mask> u := fmt.Sprintf("http://%s%s", host, path)
<mask> req, _ := http.NewRequest("GET", u, bytes.NewBuffer(b))
<mask> for key, list := range hc.cfg.Headers {
<mask> req.Header.Set(key, list[rand.Intn(len(list))])
<mask> }
<mask> req.ContentLength = int64(len(b))
<mask> if err := req.Write(hc.Conn); err != nil {
</s> Chore: add some linters and clean up the code </s> remove log.Warnln("All PROCESS-NAMES rules will be skiped")
</s> add log.Warnln("All PROCESS-NAMES rules will be skipped") </s> remove req, _ := http.NewRequest("GET", fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:]))
</s> add req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("http://%s/", ho.host), bytes.NewBuffer(b[:])) </s> remove if ok := authenticator.Verify(string(user), string(pass)); !ok {
</s> add if ok := authenticator.Verify(user, pass); !ok { </s> remove Method: "PUT",
</s> add Method: http.MethodPut, </s> remove buf.WriteByte(byte(p<<4) | byte(vc.security))
</s> add buf.WriteByte(byte(p<<4) | vc.security) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5045ca457482e1743989214985754054240440b7 | transport/vmess/http.go |
<mask>
<mask> return dialer, nil
<mask> }
<mask>
<mask> func ListenConfig() (*net.ListenConfig, error) {
<mask> cfg := &net.ListenConfig{}
<mask> if ListenConfigHook != nil {
<mask> if err := ListenConfigHook(cfg); err != nil {
<mask> return nil, err
<mask> }
<mask> }
<mask>
<mask> return cfg, nil
<mask> }
<mask>
<mask> func Dial(network, address string) (net.Conn, error) {
<mask> return DialContext(context.Background(), network, address)
<mask> }
<mask>
<mask> func DialContext(ctx context.Context, network, address string) (net.Conn, error) {
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove address = net.JoinHostPort(ip.String(), "0")
</s> add </s> remove return lc.ListenPacket(context.Background(), network, address)
</s> add return cfg.ListenPacket(context.Background(), network, address) </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) | [
"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/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/dialer.go | |
cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) | <mask> }
<mask> }
<mask>
<mask> func ListenPacket(network, address string) (net.PacketConn, error) {
<mask> lc, err := ListenConfig()
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> if ListenPacketHook != nil && address == "" {
<mask> ip, err := ListenPacketHook()
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> address = net.JoinHostPort(ip.String(), "0")
<mask> }
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove address = net.JoinHostPort(ip.String(), "0")
</s> add </s> remove func ListenConfig() (*net.ListenConfig, error) {
cfg := &net.ListenConfig{}
if ListenConfigHook != nil {
if err := ListenConfigHook(cfg); err != nil {
return nil, err
}
}
return cfg, nil
}
</s> add </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove return lc.ListenPacket(context.Background(), network, address)
</s> add return cfg.ListenPacket(context.Background(), network, address) </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/dialer.go |
<mask> ip, err := ListenPacketHook()
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> address = net.JoinHostPort(ip.String(), "0")
<mask> }
<mask> return lc.ListenPacket(context.Background(), network, address)
<mask> }
<mask>
<mask> func dualStackDialContext(ctx context.Context, network, address string) (net.Conn, error) {
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove return lc.ListenPacket(context.Background(), network, address)
</s> add return cfg.ListenPacket(context.Background(), network, address) </s> remove func ListenConfig() (*net.ListenConfig, error) {
cfg := &net.ListenConfig{}
if ListenConfigHook != nil {
if err := ListenConfigHook(cfg); err != nil {
return nil, err
}
}
return cfg, nil
}
</s> add </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/dialer.go | |
return cfg.ListenPacket(context.Background(), network, address) | <mask> return nil, err
<mask> }
<mask> address = net.JoinHostPort(ip.String(), "0")
<mask> }
<mask> return lc.ListenPacket(context.Background(), network, address)
<mask> }
<mask>
<mask> func dualStackDialContext(ctx context.Context, network, address string) (net.Conn, error) {
<mask> host, port, err := net.SplitHostPort(address)
<mask> if err != nil {
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove address = net.JoinHostPort(ip.String(), "0")
</s> add </s> remove func ListenConfig() (*net.ListenConfig, error) {
cfg := &net.ListenConfig{}
if ListenConfigHook != nil {
if err := ListenConfigHook(cfg); err != nil {
return nil, err
}
}
return cfg, nil
}
</s> add </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/dialer.go |
<mask>
<mask> import (
<mask> "errors"
<mask> "net"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/common/singledo"
<mask> )
<mask>
<mask> type DialerHookFunc = func(dialer *net.Dialer) error
<mask> type DialHookFunc = func(dialer *net.Dialer, network string, ip net.IP) error
<mask> type ListenConfigHookFunc = func(*net.ListenConfig) error
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove type ListenConfigHookFunc = func(*net.ListenConfig) error
type ListenPacketHookFunc = func() (net.IP, error)
</s> add type ListenPacketHookFunc = func(lc *net.ListenConfig, address string) (string, error) </s> remove ListenConfigHook ListenConfigHookFunc
</s> add </s> remove single := singledo.NewSingle(5 * time.Second)
</s> add </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go | |
type ListenPacketHookFunc = func(lc *net.ListenConfig, address string) (string, error) | <mask> )
<mask>
<mask> type DialerHookFunc = func(dialer *net.Dialer) error
<mask> type DialHookFunc = func(dialer *net.Dialer, network string, ip net.IP) error
<mask> type ListenConfigHookFunc = func(*net.ListenConfig) error
<mask> type ListenPacketHookFunc = func() (net.IP, error)
<mask>
<mask> var (
<mask> DialerHook DialerHookFunc
<mask> DialHook DialHookFunc
<mask> ListenConfigHook ListenConfigHookFunc
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove "time"
"github.com/Dreamacro/clash/common/singledo"
</s> add </s> remove ListenConfigHook ListenConfigHookFunc
</s> add </s> remove single := singledo.NewSingle(5 * time.Second)
</s> add </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go |
<mask>
<mask> var (
<mask> DialerHook DialerHookFunc
<mask> DialHook DialHookFunc
<mask> ListenConfigHook ListenConfigHookFunc
<mask> ListenPacketHook ListenPacketHookFunc
<mask> )
<mask>
<mask> var (
<mask> ErrAddrNotFound = errors.New("addr not found")
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove type ListenConfigHookFunc = func(*net.ListenConfig) error
type ListenPacketHookFunc = func() (net.IP, error)
</s> add type ListenPacketHookFunc = func(lc *net.ListenConfig, address string) (string, error) </s> remove "time"
"github.com/Dreamacro/clash/common/singledo"
</s> add </s> remove func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
</s> add </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.