docstring_tokens stringlengths 0 76.5k | code_tokens stringlengths 75 1.81M | label_window listlengths 4 2.12k | html_url stringlengths 74 116 | file_name stringlengths 3 311 |
|---|---|---|---|---|
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
<mask>
<mask> // from https://github.com/vishvananda/netlink/blob/bca67dfc8220b44ef582c9da4e9172bf1c9ec973/nl/nl_linux.go#L52-L62
<mask> var nativeEndian = func() binary.ByteOrder {
<mask> var x uint32 = 0x01020304
<mask> if *(*byte)(unsafe.Pointer(&x)) == 0x01 {
<mask> return binary.BigEndian
<mask> }
<mask>
<mask> return binary.LittleEndian
<mask> }()
<mask>
<mask> const (
<mask> sizeOfSocketDiagRequest = syscall.SizeofNlMsghdr + 8 + 48
<mask> socketDiagByFamily = 20
<mask> pathProc = "/proc"
<mask> )
</s> Refactor: linux process resolving (#2305) </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add "github.com/mdlayher/netlink"
"golang.org/x/sys/unix" </s> remove sizeOfSocketDiagRequest = syscall.SizeofNlMsghdr + 8 + 48
socketDiagByFamily = 20
pathProc = "/proc"
</s> add SOCK_DIAG_BY_FAMILY = 20
inetDiagRequestSize = int(unsafe.Sizeof(inetDiagRequest{}))
inetDiagResponseSize = int(unsafe.Sizeof(inetDiagResponse{})) </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) {
var family byte
var protocol byte
switch network {
case TCP:
protocol = syscall.IPPROTO_TCP
case UDP:
protocol = syscall.IPPROTO_UDP
default:
return 0, 0, ErrInvalidNetwork
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (uint32, uint32, error) {
request := &inetDiagRequest{
States: 0xffffffff,
Cookie: [2]uint32{0xffffffff, 0xffffffff}, </s> remove family = syscall.AF_INET
</s> add request.Family = unix.AF_INET </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound | [
"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/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go | |
SOCK_DIAG_BY_FAMILY = 20
inetDiagRequestSize = int(unsafe.Sizeof(inetDiagRequest{}))
inetDiagResponseSize = int(unsafe.Sizeof(inetDiagResponse{})) | <mask> return binary.LittleEndian
<mask> }()
<mask>
<mask> const (
<mask> sizeOfSocketDiagRequest = syscall.SizeofNlMsghdr + 8 + 48
<mask> socketDiagByFamily = 20
<mask> pathProc = "/proc"
<mask> )
<mask>
<mask> func findProcessName(network string, ip net.IP, srcPort int) (string, error) {
<mask> inode, uid, err := resolveSocketByNetlink(network, ip, srcPort)
<mask> if err != nil {
</s> Refactor: linux process resolving (#2305) </s> remove // from https://github.com/vishvananda/netlink/blob/bca67dfc8220b44ef582c9da4e9172bf1c9ec973/nl/nl_linux.go#L52-L62
var nativeEndian = func() binary.ByteOrder {
var x uint32 = 0x01020304
if *(*byte)(unsafe.Pointer(&x)) == 0x01 {
return binary.BigEndian
}
return binary.LittleEndian
}()
</s> add </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) {
var family byte
var protocol byte
switch network {
case TCP:
protocol = syscall.IPPROTO_TCP
case UDP:
protocol = syscall.IPPROTO_UDP
default:
return 0, 0, ErrInvalidNetwork
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (uint32, uint32, error) {
request := &inetDiagRequest{
States: 0xffffffff,
Cookie: [2]uint32{0xffffffff, 0xffffffff}, </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound </s> remove func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
files, err := os.ReadDir(pathProc)
</s> add func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (uint32, uint32, error) {
request := &inetDiagRequest{
States: 0xffffffff,
Cookie: [2]uint32{0xffffffff, 0xffffffff}, | <mask>
<mask> return resolveProcessNameByProcSearch(inode, uid)
<mask> }
<mask>
<mask> func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) {
<mask> var family byte
<mask> var protocol byte
<mask>
<mask> switch network {
<mask> case TCP:
<mask> protocol = syscall.IPPROTO_TCP
<mask> case UDP:
<mask> protocol = syscall.IPPROTO_UDP
<mask> default:
<mask> return 0, 0, ErrInvalidNetwork
<mask> }
<mask>
<mask> if ip.To4() != nil {
<mask> family = syscall.AF_INET
<mask> } else {
</s> Refactor: linux process resolving (#2305) </s> remove family = syscall.AF_INET
</s> add request.Family = unix.AF_INET </s> remove sizeOfSocketDiagRequest = syscall.SizeofNlMsghdr + 8 + 48
socketDiagByFamily = 20
pathProc = "/proc"
</s> add SOCK_DIAG_BY_FAMILY = 20
inetDiagRequestSize = int(unsafe.Sizeof(inetDiagRequest{}))
inetDiagResponseSize = int(unsafe.Sizeof(inetDiagResponse{})) </s> remove family = syscall.AF_INET6
</s> add request.Family = unix.AF_INET6 </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound | [
"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/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
request.Family = unix.AF_INET | <mask> return 0, 0, ErrInvalidNetwork
<mask> }
<mask>
<mask> if ip.To4() != nil {
<mask> family = syscall.AF_INET
<mask> } else {
<mask> family = syscall.AF_INET6
<mask> }
<mask>
<mask> req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
</s> Refactor: linux process resolving (#2305) </s> remove family = syscall.AF_INET6
</s> add request.Family = unix.AF_INET6 </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) {
var family byte
var protocol byte
switch network {
case TCP:
protocol = syscall.IPPROTO_TCP
case UDP:
protocol = syscall.IPPROTO_UDP
default:
return 0, 0, ErrInvalidNetwork
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (uint32, uint32, error) {
request := &inetDiagRequest{
States: 0xffffffff,
Cookie: [2]uint32{0xffffffff, 0xffffffff}, </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
request.Family = unix.AF_INET6 | <mask>
<mask> if ip.To4() != nil {
<mask> family = syscall.AF_INET
<mask> } else {
<mask> family = syscall.AF_INET6
<mask> }
<mask>
<mask> req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
<mask>
<mask> socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
</s> Refactor: linux process resolving (#2305) </s> remove family = syscall.AF_INET
</s> add request.Family = unix.AF_INET </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) {
var family byte
var protocol byte
switch network {
case TCP:
protocol = syscall.IPPROTO_TCP
case UDP:
protocol = syscall.IPPROTO_UDP
default:
return 0, 0, ErrInvalidNetwork
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (uint32, uint32, error) {
request := &inetDiagRequest{
States: 0xffffffff,
Cookie: [2]uint32{0xffffffff, 0xffffffff}, </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork | <mask> } else {
<mask> family = syscall.AF_INET6
<mask> }
<mask>
<mask> req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
<mask>
<mask> socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
<mask> if err != nil {
<mask> return 0, 0, fmt.Errorf("dial netlink: %w", err)
<mask> }
<mask> defer syscall.Close(socket)
<mask>
<mask> syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
<mask> syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
<mask>
<mask> if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
<mask> Family: syscall.AF_NETLINK,
<mask> Pad: 0,
<mask> Pid: 0,
<mask> Groups: 0,
<mask> }); err != nil {
<mask> return 0, 0, err
<mask> }
<mask>
<mask> if _, err := syscall.Write(socket, req); err != nil {
<mask> return 0, 0, fmt.Errorf("write request: %w", err)
<mask> }
</s> Refactor: linux process resolving (#2305) </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) </s> remove if _, err := syscall.Write(socket, req); err != nil {
return 0, 0, fmt.Errorf("write request: %w", err)
</s> add if v4 := ip.To4(); v4 != nil {
copy(request.Src[:], v4)
} else {
copy(request.Src[:], ip) </s> remove family = syscall.AF_INET6
</s> add request.Family = unix.AF_INET6 </s> remove family = syscall.AF_INET
</s> add request.Family = unix.AF_INET </s> remove messages, err := syscall.ParseNetlinkMessage(rb[:n])
</s> add conn, err := netlink.Dial(unix.NETLINK_INET_DIAG, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"k... | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
if v4 := ip.To4(); v4 != nil {
copy(request.Src[:], v4)
} else {
copy(request.Src[:], ip) | <mask> }); err != nil {
<mask> return 0, 0, err
<mask> }
<mask>
<mask> if _, err := syscall.Write(socket, req); err != nil {
<mask> return 0, 0, fmt.Errorf("write request: %w", err)
<mask> }
<mask>
<mask> rb := pool.Get(pool.RelayBufferSize)
<mask> defer pool.Put(rb)
<mask>
</s> Refactor: linux process resolving (#2305) </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork </s> remove messages, err := syscall.ParseNetlinkMessage(rb[:n])
</s> add conn, err := netlink.Dial(unix.NETLINK_INET_DIAG, nil) </s> remove return 0, 0, fmt.Errorf("parse netlink message: %w", err)
} else if len(messages) == 0 {
return 0, 0, fmt.Errorf("unexcepted netlink response")
</s> add return 0, 0, err </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) | <mask> if _, err := syscall.Write(socket, req); err != nil {
<mask> return 0, 0, fmt.Errorf("write request: %w", err)
<mask> }
<mask>
<mask> rb := pool.Get(pool.RelayBufferSize)
<mask> defer pool.Put(rb)
<mask>
<mask> n, err := syscall.Read(socket, rb)
<mask> if err != nil {
<mask> return 0, 0, fmt.Errorf("read response: %w", err)
<mask> }
<mask>
<mask> messages, err := syscall.ParseNetlinkMessage(rb[:n])
<mask> if err != nil {
<mask> return 0, 0, fmt.Errorf("parse netlink message: %w", err)
<mask> } else if len(messages) == 0 {
</s> Refactor: linux process resolving (#2305) </s> remove messages, err := syscall.ParseNetlinkMessage(rb[:n])
</s> add conn, err := netlink.Dial(unix.NETLINK_INET_DIAG, nil) </s> remove if _, err := syscall.Write(socket, req); err != nil {
return 0, 0, fmt.Errorf("write request: %w", err)
</s> add if v4 := ip.To4(); v4 != nil {
copy(request.Src[:], v4)
} else {
copy(request.Src[:], ip) </s> remove return 0, 0, fmt.Errorf("parse netlink message: %w", err)
} else if len(messages) == 0 {
return 0, 0, fmt.Errorf("unexcepted netlink response")
</s> add return 0, 0, err </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
conn, err := netlink.Dial(unix.NETLINK_INET_DIAG, nil) | <mask> if err != nil {
<mask> return 0, 0, fmt.Errorf("read response: %w", err)
<mask> }
<mask>
<mask> messages, err := syscall.ParseNetlinkMessage(rb[:n])
<mask> if err != nil {
<mask> return 0, 0, fmt.Errorf("parse netlink message: %w", err)
<mask> } else if len(messages) == 0 {
<mask> return 0, 0, fmt.Errorf("unexcepted netlink response")
<mask> }
</s> Refactor: linux process resolving (#2305) </s> remove return 0, 0, fmt.Errorf("parse netlink message: %w", err)
} else if len(messages) == 0 {
return 0, 0, fmt.Errorf("unexcepted netlink response")
</s> add return 0, 0, err </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork </s> remove if _, err := syscall.Write(socket, req); err != nil {
return 0, 0, fmt.Errorf("write request: %w", err)
</s> add if v4 := ip.To4(); v4 != nil {
copy(request.Src[:], v4)
} else {
copy(request.Src[:], ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
return 0, 0, err | <mask> }
<mask>
<mask> messages, err := syscall.ParseNetlinkMessage(rb[:n])
<mask> if err != nil {
<mask> return 0, 0, fmt.Errorf("parse netlink message: %w", err)
<mask> } else if len(messages) == 0 {
<mask> return 0, 0, fmt.Errorf("unexcepted netlink response")
<mask> }
<mask>
<mask> message := messages[0]
<mask> if message.Header.Type&syscall.NLMSG_ERROR != 0 {
<mask> return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> Refactor: linux process resolving (#2305) </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], </s> remove messages, err := syscall.ParseNetlinkMessage(rb[:n])
</s> add conn, err := netlink.Dial(unix.NETLINK_INET_DIAG, nil) </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], | <mask> return 0, 0, fmt.Errorf("parse netlink message: %w", err)
<mask> } else if len(messages) == 0 {
<mask> return 0, 0, fmt.Errorf("unexcepted netlink response")
<mask> }
<mask>
<mask> message := messages[0]
<mask> if message.Header.Type&syscall.NLMSG_ERROR != 0 {
<mask> return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
<mask> }
<mask>
<mask> inode, uid := unpackSocketDiagResponse(&messages[0])
<mask> if inode < 0 || uid < 0 {
<mask> return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
</s> Refactor: linux process resolving (#2305) </s> remove return 0, 0, fmt.Errorf("parse netlink message: %w", err)
} else if len(messages) == 0 {
return 0, 0, fmt.Errorf("unexcepted netlink response")
</s> add return 0, 0, err </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove messages, err := syscall.ParseNetlinkMessage(rb[:n])
</s> add conn, err := netlink.Dial(unix.NETLINK_INET_DIAG, nil) </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err | <mask> if message.Header.Type&syscall.NLMSG_ERROR != 0 {
<mask> return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
<mask> }
<mask>
<mask> inode, uid := unpackSocketDiagResponse(&messages[0])
<mask> if inode < 0 || uid < 0 {
<mask> return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
<mask> }
<mask>
<mask> return inode, uid, nil
<mask> }
<mask>
<mask> func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
<mask> s := make([]byte, 16)
<mask>
<mask> if v4 := source.To4(); v4 != nil {
<mask> copy(s, v4)
<mask> } else {
<mask> copy(s, source)
<mask> }
<mask>
<mask> buf := make([]byte, sizeOfSocketDiagRequest)
<mask>
<mask> nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
</s> Refactor: linux process resolving (#2305) </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove return 0, 0, fmt.Errorf("parse netlink message: %w", err)
} else if len(messages) == 0 {
return 0, 0, fmt.Errorf("unexcepted netlink response")
</s> add return 0, 0, err </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound </s> remove func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
if len(msg.Data) < 72 {
return 0, 0
</s> add return response.INode, response.UID, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} | <mask> } else {
<mask> copy(s, source)
<mask> }
<mask>
<mask> buf := make([]byte, sizeOfSocketDiagRequest)
<mask>
<mask> nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
<mask> nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
<mask> nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
<mask> nativeEndian.PutUint32(buf[8:12], 0)
<mask> nativeEndian.PutUint32(buf[12:16], 0)
<mask>
<mask> buf[16] = family
<mask> buf[17] = protocol
<mask> buf[18] = 0
<mask> buf[19] = 0
<mask> nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
<mask>
<mask> binary.BigEndian.PutUint16(buf[24:26], sourcePort)
<mask> binary.BigEndian.PutUint16(buf[26:28], 0)
<mask>
<mask> copy(buf[28:44], s)
<mask> copy(buf[44:60], net.IPv6zero)
<mask>
<mask> nativeEndian.PutUint32(buf[60:64], 0)
<mask> nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
<mask>
<mask> return buf
<mask> }
<mask>
<mask> func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
</s> Refactor: linux process resolving (#2305) </s> remove return buf
}
</s> add response := (*inetDiagResponse)(unsafe.Pointer(&msg.Data[0])) </s> remove func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
if len(msg.Data) < 72 {
return 0, 0
</s> add return response.INode, response.UID, nil </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound </s> remove func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (int32, int32, error) {
var family byte
var protocol byte
switch network {
case TCP:
protocol = syscall.IPPROTO_TCP
case UDP:
protocol = syscall.IPPROTO_UDP
default:
return 0, 0, ErrInvalidNetwork
</s> add func resolveSocketByNetlink(network string, ip net.IP, srcPort int) (uint32, uint32, error) {
request := &inetDiagRequest{
States: 0xffffffff,
Cookie: [2]uint32{0xffffffff, 0xffffffff}, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
response := (*inetDiagResponse)(unsafe.Pointer(&msg.Data[0])) | <mask>
<mask> nativeEndian.PutUint32(buf[60:64], 0)
<mask> nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
<mask>
<mask> return buf
<mask> }
<mask>
<mask> func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
<mask> if len(msg.Data) < 72 {
<mask> return 0, 0
<mask> }
</s> Refactor: linux process resolving (#2305) </s> remove func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
if len(msg.Data) < 72 {
return 0, 0
</s> add return response.INode, response.UID, nil </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
return response.INode, response.UID, nil | <mask>
<mask> return buf
<mask> }
<mask>
<mask> func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
<mask> if len(msg.Data) < 72 {
<mask> return 0, 0
<mask> }
<mask>
<mask> data := msg.Data
<mask>
<mask> uid = int32(nativeEndian.Uint32(data[64:68]))
</s> Refactor: linux process resolving (#2305) </s> remove return buf
}
</s> add response := (*inetDiagResponse)(unsafe.Pointer(&msg.Data[0])) </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
files, err := os.ReadDir(pathProc)
</s> add func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
return 0, 0, ErrNotFound | <mask> if len(msg.Data) < 72 {
<mask> return 0, 0
<mask> }
<mask>
<mask> data := msg.Data
<mask>
<mask> uid = int32(nativeEndian.Uint32(data[64:68]))
<mask> inode = int32(nativeEndian.Uint32(data[68:72]))
<mask>
<mask> return
<mask> }
<mask>
<mask> func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
<mask> files, err := os.ReadDir(pathProc)
<mask> if err != nil {
</s> Refactor: linux process resolving (#2305) </s> remove func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
if len(msg.Data) < 72 {
return 0, 0
</s> add return response.INode, response.UID, nil </s> remove func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
files, err := os.ReadDir(pathProc)
</s> add func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") </s> remove return buf
}
</s> add response := (*inetDiagResponse)(unsafe.Pointer(&msg.Data[0])) </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") | <mask>
<mask> return
<mask> }
<mask>
<mask> func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
<mask> files, err := os.ReadDir(pathProc)
<mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
<mask> buffer := make([]byte, syscall.PathMax)
</s> Refactor: linux process resolving (#2305) </s> remove data := msg.Data
uid = int32(nativeEndian.Uint32(data[64:68]))
inode = int32(nativeEndian.Uint32(data[68:72]))
return
</s> add return 0, 0, ErrNotFound </s> remove buffer := make([]byte, syscall.PathMax)
</s> add buffer := make([]byte, unix.PathMax) </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
</s> add if info.Sys().(*syscall.Stat_t).Uid != uid { </s> remove func unpackSocketDiagResponse(msg *syscall.NetlinkMessage) (inode, uid int32) {
if len(msg.Data) < 72 {
return 0, 0
</s> add return response.INode, response.UID, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
buffer := make([]byte, unix.PathMax) | <mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
<mask> buffer := make([]byte, syscall.PathMax)
<mask> socket := fmt.Appendf(nil, "socket:[%d]", inode)
<mask>
<mask> for _, f := range files {
<mask> if !f.IsDir() || !isPid(f.Name()) {
<mask> continue
</s> Refactor: linux process resolving (#2305) </s> remove func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
files, err := os.ReadDir(pathProc)
</s> add func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") </s> remove n, err := syscall.Readlink(path.Join(fdPath, fd.Name()), buffer)
</s> add n, err := unix.Readlink(filepath.Join(fdPath, fd.Name()), buffer) </s> remove if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
</s> add if info.Sys().(*syscall.Stat_t).Uid != uid { </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
if info.Sys().(*syscall.Stat_t).Uid != uid { | <mask> info, err := f.Info()
<mask> if err != nil {
<mask> return "", err
<mask> }
<mask> if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
<mask> continue
<mask> }
<mask>
<mask> processPath := path.Join(pathProc, f.Name())
<mask> fdPath := path.Join(processPath, "fd")
</s> Refactor: linux process resolving (#2305) </s> remove processPath := path.Join(pathProc, f.Name())
fdPath := path.Join(processPath, "fd")
</s> add processPath := filepath.Join("/proc", f.Name())
fdPath := filepath.Join(processPath, "fd") </s> remove buffer := make([]byte, syscall.PathMax)
</s> add buffer := make([]byte, unix.PathMax) </s> remove n, err := syscall.Readlink(path.Join(fdPath, fd.Name()), buffer)
</s> add n, err := unix.Readlink(filepath.Join(fdPath, fd.Name()), buffer) </s> remove func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
files, err := os.ReadDir(pathProc)
</s> add func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
processPath := filepath.Join("/proc", f.Name())
fdPath := filepath.Join(processPath, "fd") | <mask> if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
<mask> continue
<mask> }
<mask>
<mask> processPath := path.Join(pathProc, f.Name())
<mask> fdPath := path.Join(processPath, "fd")
<mask>
<mask> fds, err := os.ReadDir(fdPath)
<mask> if err != nil {
<mask> continue
<mask> }
</s> Refactor: linux process resolving (#2305) </s> remove if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
</s> add if info.Sys().(*syscall.Stat_t).Uid != uid { </s> remove n, err := syscall.Readlink(path.Join(fdPath, fd.Name()), buffer)
</s> add n, err := unix.Readlink(filepath.Join(fdPath, fd.Name()), buffer) </s> remove buffer := make([]byte, syscall.PathMax)
</s> add buffer := make([]byte, unix.PathMax) </s> remove if _, err := syscall.Write(socket, req); err != nil {
return 0, 0, fmt.Errorf("write request: %w", err)
</s> add if v4 := ip.To4(); v4 != nil {
copy(request.Src[:], v4)
} else {
copy(request.Src[:], ip) </s> remove rb := pool.Get(pool.RelayBufferSize)
defer pool.Put(rb)
n, err := syscall.Read(socket, rb)
if err != nil {
return 0, 0, fmt.Errorf("read response: %w", err)
}
</s> add binary.BigEndian.PutUint16(request.SrcPort[:], uint16(srcPort)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
n, err := unix.Readlink(filepath.Join(fdPath, fd.Name()), buffer) | <mask> continue
<mask> }
<mask>
<mask> for _, fd := range fds {
<mask> n, err := syscall.Readlink(path.Join(fdPath, fd.Name()), buffer)
<mask> if err != nil {
<mask> continue
<mask> }
<mask>
<mask> if bytes.Equal(buffer[:n], socket) {
</s> Refactor: linux process resolving (#2305) </s> remove buffer := make([]byte, syscall.PathMax)
</s> add buffer := make([]byte, unix.PathMax) </s> remove return os.Readlink(path.Join(processPath, "exe"))
</s> add return os.Readlink(filepath.Join(processPath, "exe")) </s> remove processPath := path.Join(pathProc, f.Name())
fdPath := path.Join(processPath, "fd")
</s> add processPath := filepath.Join("/proc", f.Name())
fdPath := filepath.Join(processPath, "fd") </s> remove if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
</s> add if info.Sys().(*syscall.Stat_t).Uid != uid { </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
return os.Readlink(filepath.Join(processPath, "exe")) | <mask> continue
<mask> }
<mask>
<mask> if bytes.Equal(buffer[:n], socket) {
<mask> return os.Readlink(path.Join(processPath, "exe"))
<mask> }
<mask> }
<mask> }
<mask>
<mask> return "", fmt.Errorf("process of uid(%d),inode(%d) not found", uid, inode)
</s> Refactor: linux process resolving (#2305) </s> remove n, err := syscall.Readlink(path.Join(fdPath, fd.Name()), buffer)
</s> add n, err := unix.Readlink(filepath.Join(fdPath, fd.Name()), buffer) </s> remove buffer := make([]byte, syscall.PathMax)
</s> add buffer := make([]byte, unix.PathMax) </s> remove if info.Sys().(*syscall.Stat_t).Uid != uint32(uid) {
</s> add if info.Sys().(*syscall.Stat_t).Uid != uid { </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
files, err := os.ReadDir(pathProc)
</s> add func resolveProcessNameByProcSearch(inode, uid uint32) (string, error) {
files, err := os.ReadDir("/proc") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | component/process/process_linux.go |
github.com/mdlayher/netlink v1.6.0 | <mask> github.com/gofrs/uuid v4.2.0+incompatible
<mask> github.com/gorilla/websocket v1.5.0
<mask> github.com/insomniacslk/dhcp v0.0.0-20220822114210-de18a9d48e84
<mask> github.com/miekg/dns v1.1.50
<mask> github.com/oschwald/geoip2-golang v1.8.0
<mask> github.com/sirupsen/logrus v1.9.0
<mask> github.com/stretchr/testify v1.8.0
<mask> go.etcd.io/bbolt v1.3.6
<mask> go.uber.org/atomic v1.10.0
</s> Refactor: linux process resolving (#2305) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.mod |
github.com/google/go-cmp v0.5.7 // indirect
github.com/josharian/native v1.0.0 // indirect | <mask>
<mask> require (
<mask> github.com/ajg/form v1.5.1 // indirect
<mask> github.com/davecgh/go-spew v1.1.1 // indirect
<mask> github.com/kr/text v0.2.0 // indirect
<mask> github.com/mdlayher/socket v0.1.1 // indirect
<mask> github.com/oschwald/maxminddb-golang v1.10.0 // indirect
<mask> github.com/pmezard/go-difflib v1.0.0 // indirect
<mask> github.com/u-root/uio v0.0.0-20210528114334-82958018845c // indirect
<mask> golang.org/x/mod v0.4.2 // indirect
</s> Refactor: linux process resolving (#2305) </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add "github.com/mdlayher/netlink"
"golang.org/x/sys/unix" </s> remove // from https://github.com/vishvananda/netlink/blob/bca67dfc8220b44ef582c9da4e9172bf1c9ec973/nl/nl_linux.go#L52-L62
var nativeEndian = func() binary.ByteOrder {
var x uint32 = 0x01020304
if *(*byte)(unsafe.Pointer(&x)) == 0x01 {
return binary.BigEndian
}
return binary.LittleEndian
}()
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.mod |
github.com/mdlayher/socket v0.1.1 // indirect | <mask> github.com/google/go-cmp v0.5.7 // indirect
<mask> github.com/josharian/native v1.0.0 // indirect
<mask> github.com/kr/text v0.2.0 // indirect
<mask> github.com/oschwald/maxminddb-golang v1.10.0 // indirect
<mask> github.com/pmezard/go-difflib v1.0.0 // indirect
<mask> github.com/u-root/uio v0.0.0-20210528114334-82958018845c // indirect
<mask> golang.org/x/mod v0.4.2 // indirect
<mask> golang.org/x/text v0.3.7 // indirect
<mask> golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2 // indirect
</s> Refactor: linux process resolving (#2305) </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add "github.com/mdlayher/netlink"
"golang.org/x/sys/unix" </s> remove // from https://github.com/vishvananda/netlink/blob/bca67dfc8220b44ef582c9da4e9172bf1c9ec973/nl/nl_linux.go#L52-L62
var nativeEndian = func() binary.ByteOrder {
var x uint32 = 0x01020304
if *(*byte)(unsafe.Pointer(&x)) == 0x01 {
return binary.BigEndian
}
return binary.LittleEndian
}()
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.mod |
github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= | <mask> github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
<mask> github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
<mask> github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
<mask> github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
<mask> github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
<mask> github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
<mask> github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
<mask> github.com/hugelgupf/socketpair v0.0.0-20190730060125-05d35a94e714/go.mod h1:2Goc3h8EklBH5mspfHFxBnEoURQCGzQQH1ga9Myjvis=
<mask> github.com/insomniacslk/dhcp v0.0.0-20220822114210-de18a9d48e84 h1:MJTy6H+EpXLeAn0P5WAWeLk6dJA3V0ik6S3VJfUyQuI=
<mask> github.com/insomniacslk/dhcp v0.0.0-20220822114210-de18a9d48e84/go.mod h1:h+MxyHxRg9NH3terB1nfRIUaQEcI0XOVkdR9LNBlp8E=
</s> Refactor: linux process resolving (#2305) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
github.com/josharian/native v1.0.0 h1:Ts/E8zCSEsG17dUqv7joXJFybuMLjQfWE04tsBODTxk=
github.com/josharian/native v1.0.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w= | <mask> github.com/hugelgupf/socketpair v0.0.0-20190730060125-05d35a94e714/go.mod h1:2Goc3h8EklBH5mspfHFxBnEoURQCGzQQH1ga9Myjvis=
<mask> github.com/insomniacslk/dhcp v0.0.0-20220822114210-de18a9d48e84 h1:MJTy6H+EpXLeAn0P5WAWeLk6dJA3V0ik6S3VJfUyQuI=
<mask> github.com/insomniacslk/dhcp v0.0.0-20220822114210-de18a9d48e84/go.mod h1:h+MxyHxRg9NH3terB1nfRIUaQEcI0XOVkdR9LNBlp8E=
<mask> github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
<mask> github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ=
<mask> github.com/jsimonetti/rtnetlink v0.0.0-20201009170750-9c6f07d100c1/go.mod h1:hqoO/u39cqLeBLebZ8fWdE96O7FxrAsRYhnVOdgHxok=
<mask> github.com/jsimonetti/rtnetlink v0.0.0-20201110080708-d2c240429e6c/go.mod h1:huN4d1phzjhlOsNIjFsw2SVRbwIHj3fJDMEU2SDPTmg=
<mask> github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
</s> Refactor: linux process resolving (#2305) </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
github.com/mdlayher/netlink v1.6.0 h1:rOHX5yl7qnlpiVkFWoqccueppMtXzeziFjWAjLg6sz0=
github.com/mdlayher/netlink v1.6.0/go.mod h1:0o3PlBmGst1xve7wQ7j/hwpNaFaH4qCRyWCdcZk8/vA= | <mask> github.com/mdlayher/netlink v1.0.0/go.mod h1:KxeJAFOFLG6AjpyDkQ/iIhxygIUKD+vcwqcnu43w/+M=
<mask> github.com/mdlayher/netlink v1.1.0/go.mod h1:H4WCitaheIsdF9yOYu8CFmCgQthAPIWZmcKp9uZHgmY=
<mask> github.com/mdlayher/netlink v1.1.1/go.mod h1:WTYpFb/WTvlRJAyKhZL5/uy69TDDpHHu2VZmb2XgV7o=
<mask> github.com/mdlayher/raw v0.0.0-20190606142536-fef19f00fc18/go.mod h1:7EpbotpCmVZcu+KCX4g9WaRNuu11uyhiW7+Le1dKawg=
<mask> github.com/mdlayher/raw v0.0.0-20191009151244-50f2db8cc065/go.mod h1:7EpbotpCmVZcu+KCX4g9WaRNuu11uyhiW7+Le1dKawg=
<mask> github.com/mdlayher/socket v0.1.1 h1:q3uOGirUPfAV2MUoaC7BavjQ154J7+JOkTWyiV+intI=
<mask> github.com/mdlayher/socket v0.1.1/go.mod h1:mYV5YIZAfHh4dzDVzI8x8tWLWCliuX8Mon5Awbj+qDs=
<mask> github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
<mask> github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
</s> Refactor: linux process resolving (#2305) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
github.com/mdlayher/socket v0.1.1 h1:q3uOGirUPfAV2MUoaC7BavjQ154J7+JOkTWyiV+intI=
github.com/mdlayher/socket v0.1.1/go.mod h1:mYV5YIZAfHh4dzDVzI8x8tWLWCliuX8Mon5Awbj+qDs= | <mask> github.com/mdlayher/netlink v1.6.0/go.mod h1:0o3PlBmGst1xve7wQ7j/hwpNaFaH4qCRyWCdcZk8/vA=
<mask> github.com/mdlayher/raw v0.0.0-20190606142536-fef19f00fc18/go.mod h1:7EpbotpCmVZcu+KCX4g9WaRNuu11uyhiW7+Le1dKawg=
<mask> github.com/mdlayher/raw v0.0.0-20191009151244-50f2db8cc065/go.mod h1:7EpbotpCmVZcu+KCX4g9WaRNuu11uyhiW7+Le1dKawg=
<mask> github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
<mask> github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
<mask> github.com/oschwald/geoip2-golang v1.8.0 h1:KfjYB8ojCEn/QLqsDU0AzrJ3R5Qa9vFlx3z6SLNcKTs=
<mask> github.com/oschwald/geoip2-golang v1.8.0/go.mod h1:R7bRvYjOeaoenAp9sKRS8GX5bJWcZ0laWO5+DauEktw=
<mask> github.com/oschwald/maxminddb-golang v1.10.0 h1:Xp1u0ZhqkSuopaKmk1WwHtjF0H9Hd9181uj2MQ5Vndg=
<mask> github.com/oschwald/maxminddb-golang v1.10.0/go.mod h1:Y2ELenReaLAZ0b400URyGwvYxHV1dLIxBuyOsyYjHK0=
</s> Refactor: linux process resolving (#2305) </s> remove family = syscall.AF_INET6
</s> add request.Family = unix.AF_INET6 | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
golang.org/x/net v0.0.0-20210928044308-7d9f5e0b762b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= | <mask> golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
<mask> golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
<mask> golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
<mask> golang.org/x/net v0.0.0-20220822230855-b0a4917ee28c h1:JVAXQ10yGGVbSyoer5VILysz6YKjdNT2bsvlayjqhes=
<mask> golang.org/x/net v0.0.0-20220822230855-b0a4917ee28c/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
<mask> golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
<mask> golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
<mask> golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde h1:ejfdSekXMDxDLbRrJMwUk6KnSLZ2McaUCVcIKM+N6jc=
</s> Refactor: linux process resolving (#2305) </s> remove if _, err := syscall.Write(socket, req); err != nil {
return 0, 0, fmt.Errorf("write request: %w", err)
</s> add if v4 := ip.To4(); v4 != nil {
copy(request.Src[:], v4)
} else {
copy(request.Src[:], ip) </s> remove buf := make([]byte, sizeOfSocketDiagRequest)
nativeEndian.PutUint32(buf[0:4], sizeOfSocketDiagRequest)
nativeEndian.PutUint16(buf[4:6], socketDiagByFamily)
nativeEndian.PutUint16(buf[6:8], syscall.NLM_F_REQUEST|syscall.NLM_F_DUMP)
nativeEndian.PutUint32(buf[8:12], 0)
nativeEndian.PutUint32(buf[12:16], 0)
buf[16] = family
buf[17] = protocol
buf[18] = 0
buf[19] = 0
nativeEndian.PutUint32(buf[20:24], 0xFFFFFFFF)
binary.BigEndian.PutUint16(buf[24:26], sourcePort)
binary.BigEndian.PutUint16(buf[26:28], 0)
copy(buf[28:44], s)
copy(buf[44:60], net.IPv6zero)
nativeEndian.PutUint32(buf[60:64], 0)
nativeEndian.PutUint64(buf[64:72], 0xFFFFFFFFFFFFFFFF)
</s> add for _, msg := range messages {
if len(msg.Data) < inetDiagResponseSize {
continue
} </s> remove inode, uid := unpackSocketDiagResponse(&messages[0])
if inode < 0 || uid < 0 {
return 0, 0, fmt.Errorf("invalid inode(%d) or uid(%d)", inode, uid)
}
return inode, uid, nil
}
func packSocketDiagRequest(family, protocol byte, source net.IP, sourcePort uint16) []byte {
s := make([]byte, 16)
if v4 := source.To4(); v4 != nil {
copy(s, v4)
} else {
copy(s, source)
</s> add messages, err := conn.Execute(message)
if err != nil {
return 0, 0, err </s> remove
message := messages[0]
if message.Header.Type&syscall.NLMSG_ERROR != 0 {
return 0, 0, fmt.Errorf("netlink message: NLMSG_ERROR")
</s> add defer conn.Close()
message := netlink.Message{
Header: netlink.Header{
Type: SOCK_DIAG_BY_FAMILY,
Flags: netlink.Request | netlink.Dump,
},
Data: (*(*[inetDiagRequestSize]byte)(unsafe.Pointer(request)))[:], | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= | <mask> golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20210525143221-35b2ab0089ea/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
</s> Refactor: linux process resolving (#2305) </s> remove "github.com/Dreamacro/clash/common/pool"
</s> add "github.com/mdlayher/netlink"
"golang.org/x/sys/unix" </s> remove // from https://github.com/vishvananda/netlink/blob/bca67dfc8220b44ef582c9da4e9172bf1c9ec973/nl/nl_linux.go#L52-L62
var nativeEndian = func() binary.ByteOrder {
var x uint32 = 0x01020304
if *(*byte)(unsafe.Pointer(&x)) == 0x01 {
return binary.BigEndian
}
return binary.LittleEndian
}()
</s> add </s> remove sizeOfSocketDiagRequest = syscall.SizeofNlMsghdr + 8 + 48
socketDiagByFamily = 20
pathProc = "/proc"
</s> add SOCK_DIAG_BY_FAMILY = 20
inetDiagRequestSize = int(unsafe.Sizeof(inetDiagRequest{}))
inetDiagResponseSize = int(unsafe.Sizeof(inetDiagResponse{})) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= | <mask> golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64 h1:UiNENfZ8gDvpiWw7IpOMQ27spWmThO1RwwdQVbJahJM=
<mask> golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
<mask> golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
<mask> golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
</s> Refactor: linux process resolving (#2305) </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= | <mask> golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
<mask> golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
<mask> golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
<mask> golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
<mask> golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
</s> Refactor: linux process resolving (#2305) </s> remove req := packSocketDiagRequest(family, protocol, ip, uint16(srcPort))
socket, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_INET_DIAG)
if err != nil {
return 0, 0, fmt.Errorf("dial netlink: %w", err)
}
defer syscall.Close(socket)
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &syscall.Timeval{Usec: 100})
syscall.SetsockoptTimeval(socket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &syscall.Timeval{Usec: 100})
if err := syscall.Connect(socket, &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Pad: 0,
Pid: 0,
Groups: 0,
}); err != nil {
return 0, 0, err
</s> add if strings.HasPrefix(network, "tcp") {
request.Protocol = unix.IPPROTO_TCP
} else if strings.HasPrefix(network, "udp") {
request.Protocol = unix.IPPROTO_UDP
} else {
return 0, 0, ErrInvalidNetwork | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6995e9818177d65e9da7964168fc489ad0ed549d | go.sum |
conn := N.NewBufferedConn(c) | <mask> func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
<mask> client := newClient(c.RemoteAddr(), in)
<mask> defer client.CloseIdleConnections()
<mask>
<mask> var conn *N.BufferedConn
<mask> if bufConn, ok := c.(*N.BufferedConn); ok {
<mask> conn = bufConn
<mask> } else {
<mask> conn = N.NewBufferedConn(c)
<mask> }
<mask>
<mask> keepAlive := true
<mask> trusted := cache == nil // disable authenticate if cache is nil
<mask>
<mask> for keepAlive {
</s> Fix: http proxy Upgrade behavior (#2097) </s> remove relay(ctx.Conn(), outbound)
}
// relay copies between left and right bidirectionally.
func relay(leftConn, rightConn net.Conn) {
ch := make(chan error)
go func() {
buf := pool.Get(pool.RelayBufferSize)
// Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
leftConn.SetReadDeadline(time.Now())
ch <- err
}()
buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
rightConn.SetReadDeadline(time.Now())
<-ch
</s> add N.Relay(ctx.Conn(), outbound) </s> remove header.Del("Proxy-Connection")
header.Del("Proxy-Authenticate")
header.Del("Proxy-Authorization")
</s> add removeProxyHeaders(header)
</s> remove "io"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6a92c6af4e565a479681f219f794fc8b5df5c9a5 | listener/http/proxy.go |
if isUpgradeRequest(request) {
handleUpgrade(conn, request, in)
return // hijack connection
}
| <mask> }
<mask>
<mask> request.RequestURI = ""
<mask>
<mask> removeHopByHopHeaders(request.Header)
<mask> removeExtraHTTPHostPort(request)
<mask>
<mask> if request.URL.Scheme == "" || request.URL.Host == "" {
<mask> resp = responseWith(request, http.StatusBadRequest)
<mask> } else {
</s> Fix: http proxy Upgrade behavior (#2097) </s> remove var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
}
</s> add conn := N.NewBufferedConn(c) </s> remove relay(ctx.Conn(), outbound)
}
// relay copies between left and right bidirectionally.
func relay(leftConn, rightConn net.Conn) {
ch := make(chan error)
go func() {
buf := pool.Get(pool.RelayBufferSize)
// Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
leftConn.SetReadDeadline(time.Now())
ch <- err
}()
buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
rightConn.SetReadDeadline(time.Now())
<-ch
</s> add N.Relay(ctx.Conn(), outbound) </s> remove "io"
</s> add </s> remove header.Del("Proxy-Connection")
header.Del("Proxy-Authenticate")
header.Del("Proxy-Authorization")
</s> add removeProxyHeaders(header)
| [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6a92c6af4e565a479681f219f794fc8b5df5c9a5 | listener/http/proxy.go |
// removeHopByHopHeaders remove Proxy-* headers
func removeProxyHeaders(header http.Header) {
header.Del("Proxy-Connection")
header.Del("Proxy-Authenticate")
header.Del("Proxy-Authorization")
}
| <mask> "strings"
<mask> )
<mask>
<mask> // removeHopByHopHeaders remove hop-by-hop header
<mask> func removeHopByHopHeaders(header http.Header) {
<mask> // Strip hop-by-hop header based on RFC:
<mask> // http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.1
<mask> // https://www.mnot.net/blog/2011/07/11/what_proxies_must_do
</s> Fix: http proxy Upgrade behavior (#2097) </s> remove header.Del("Proxy-Connection")
header.Del("Proxy-Authenticate")
header.Del("Proxy-Authorization")
</s> add removeProxyHeaders(header)
</s> remove relay(ctx.Conn(), outbound)
}
// relay copies between left and right bidirectionally.
func relay(leftConn, rightConn net.Conn) {
ch := make(chan error)
go func() {
buf := pool.Get(pool.RelayBufferSize)
// Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
leftConn.SetReadDeadline(time.Now())
ch <- err
}()
buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
rightConn.SetReadDeadline(time.Now())
<-ch
</s> add N.Relay(ctx.Conn(), outbound) </s> remove var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
}
</s> add conn := N.NewBufferedConn(c) </s> remove "io"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6a92c6af4e565a479681f219f794fc8b5df5c9a5 | listener/http/utils.go |
removeProxyHeaders(header)
| <mask> // Strip hop-by-hop header based on RFC:
<mask> // http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.1
<mask> // https://www.mnot.net/blog/2011/07/11/what_proxies_must_do
<mask>
<mask> header.Del("Proxy-Connection")
<mask> header.Del("Proxy-Authenticate")
<mask> header.Del("Proxy-Authorization")
<mask> header.Del("TE")
<mask> header.Del("Trailers")
<mask> header.Del("Transfer-Encoding")
<mask> header.Del("Upgrade")
<mask>
</s> Fix: http proxy Upgrade behavior (#2097) </s> remove relay(ctx.Conn(), outbound)
}
// relay copies between left and right bidirectionally.
func relay(leftConn, rightConn net.Conn) {
ch := make(chan error)
go func() {
buf := pool.Get(pool.RelayBufferSize)
// Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
leftConn.SetReadDeadline(time.Now())
ch <- err
}()
buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
rightConn.SetReadDeadline(time.Now())
<-ch
</s> add N.Relay(ctx.Conn(), outbound) </s> remove var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
}
</s> add conn := N.NewBufferedConn(c) </s> remove "io"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6a92c6af4e565a479681f219f794fc8b5df5c9a5 | listener/http/utils.go |
<mask> package tunnel
<mask>
<mask> import (
<mask> "errors"
<mask> "io"
<mask> "net"
<mask> "time"
<mask>
<mask> N "github.com/Dreamacro/clash/common/net"
<mask> "github.com/Dreamacro/clash/common/pool"
</s> Fix: http proxy Upgrade behavior (#2097) </s> remove relay(ctx.Conn(), outbound)
}
// relay copies between left and right bidirectionally.
func relay(leftConn, rightConn net.Conn) {
ch := make(chan error)
go func() {
buf := pool.Get(pool.RelayBufferSize)
// Wrapping to avoid using *net.TCPConn.(ReadFrom)
// See also https://github.com/Dreamacro/clash/pull/1209
_, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf)
pool.Put(buf)
leftConn.SetReadDeadline(time.Now())
ch <- err
}()
buf := pool.Get(pool.RelayBufferSize)
io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf)
pool.Put(buf)
rightConn.SetReadDeadline(time.Now())
<-ch
</s> add N.Relay(ctx.Conn(), outbound) </s> remove header.Del("Proxy-Connection")
header.Del("Proxy-Authenticate")
header.Del("Proxy-Authorization")
</s> add removeProxyHeaders(header)
</s> remove var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
}
</s> add conn := N.NewBufferedConn(c) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6a92c6af4e565a479681f219f794fc8b5df5c9a5 | tunnel/connection.go | |
N.Relay(ctx.Conn(), outbound) | <mask> }
<mask> }
<mask>
<mask> func handleSocket(ctx C.ConnContext, outbound net.Conn) {
<mask> relay(ctx.Conn(), outbound)
<mask> }
<mask>
<mask> // relay copies between left and right bidirectionally.
<mask> func relay(leftConn, rightConn net.Conn) {
<mask> ch := make(chan error)
<mask>
<mask> go func() {
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> // Wrapping to avoid using *net.TCPConn.(ReadFrom)
<mask> // See also https://github.com/Dreamacro/clash/pull/1209
<mask> _, err := io.CopyBuffer(N.WriteOnlyWriter{Writer: leftConn}, N.ReadOnlyReader{Reader: rightConn}, buf)
<mask> pool.Put(buf)
<mask> leftConn.SetReadDeadline(time.Now())
<mask> ch <- err
<mask> }()
<mask>
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> io.CopyBuffer(N.WriteOnlyWriter{Writer: rightConn}, N.ReadOnlyReader{Reader: leftConn}, buf)
<mask> pool.Put(buf)
<mask> rightConn.SetReadDeadline(time.Now())
<mask> <-ch
<mask> }
</s> Fix: http proxy Upgrade behavior (#2097) </s> remove var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
}
</s> add conn := N.NewBufferedConn(c) </s> remove header.Del("Proxy-Connection")
header.Del("Proxy-Authenticate")
header.Del("Proxy-Authorization")
</s> add removeProxyHeaders(header)
</s> remove "io"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/6a92c6af4e565a479681f219f794fc8b5df5c9a5 | tunnel/connection.go |
// New creates an LruCache
func New(options ...Option) *LruCache { | <mask> staleReturn bool
<mask> onEvict EvictCallback
<mask> }
<mask>
<mask> // NewLRUCache creates an LruCache
<mask> func NewLRUCache(options ...Option) *LruCache {
<mask> lc := &LruCache{
<mask> lru: list.New(),
<mask> cache: make(map[any]*list.Element),
<mask> }
<mask>
</s> Chore: remove old cache implementation </s> remove cache *cache.Cache
</s> add cache *cache.LruCache </s> remove cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
</s> add cache: cache.New(cache.WithSize(options.Size * 2)), </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
</s> add c := New(WithAge(86400), WithUpdateAgeOnGet()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache.go |
c := New() | <mask> {"5", "five"},
<mask> }
<mask>
<mask> func TestLRUCache(t *testing.T) {
<mask> c := NewLRUCache()
<mask>
<mask> for _, e := range entries {
<mask> c.Set(e.key, e.value)
<mask> }
<mask>
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithSize(2))
</s> add c := New(WithSize(2)) </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove c := NewLRUCache(WithSize(1))
</s> add c := New(WithSize(1)) </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithAge(86400)) | <mask> }
<mask> }
<mask>
<mask> func TestLRUMaxAge(t *testing.T) {
<mask> c := NewLRUCache(WithAge(86400))
<mask>
<mask> now := time.Now().Unix()
<mask> expected := now + 86400
<mask>
<mask> // Add one expired entry
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
</s> add c := New(WithAge(86400), WithUpdateAgeOnGet()) </s> remove c := NewLRUCache(WithSize(2))
</s> add c := New(WithSize(2)) </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) </s> remove c := NewLRUCache(WithAge(1), WithStale(true))
</s> add c := New(WithAge(1), WithStale(true)) </s> remove c := NewLRUCache()
</s> add c := New() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithAge(86400), WithUpdateAgeOnGet()) | <mask> assert.Equal(t, c.lru.Len(), 0)
<mask> }
<mask>
<mask> func TestLRUpdateOnGet(t *testing.T) {
<mask> c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
<mask>
<mask> now := time.Now().Unix()
<mask> expires := now + 86400/2
<mask>
<mask> // Add one expired entry
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) </s> remove c := NewLRUCache(WithSize(2))
</s> add c := New(WithSize(2)) </s> remove c := NewLRUCache(WithAge(1), WithStale(true))
</s> add c := New(WithAge(1), WithStale(true)) </s> remove c := NewLRUCache(WithEvict(evict), WithSize(1))
</s> add c := New(WithEvict(evict), WithSize(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithSize(2)) | <mask> assert.True(t, c.lru.Back().Value.(*entry).expires > expires)
<mask> }
<mask>
<mask> func TestMaxSize(t *testing.T) {
<mask> c := NewLRUCache(WithSize(2))
<mask> // Add one expired entry
<mask> c.Set("foo", "bar")
<mask> _, ok := c.Get("foo")
<mask> assert.True(t, ok)
<mask>
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
</s> add c := New(WithAge(86400), WithUpdateAgeOnGet()) </s> remove c := NewLRUCache(WithSize(1))
</s> add c := New(WithSize(1)) </s> remove c := NewLRUCache()
</s> add c := New() </s> remove o := NewLRUCache(WithSize(10))
</s> add o := New(WithSize(10)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithSize(1)) | <mask> assert.False(t, ok)
<mask> }
<mask>
<mask> func TestExist(t *testing.T) {
<mask> c := NewLRUCache(WithSize(1))
<mask> c.Set(1, 2)
<mask> assert.True(t, c.Exist(1))
<mask> c.Set(2, 3)
<mask> assert.False(t, c.Exist(1))
<mask> }
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithEvict(evict), WithSize(1))
</s> add c := New(WithEvict(evict), WithSize(1)) </s> remove c := NewLRUCache(WithSize(2))
</s> add c := New(WithSize(2)) </s> remove o := NewLRUCache(WithSize(10))
</s> add o := New(WithSize(10)) </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) </s> remove c := NewLRUCache()
</s> add c := New() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithEvict(evict), WithSize(1)) | <mask> evict := func(key any, value any) {
<mask> temp = key.(int) + value.(int)
<mask> }
<mask>
<mask> c := NewLRUCache(WithEvict(evict), WithSize(1))
<mask> c.Set(1, 2)
<mask> c.Set(2, 3)
<mask>
<mask> assert.Equal(t, temp, 3)
<mask> }
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithSize(1))
</s> add c := New(WithSize(1)) </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) </s> remove o := NewLRUCache(WithSize(10))
</s> add o := New(WithSize(10)) </s> remove c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
</s> add c := New(WithAge(86400), WithUpdateAgeOnGet()) </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithAge(1)) | <mask> assert.Equal(t, temp, 3)
<mask> }
<mask>
<mask> func TestSetWithExpire(t *testing.T) {
<mask> c := NewLRUCache(WithAge(1))
<mask> now := time.Now().Unix()
<mask>
<mask> tenSecBefore := time.Unix(now-10, 0)
<mask> c.SetWithExpire(1, 2, tenSecBefore)
<mask>
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithAge(1), WithStale(true))
</s> add c := New(WithAge(1), WithStale(true)) </s> remove c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
</s> add c := New(WithAge(86400), WithUpdateAgeOnGet()) </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove c := NewLRUCache(WithEvict(evict), WithSize(1))
</s> add c := New(WithEvict(evict), WithSize(1)) </s> remove o := NewLRUCache(WithSize(10))
</s> add o := New(WithSize(10)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
c := New(WithAge(1), WithStale(true)) | <mask> assert.Equal(t, false, exist)
<mask> }
<mask>
<mask> func TestStale(t *testing.T) {
<mask> c := NewLRUCache(WithAge(1), WithStale(true))
<mask> now := time.Now().Unix()
<mask>
<mask> tenSecBefore := time.Unix(now-10, 0)
<mask> c.SetWithExpire(1, 2, tenSecBefore)
<mask>
</s> Chore: remove old cache implementation </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) </s> remove c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
</s> add c := New(WithAge(86400), WithUpdateAgeOnGet()) </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove o := NewLRUCache(WithSize(10))
</s> add o := New(WithSize(10)) </s> remove c := NewLRUCache()
</s> add c := New() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
o := New(WithSize(10)) | <mask> assert.Equal(t, true, exist)
<mask> }
<mask>
<mask> func TestCloneTo(t *testing.T) {
<mask> o := NewLRUCache(WithSize(10))
<mask> o.Set("1", 1)
<mask> o.Set("2", 2)
<mask>
<mask> n := NewLRUCache(WithSize(2))
<mask> n.Set("3", 3)
</s> Chore: remove old cache implementation </s> remove n := NewLRUCache(WithSize(2))
</s> add n := New(WithSize(2)) </s> remove c := NewLRUCache(WithAge(1), WithStale(true))
</s> add c := New(WithAge(1), WithStale(true)) </s> remove c := NewLRUCache(WithSize(1))
</s> add c := New(WithSize(1)) </s> remove c := NewLRUCache(WithEvict(evict), WithSize(1))
</s> add c := New(WithEvict(evict), WithSize(1)) </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
n := New(WithSize(2)) | <mask> o := NewLRUCache(WithSize(10))
<mask> o.Set("1", 1)
<mask> o.Set("2", 2)
<mask>
<mask> n := NewLRUCache(WithSize(2))
<mask> n.Set("3", 3)
<mask> n.Set("4", 4)
<mask>
<mask> o.CloneTo(n)
<mask>
</s> Chore: remove old cache implementation </s> remove o := NewLRUCache(WithSize(10))
</s> add o := New(WithSize(10)) </s> remove c := NewLRUCache(WithEvict(evict), WithSize(1))
</s> add c := New(WithEvict(evict), WithSize(1)) </s> remove c := NewLRUCache(WithSize(1))
</s> add c := New(WithSize(1)) </s> remove c := NewLRUCache(WithSize(2))
</s> add c := New(WithSize(2)) </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | common/cache/lrucache_test.go |
cache: cache.New(cache.WithSize(options.Size * 2)), | <mask> cache: cachefile.Cache(),
<mask> }
<mask> } else {
<mask> pool.store = &memoryStore{
<mask> cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
<mask> }
<mask> }
<mask>
<mask> return pool, nil
<mask> }
</s> Chore: remove old cache implementation </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove // NewLRUCache creates an LruCache
func NewLRUCache(options ...Option) *LruCache {
</s> add // New creates an LruCache
func New(options ...Option) *LruCache { </s> remove c = cache.New(time.Second * 30)
</s> add c = cache.New(cache.WithAge(30)) </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | component/fakeip/pool.go |
mapping = cache.New(cache.WithSize(4096), cache.WithStale(true)) | <mask> var mapping *cache.LruCache
<mask>
<mask> if cfg.EnhancedMode != C.DNSNormal {
<mask> fakePool = cfg.Pool
<mask> mapping = cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true))
<mask> }
<mask>
<mask> return &ResolverEnhancer{
<mask> mode: cfg.EnhancedMode,
<mask> fakePool: fakePool,
</s> Chore: remove old cache implementation </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
</s> add lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)), </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { </s> remove c = cache.New(time.Second * 30)
</s> add c = cache.New(cache.WithAge(30)) </s> remove cache.Put(credential, authed, time.Minute)
</s> add cache.Set(credential, authed) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | dns/enhancer.go |
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)), | <mask>
<mask> func NewResolver(config Config) *Resolver {
<mask> defaultResolver := &Resolver{
<mask> main: transform(config.Default, nil),
<mask> lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
<mask> }
<mask>
<mask> r := &Resolver{
<mask> ipv6: config.IPv6,
<mask> main: transform(config.Main, defaultResolver),
</s> Chore: remove old cache implementation </s> remove lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
</s> add lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)), </s> remove c := NewLRUCache()
</s> add c := New() </s> remove c := NewLRUCache(WithAge(86400))
</s> add c := New(WithAge(86400)) </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | dns/resolver.go |
lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)), | <mask>
<mask> r := &Resolver{
<mask> ipv6: config.IPv6,
<mask> main: transform(config.Main, defaultResolver),
<mask> lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
<mask> hosts: config.Hosts,
<mask> }
<mask>
<mask> if len(config.Fallback) != 0 {
<mask> r.fallback = transform(config.Fallback, defaultResolver)
</s> Chore: remove old cache implementation </s> remove lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
</s> add lruCache: cache.New(cache.WithSize(4096), cache.WithStale(true)), </s> remove mapping = cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true))
</s> add mapping = cache.New(cache.WithSize(4096), cache.WithStale(true)) </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | dns/resolver.go |
<mask> "fmt"
<mask> "net"
<mask> "net/http"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapter/inbound"
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> N "github.com/Dreamacro/clash/common/net"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Chore: remove old cache implementation </s> remove "time"
</s> add </s> remove "time"
</s> add </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
</s> add cache: cache.New(cache.WithSize(options.Size * 2)), </s> remove c := NewLRUCache()
</s> add c := New() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/proxy.go | |
func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { | <mask> authStore "github.com/Dreamacro/clash/listener/auth"
<mask> "github.com/Dreamacro/clash/log"
<mask> )
<mask>
<mask> func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
<mask> client := newClient(c.RemoteAddr(), in)
<mask> defer client.CloseIdleConnections()
<mask>
<mask> conn := N.NewBufferedConn(c)
<mask>
</s> Chore: remove old cache implementation </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove cache *cache.Cache
</s> add cache *cache.LruCache </s> remove c := NewLRUCache()
</s> add c := New() </s> remove c := NewLRUCache(WithAge(1))
</s> add c := New(WithAge(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/proxy.go |
func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { | <mask>
<mask> conn.Close()
<mask> }
<mask>
<mask> func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
<mask> authenticator := authStore.Authenticator()
<mask> if authenticator != nil {
<mask> credential := parseBasicProxyAuthorization(request)
<mask> if credential == "" {
<mask> resp := responseWith(request, http.StatusProxyAuthRequired)
</s> Chore: remove old cache implementation </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { </s> remove cache.Put(credential, authed, time.Minute)
</s> add cache.Set(credential, authed) </s> remove func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/proxy.go |
authed, exist := cache.Get(credential)
if !exist { | <mask> resp.Header.Set("Proxy-Authenticate", "Basic")
<mask> return resp
<mask> }
<mask>
<mask> var authed any
<mask> if authed = cache.Get(credential); authed == nil {
<mask> user, pass, err := decodeBasicProxyAuthorization(credential)
<mask> authed = err == nil && authenticator.Verify(user, pass)
<mask> cache.Put(credential, authed, time.Minute)
<mask> }
<mask> if !authed.(bool) {
</s> Chore: remove old cache implementation </s> remove cache.Put(credential, authed, time.Minute)
</s> add cache.Set(credential, authed) </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/proxy.go |
cache.Set(credential, authed) | <mask> var authed any
<mask> if authed = cache.Get(credential); authed == nil {
<mask> user, pass, err := decodeBasicProxyAuthorization(credential)
<mask> authed = err == nil && authenticator.Verify(user, pass)
<mask> cache.Put(credential, authed, time.Minute)
<mask> }
<mask> if !authed.(bool) {
<mask> log.Infoln("Auth failed from %s", request.RemoteAddr)
<mask>
<mask> return responseWith(request, http.StatusForbidden)
</s> Chore: remove old cache implementation </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/proxy.go |
<mask> package http
<mask>
<mask> import (
<mask> "net"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
</s> Chore: remove old cache implementation </s> remove "time"
</s> add </s> remove "time"
</s> add </s> remove func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove n := NewLRUCache(WithSize(2))
</s> add n := New(WithSize(2)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/server.go | |
var c *cache.LruCache | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> var c *cache.Cache
<mask> if authenticate {
<mask> c = cache.New(time.Second * 30)
<mask> }
<mask>
<mask> hl := &Listener{
</s> Chore: remove old cache implementation </s> remove c = cache.New(time.Second * 30)
</s> add c = cache.New(cache.WithAge(30)) </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { </s> remove cache.Put(credential, authed, time.Minute)
</s> add cache.Set(credential, authed) </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/server.go |
c = cache.New(cache.WithAge(30)) | <mask> }
<mask>
<mask> var c *cache.Cache
<mask> if authenticate {
<mask> c = cache.New(time.Second * 30)
<mask> }
<mask>
<mask> hl := &Listener{
<mask> listener: l,
<mask> addr: addr,
</s> Chore: remove old cache implementation </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), </s> remove cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
</s> add cache: cache.New(cache.WithSize(options.Size * 2)), </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { </s> remove c := NewLRUCache(WithEvict(evict), WithSize(1))
</s> add c := New(WithEvict(evict), WithSize(1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/http/server.go |
<mask> package mixed
<mask>
<mask> import (
<mask> "net"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> N "github.com/Dreamacro/clash/common/net"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/listener/http"
</s> Chore: remove old cache implementation </s> remove "time"
</s> add </s> remove "time"
</s> add </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
</s> add cache: cache.New(cache.WithSize(options.Size * 2)), </s> remove c := NewLRUCache()
</s> add c := New() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/mixed/mixed.go | |
cache *cache.LruCache | <mask>
<mask> type Listener struct {
<mask> listener net.Listener
<mask> addr string
<mask> cache *cache.Cache
<mask> closed bool
<mask> }
<mask>
<mask> // RawAddress implements C.Listener
<mask> func (l *Listener) RawAddress() string {
</s> Chore: remove old cache implementation </s> remove // NewLRUCache creates an LruCache
func NewLRUCache(options ...Option) *LruCache {
</s> add // New creates an LruCache
func New(options ...Option) *LruCache { </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove var c *cache.Cache
</s> add var c *cache.LruCache | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/mixed/mixed.go |
cache: cache.New(cache.WithAge(30)), | <mask>
<mask> ml := &Listener{
<mask> listener: l,
<mask> addr: addr,
<mask> cache: cache.New(30 * time.Second),
<mask> }
<mask> go func() {
<mask> for {
<mask> c, err := ml.listener.Accept()
<mask> if err != nil {
</s> Chore: remove old cache implementation </s> remove c = cache.New(time.Second * 30)
</s> add c = cache.New(cache.WithAge(30)) </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { </s> remove cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
</s> add cache: cache.New(cache.WithSize(options.Size * 2)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/mixed/mixed.go |
func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { | <mask>
<mask> return ml, nil
<mask> }
<mask>
<mask> func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
<mask> conn.(*net.TCPConn).SetKeepAlive(true)
<mask>
<mask> bufConn := N.NewBufferedConn(conn)
<mask> head, err := bufConn.Peek(1)
<mask> if err != nil {
</s> Chore: remove old cache implementation </s> remove func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
</s> add func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache) { </s> remove var c *cache.Cache
</s> add var c *cache.LruCache </s> remove func authenticate(request *http.Request, cache *cache.Cache) *http.Response {
</s> add func authenticate(request *http.Request, cache *cache.LruCache) *http.Response { </s> remove cache: cache.New(30 * time.Second),
</s> add cache: cache.New(cache.WithAge(30)), </s> remove var authed any
if authed = cache.Get(credential); authed == nil {
</s> add authed, exist := cache.Get(credential)
if !exist { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6e058f8581ed69057fa7ef2749997fb6f5f73591 | listener/mixed/mixed.go |
IPSet | <mask> SrcPort
<mask> DstPort
<mask> Process
<mask> ProcessPath
<mask> MATCH
<mask> )
<mask>
<mask> type RuleType int
<mask>
</s> Feature: support IPSET rule (#2693) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | constant/rule.go |
case IPSet:
return "IPSet" | <mask> return "Process"
<mask> case ProcessPath:
<mask> return "ProcessPath"
<mask> case MATCH:
<mask> return "Match"
<mask> default:
<mask> return "Unknown"
</s> Feature: support IPSET rule (#2693) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | constant/rule.go |
github.com/vishvananda/netlink v1.2.1-beta.2.0.20230420174744-55c8b9515a01 | <mask> github.com/sirupsen/logrus v1.9.0
<mask> github.com/stretchr/testify v1.8.2
<mask> go.etcd.io/bbolt v1.3.7
<mask> go.uber.org/atomic v1.10.0
<mask> go.uber.org/automaxprocs v1.5.2
<mask> golang.org/x/crypto v0.8.0
</s> Feature: support IPSET rule (#2693) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | go.mod |
github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae // indirect | <mask> github.com/pmezard/go-difflib v1.0.0 // indirect
<mask> github.com/u-root/uio v0.0.0-20230220225925-ffce2a382923 // indirect
<mask> golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 // indirect
<mask> golang.org/x/mod v0.8.0 // indirect
<mask> golang.org/x/text v0.9.0 // indirect
<mask> golang.org/x/tools v0.6.0 // indirect
<mask> )
</s> Feature: support IPSET rule (#2693) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | go.mod |
github.com/vishvananda/netlink v1.2.1-beta.2.0.20230420174744-55c8b9515a01 h1:F9xjJm4IH8VjcqG4ujciOF+GIM4mjPkHhWLLzOghPtM=
github.com/vishvananda/netlink v1.2.1-beta.2.0.20230420174744-55c8b9515a01/go.mod h1:cAAsePK2e15YDAMJNyOpGYEWNe4sIghTY7gpz4cX/Ik=
github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae h1:4hwBBUfQCFe3Cym0ZtKyq7L16eZUtYKs+BaHDN6mAns=
github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0= | <mask> github.com/u-root/uio v0.0.0-20230220225925-ffce2a382923 h1:tHNk7XK9GkmKUR6Gh8gVBKXc2MVSZ4G/NnWLtzw4gNA=
<mask> github.com/u-root/uio v0.0.0-20230220225925-ffce2a382923/go.mod h1:eLL9Nub3yfAho7qB0MzZizFhTU2QkLeoVsWdHtDW264=
<mask> go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
<mask> go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
<mask> go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ=
<mask> go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
<mask> go.uber.org/automaxprocs v1.5.2 h1:2LxUOGiR3O6tw8ui5sZa2LAaHnsviZdVOUZw4fvbnME=
<mask> go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
</s> Feature: support IPSET rule (#2693) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | go.sum |
golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= | <mask> golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
<mask> golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
<mask> golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
<mask> golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
<mask> golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220804214406-8e32c043e418/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
<mask> golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
</s> Feature: support IPSET rule (#2693) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | go.sum |
golang.org/x/sys v0.0.0-20220804214406-8e32c043e418/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= | <mask> golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
<mask> golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
<mask> golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
<mask> golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
<mask> golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
<mask> golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
</s> Feature: support IPSET rule (#2693) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | go.sum |
case "IPSET":
noResolve := HasNoResolve(params)
parsed, parseErr = NewIPSet(payload, target, noResolve) | <mask> case "PROCESS-NAME":
<mask> parsed, parseErr = NewProcess(payload, target, true)
<mask> case "PROCESS-PATH":
<mask> parsed, parseErr = NewProcess(payload, target, false)
<mask> case "MATCH":
<mask> parsed = NewMatch(target)
<mask> default:
<mask> parseErr = fmt.Errorf("unsupported rule type %s", tp)
<mask> }
<mask>
</s> Feature: support IPSET rule (#2693) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6eee2269651f43eee548c70a7c6614b9a251a5cd | rule/parser.go |
func (d *Direct) Name() string {
return "Direct"
}
| <mask> }
<mask>
<mask> func (d *Direct) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", net.JoinHostPort(addr.String(), addr.Port))
<mask> if err != nil {
<mask> return
</s> Add: url-test proxy group support </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) </s> remove func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
</s> add func NewShadowSocks(name string, ssURL string) (*ShadowSocks, error) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | adapters/direct.go |
func (r *Reject) Name() string {
return "Reject"
}
| <mask>
<mask> type Reject struct {
<mask> }
<mask>
<mask> func (r *Reject) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> return &RejectAdapter{}, nil
<mask> }
<mask>
</s> Add: url-test proxy group support | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | adapters/reject.go |
name string | <mask> type ShadowSocks struct {
<mask> server string
<mask> cipher core.Cipher
<mask> }
<mask>
<mask> func (ss *ShadowSocks) Name() string {
<mask> return ss.name
</s> Add: url-test proxy group support | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | adapters/shadowsocks.go |
func (ss *ShadowSocks) Name() string {
return ss.name
}
| <mask> name string
<mask> cipher core.Cipher
<mask> }
<mask>
<mask> func (ss *ShadowSocks) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", ss.server)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error", ss.server)
<mask> }
<mask> c.(*net.TCPConn).SetKeepAlive(true)
</s> Add: url-test proxy group support </s> remove func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
</s> add func NewShadowSocks(name string, ssURL string) (*ShadowSocks, error) { </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | adapters/shadowsocks.go |
func NewShadowSocks(name string, ssURL string) (*ShadowSocks, error) { | <mask> _, err = c.Write(serializesSocksAddr(addr))
<mask> return &ShadowsocksAdapter{conn: c}, err
<mask> }
<mask>
<mask> func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
<mask> var key []byte
<mask> server, cipher, password, _ := parseURL(ssURL)
<mask> ciph, err := core.PickCipher(cipher, key, password)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error())
</s> Add: url-test proxy group support </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | adapters/shadowsocks.go |
name: name, | <mask> }
<mask> return &ShadowSocks{
<mask> server: server,
<mask> cipher: ciph,
<mask> }, nil
<mask> }
<mask>
<mask> func parseURL(s string) (addr, cipher, password string, err error) {
</s> Add: url-test proxy group support </s> remove func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
</s> add func NewShadowSocks(name string, ssURL string) (*ShadowSocks, error) { </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | adapters/shadowsocks.go |
Name() string | <mask> Close()
<mask> }
<mask>
<mask> type Proxy interface {
<mask> Generator(addr *Addr) (ProxyAdapter, error)
<mask> }
</s> Add: url-test proxy group support | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | constant/adapters.go |
"strconv" | <mask> package tunnel
<mask>
<mask> import (
<mask> "fmt"
<mask> "strings"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters"
</s> Add: url-test proxy group support </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | tunnel/tunnel.go |
"time" | <mask> "strconv"
<mask> "strings"
<mask> "sync"
<mask>
<mask> "github.com/Dreamacro/clash/adapters"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/observable"
</s> Add: url-test proxy group support </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | tunnel/tunnel.go |
groupsConfig := cfg.Section("Proxy Group") | <mask> proxysConfig := cfg.Section("Proxy")
<mask> rulesConfig := cfg.Section("Rule")
<mask>
<mask> // parse proxy
<mask> for _, key := range proxysConfig.Keys() {
<mask> proxy := strings.Split(key.Value(), ",")
</s> Add: url-test proxy group support </s> remove func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
</s> add func NewShadowSocks(name string, ssURL string) (*ShadowSocks, error) { </s> remove ss, err := adapters.NewShadowSocks(ssURL)
</s> add ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | tunnel/tunnel.go |
ss, err := adapters.NewShadowSocks(key.Name(), ssURL) | <mask> if len(proxy) < 5 {
<mask> continue
<mask> }
<mask> ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
<mask> ss, err := adapters.NewShadowSocks(ssURL)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> proxys[key.Name()] = ss
<mask> }
</s> Add: url-test proxy group support </s> remove func NewShadowSocks(ssURL string) (*ShadowSocks, error) {
</s> add func NewShadowSocks(name string, ssURL string) (*ShadowSocks, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/6ffbb7c89ef8831dcbab863c9a803a24379bf3db | tunnel/tunnel.go |
<mask> package gun
<mask>
<mask> import (
<mask> "bufio"
<mask> "bytes"
<mask> "crypto/tls"
<mask> "encoding/binary"
<mask> "errors"
<mask> "fmt"
<mask> "io"
</s> Improve: use one bytes.Buffer pool </s> remove "bytes"
</s> add </s> remove "bytes"
</s> add </s> remove "sync"
</s> add "github.com/Dreamacro/clash/common/pool" </s> remove "bytes"
</s> add </s> remove "math/rand"
"sync"
"github.com/Dreamacro/clash/common/pool"
</s> add "crypto/rand"
"io" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/gun/gun.go | |
"github.com/Dreamacro/clash/common/pool"
| <mask> "sync"
<mask> "time"
<mask>
<mask> "go.uber.org/atomic"
<mask> "golang.org/x/net/http2"
<mask> )
<mask>
<mask> var (
</s> Improve: use one bytes.Buffer pool </s> remove "math/rand"
"sync"
"github.com/Dreamacro/clash/common/pool"
</s> add "crypto/rand"
"io" </s> remove "sync"
</s> add "github.com/Dreamacro/clash/common/pool" </s> remove
bufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
endSignal = []byte{}
</s> add endSignal = []byte{} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/gun/gun.go |
<mask> defaultHeader = http.Header{
<mask> "content-type": []string{"application/grpc"},
<mask> "user-agent": []string{"grpc-go/1.36.0"},
<mask> }
<mask> bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
<mask> )
<mask>
<mask> type DialFn = func(network, addr string) (net.Conn, error)
<mask>
<mask> type Conn struct {
</s> Improve: use one bytes.Buffer pool </s> remove bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
endSignal = []byte{}
</s> add endSignal = []byte{} </s> remove "github.com/Dreamacro/clash/transport/ssr/tools"
</s> add </s> remove
bufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove var BufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove randBytes := pool.Get(length)
defer pool.Put(randBytes)
rand.Read(randBytes)
b.Write(randBytes)
</s> add b.ReadFrom(io.LimitReader(rand.Reader, int64(length))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/gun/gun.go | |
buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | <mask> grpcHeader := make([]byte, 5)
<mask> grpcPayloadLen := uint32(varuintSize + 1 + len(b))
<mask> binary.BigEndian.PutUint32(grpcHeader[1:5], grpcPayloadLen)
<mask>
<mask> buf := bufferPool.Get().(*bytes.Buffer)
<mask> defer bufferPool.Put(buf)
<mask> defer buf.Reset()
<mask> buf.Write(grpcHeader)
<mask> buf.Write(protobufHeader[:varuintSize+1])
<mask> buf.Write(b)
<mask>
<mask> _, err = g.writer.Write(buf.Bytes())
</s> Improve: use one bytes.Buffer pool </s> remove buf := &bytes.Buffer{}
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := bufferPool.Get().(*bytes.Buffer)
buf.Reset()
defer bufferPool.Put(buf)
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/gun/gun.go |
buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | <mask> to.firstRequest = false
<mask> return len(b), err
<mask> }
<mask>
<mask> buf := &bytes.Buffer{}
<mask> buf.Write([]byte{0x17, 0x03, 0x03})
<mask> binary.Write(buf, binary.BigEndian, uint16(len(b)))
<mask> buf.Write(b)
<mask> _, err := to.Conn.Write(buf.Bytes())
<mask> return len(b), err
</s> Improve: use one bytes.Buffer pool </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/simple-obfs/tls.go |
<mask> package snell
<mask>
<mask> import (
<mask> "bytes"
<mask> "encoding/binary"
<mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net"
</s> Improve: use one bytes.Buffer pool </s> remove "bytes"
</s> add </s> remove "bytes"
</s> add </s> remove "sync"
</s> add "github.com/Dreamacro/clash/common/pool" </s> remove "bytes"
</s> add </s> remove "math/rand"
"sync"
"github.com/Dreamacro/clash/common/pool"
</s> add "crypto/rand"
"io" | [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/snell/snell.go | |
"github.com/Dreamacro/clash/common/pool" | <mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "sync"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/shadowaead"
<mask> )
<mask>
<mask> const (
</s> Improve: use one bytes.Buffer pool </s> remove "bytes"
</s> add </s> remove "bytes"
</s> add </s> remove "math/rand"
"sync"
"github.com/Dreamacro/clash/common/pool"
</s> add "crypto/rand"
"io" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/snell/snell.go |
endSignal = []byte{} | <mask> Version byte = 1
<mask> )
<mask>
<mask> var (
<mask> bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
<mask> endSignal = []byte{}
<mask> )
<mask>
<mask> type Snell struct {
<mask> net.Conn
<mask> buffer [1]byte
</s> Improve: use one bytes.Buffer pool </s> remove
bufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove "math/rand"
"sync"
"github.com/Dreamacro/clash/common/pool"
</s> add "crypto/rand"
"io" </s> remove var BufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove "github.com/Dreamacro/clash/transport/ssr/tools"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/snell/snell.go |
buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | <mask> return 0, fmt.Errorf("server reported code: %d, message: %s", errcode, string(msg))
<mask> }
<mask>
<mask> func WriteHeader(conn net.Conn, host string, port uint, version int) error {
<mask> buf := bufferPool.Get().(*bytes.Buffer)
<mask> buf.Reset()
<mask> defer bufferPool.Put(buf)
<mask> buf.WriteByte(Version)
<mask> if version == Version2 {
<mask> buf.WriteByte(CommandConnectV2)
<mask> } else {
<mask> buf.WriteByte(CommandConnect)
</s> Improve: use one bytes.Buffer pool </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/snell/snell.go |
<mask> "strconv"
<mask> "strings"
<mask>
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/transport/ssr/tools"
<mask> )
<mask>
<mask> func init() {
<mask> register("http_simple", newHTTPSimple, 0)
<mask> }
</s> Improve: use one bytes.Buffer pool </s> remove "github.com/Dreamacro/clash/transport/ssr/tools"
</s> add </s> remove "github.com/Dreamacro/clash/transport/ssr/tools"
</s> add "github.com/Dreamacro/clash/common/pool" </s> remove "bytes"
</s> add </s> remove var BufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
</s> add </s> remove "math/rand"
"sync"
"github.com/Dreamacro/clash/common/pool"
</s> add "crypto/rand"
"io" | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/ssr/obfs/http_simple.go | |
buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | <mask> }
<mask> hosts := strings.Split(host, ",")
<mask> host = hosts[rand.Intn(len(hosts))]
<mask>
<mask> buf := tools.BufPool.Get().(*bytes.Buffer)
<mask> defer tools.BufPool.Put(buf)
<mask> defer buf.Reset()
<mask> if c.post {
<mask> buf.WriteString("POST /")
<mask> } else {
<mask> buf.WriteString("GET /")
<mask> }
</s> Improve: use one bytes.Buffer pool </s> remove buf := bufferPool.Get().(*bytes.Buffer)
buf.Reset()
defer bufferPool.Put(buf)
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/ssr/obfs/http_simple.go |
buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | <mask>
<mask> func (c *tls12TicketConn) Write(b []byte) (int, error) {
<mask> length := len(b)
<mask> if c.handshakeStatus == 8 {
<mask> buf := tools.BufPool.Get().(*bytes.Buffer)
<mask> defer tools.BufPool.Put(buf)
<mask> defer buf.Reset()
<mask> for len(b) > 2048 {
<mask> size := rand.Intn(4096) + 100
<mask> if len(b) < size {
<mask> size = len(b)
<mask> }
</s> Improve: use one bytes.Buffer pool </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove data := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(data)
defer data.Reset()
</s> add data := pool.GetBuffer()
defer pool.PutBuffer(data) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/ssr/obfs/tls1.2_ticket_auth.go |
data := pool.GetBuffer()
defer pool.PutBuffer(data) | <mask>
<mask> if c.handshakeStatus == 0 {
<mask> c.handshakeStatus = 1
<mask>
<mask> data := tools.BufPool.Get().(*bytes.Buffer)
<mask> defer tools.BufPool.Put(data)
<mask> defer data.Reset()
<mask>
<mask> data.Write([]byte{3, 3})
<mask> c.packAuthData(data)
<mask> data.WriteByte(0x20)
<mask> data.Write(c.clientID[:])
</s> Improve: use one bytes.Buffer pool </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := bufferPool.Get().(*bytes.Buffer)
buf.Reset()
defer bufferPool.Put(buf)
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/ssr/obfs/tls1.2_ticket_auth.go |
ext := pool.GetBuffer()
defer pool.PutBuffer(ext) | <mask> data.Write(c.clientID[:])
<mask> data.Write([]byte{0x00, 0x1c, 0xc0, 0x2b, 0xc0, 0x2f, 0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0x14, 0xcc, 0x13, 0xc0, 0x0a, 0xc0, 0x14, 0xc0, 0x09, 0xc0, 0x13, 0x00, 0x9c, 0x00, 0x35, 0x00, 0x2f, 0x00, 0x0a})
<mask> data.Write([]byte{0x1, 0x0})
<mask>
<mask> ext := tools.BufPool.Get().(*bytes.Buffer)
<mask> defer tools.BufPool.Put(ext)
<mask> defer ext.Reset()
<mask>
<mask> host := c.getHost()
<mask> ext.Write([]byte{0xff, 0x01, 0x00, 0x01, 0x00})
<mask> packSNIData(ext, host)
<mask> ext.Write([]byte{0, 0x17, 0, 0})
</s> Improve: use one bytes.Buffer pool </s> remove data := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(data)
defer data.Reset()
</s> add data := pool.GetBuffer()
defer pool.PutBuffer(data) </s> remove ret := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(ret)
defer ret.Reset()
</s> add ret := pool.GetBuffer()
defer pool.PutBuffer(ret) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/ssr/obfs/tls1.2_ticket_auth.go |
ret := pool.GetBuffer()
defer pool.PutBuffer(ret) | <mask>
<mask> binary.Write(data, binary.BigEndian, uint16(ext.Len()))
<mask> data.ReadFrom(ext)
<mask>
<mask> ret := tools.BufPool.Get().(*bytes.Buffer)
<mask> defer tools.BufPool.Put(ret)
<mask> defer ret.Reset()
<mask>
<mask> ret.Write([]byte{0x16, 3, 1})
<mask> binary.Write(ret, binary.BigEndian, uint16(data.Len()+4))
<mask> ret.Write([]byte{1, 0})
<mask> binary.Write(ret, binary.BigEndian, uint16(data.Len()))
</s> Improve: use one bytes.Buffer pool </s> remove buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := &bytes.Buffer{}
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove buf := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(buf)
defer buf.Reset()
</s> add buf := pool.GetBuffer()
defer pool.PutBuffer(buf) </s> remove ext := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(ext)
defer ext.Reset()
</s> add ext := pool.GetBuffer()
defer pool.PutBuffer(ext) </s> remove data := tools.BufPool.Get().(*bytes.Buffer)
defer tools.BufPool.Put(data)
defer data.Reset()
</s> add data := pool.GetBuffer()
defer pool.PutBuffer(data) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/70c8605cca3b9cba8598bad52d3bb6a36d77d032 | transport/ssr/obfs/tls1.2_ticket_auth.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.