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> ErrAddrNotFound = errors.New("addr not found")
<mask> ErrNetworkNotSupport = errors.New("network not support")
<mask> )
<mask>
<mask> func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
<mask> ipv4 := ip.To4() != nil
<mask>
<mask> for _, elm := range addrs {
<mask> addr, ok := elm.(*net.IPNet)
<mask> if !ok {
<mask> continue
<mask> }
<mask>
<mask> addrV4 := addr.IP.To4() != nil
<mask>
<mask> if addrV4 && ipv4 {
<mask> return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
<mask> } else if !addrV4 && !ipv4 {
<mask> return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
<mask> }
<mask> }
<mask>
<mask> return nil, ErrAddrNotFound
<mask> }
<mask>
<mask> func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
<mask> ipv4 := ip.To4() != nil
<mask>
<mask> for _, elm := range addrs {
<mask> addr, ok := elm.(*net.IPNet)
<mask> if !ok {
<mask> continue
<mask> }
<mask>
<mask> addrV4 := addr.IP.To4() != nil
<mask>
<mask> if addrV4 && ipv4 {
<mask> return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
<mask> } else if !addrV4 && !ipv4 {
<mask> return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
<mask> }
<mask> }
<mask>
<mask> return nil, ErrAddrNotFound
<mask> }
<mask>
<mask> func ListenPacketWithInterface(name string) ListenPacketHookFunc {
<mask> single := singledo.NewSingle(5 * time.Second)
<mask>
<mask> return func() (net.IP, error) {
<mask> elm, err, _ := single.Do(func() (interface{}, error) {
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove addrs := elm.([]net.Addr)
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok || addr.IP.To4() == nil {
continue
}
return addr.IP, nil
}
return nil, ErrAddrNotFound
</s> add return address, err </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove single := singledo.NewSingle(5 * time.Second)
</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/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go | |
return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) | <mask> return nil, ErrAddrNotFound
<mask> }
<mask>
<mask> func ListenPacketWithInterface(name string) ListenPacketHookFunc {
<mask> single := singledo.NewSingle(5 * time.Second)
<mask>
<mask> return func() (net.IP, error) {
<mask> elm, err, _ := single.Do(func() (interface{}, error) {
<mask> iface, err := net.InterfaceByName(name)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> addrs, err := iface.Addrs()
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> return addrs, nil
<mask> })
<mask>
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> addrs := elm.([]net.Addr)
<mask>
<mask> for _, elm := range addrs {
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove addrs := elm.([]net.Addr)
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok || addr.IP.To4() == nil {
continue
}
return addr.IP, nil
}
return nil, ErrAddrNotFound
</s> add return address, err </s> remove func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
</s> add </s> remove single := singledo.NewSingle(5 * time.Second)
</s> add </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
... | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go |
return address, err | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> addrs := elm.([]net.Addr)
<mask>
<mask> for _, elm := range addrs {
<mask> addr, ok := elm.(*net.IPNet)
<mask> if !ok || addr.IP.To4() == nil {
<mask> continue
<mask> }
<mask>
<mask> return addr.IP, nil
<mask> }
<mask>
<mask> return nil, ErrAddrNotFound
<mask> }
<mask> }
<mask>
<mask> func DialerWithInterface(name string) DialHookFunc {
<mask> single := singledo.NewSingle(5 * time.Second)
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
</s> add </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove single := singledo.NewSingle(5 * time.Second)
</s> add </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go |
<mask> }
<mask> }
<mask>
<mask> func DialerWithInterface(name string) DialHookFunc {
<mask> single := singledo.NewSingle(5 * time.Second)
<mask>
<mask> return func(dialer *net.Dialer, network string, ip net.IP) error {
<mask> elm, err, _ := single.Do(func() (interface{}, error) {
<mask> iface, err := net.InterfaceByName(name)
<mask> if err != nil {
<mask> return nil, err
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) </s> remove addrs := elm.([]net.Addr)
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok || addr.IP.To4() == nil {
continue
}
return addr.IP, nil
}
return nil, ErrAddrNotFound
</s> add return address, err </s> remove func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
</s> add </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go | |
err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) | <mask> func DialerWithInterface(name string) DialHookFunc {
<mask> single := singledo.NewSingle(5 * time.Second)
<mask>
<mask> return func(dialer *net.Dialer, network string, ip net.IP) error {
<mask> elm, err, _ := single.Do(func() (interface{}, error) {
<mask> iface, err := net.InterfaceByName(name)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> addrs, err := iface.Addrs()
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> return addrs, nil
<mask> })
<mask>
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> addrs := elm.([]net.Addr)
<mask>
<mask> switch network {
<mask> case "tcp", "tcp4", "tcp6":
<mask> if addr, err := lookupTCPAddr(ip, addrs); err == nil {
<mask> dialer.LocalAddr = addr
<mask> } else {
<mask> return err
<mask> }
<mask> case "udp", "udp4", "udp6":
<mask> if addr, err := lookupUDPAddr(ip, addrs); err == nil {
<mask> dialer.LocalAddr = addr
<mask> } else {
<mask> return err
<mask> }
<mask> }
<mask>
<mask> return nil
<mask> }
<mask> }
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove single := singledo.NewSingle(5 * time.Second)
return func() (net.IP, error) {
elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return nil, err
</s> add return func(lc *net.ListenConfig, address string) (string, error) {
err := bindIfaceToListenConfig(lc, name)
if err == errPlatformNotSupport {
address, err = fallbackBindToListenConfig(name) </s> remove single := singledo.NewSingle(5 * time.Second)
</s> add </s> remove addrs := elm.([]net.Addr)
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok || addr.IP.To4() == nil {
continue
}
return addr.IP, nil
}
return nil, ErrAddrNotFound
</s> add return address, err </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
ipv4 := ip.To4() != nil
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok {
continue
}
addrV4 := addr.IP.To4() != nil
if addrV4 && ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
} else if !addrV4 && !ipv4 {
return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
}
}
return nil, ErrAddrNotFound
}
</s> add | [
"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/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go |
return err | <mask> return err
<mask> }
<mask> }
<mask>
<mask> return nil
<mask> }
<mask> }
</s> Feature: use native syscall to bind interface on Linux and macOS </s> remove elm, err, _ := single.Do(func() (interface{}, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
return addrs, nil
})
if err != nil {
return err
}
addrs := elm.([]net.Addr)
switch network {
case "tcp", "tcp4", "tcp6":
if addr, err := lookupTCPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
case "udp", "udp4", "udp6":
if addr, err := lookupUDPAddr(ip, addrs); err == nil {
dialer.LocalAddr = addr
} else {
return err
}
</s> add err := bindIfaceToDialer(dialer, name)
if err == errPlatformNotSupport {
err = fallbackBindToDialer(dialer, network, ip, name) </s> remove func ListenConfig() (*net.ListenConfig, error) {
cfg := &net.ListenConfig{}
if ListenConfigHook != nil {
if err := ListenConfigHook(cfg); err != nil {
return nil, err
}
}
return cfg, nil
}
</s> add </s> remove addrs := elm.([]net.Addr)
for _, elm := range addrs {
addr, ok := elm.(*net.IPNet)
if !ok || addr.IP.To4() == nil {
continue
}
return addr.IP, nil
}
return nil, ErrAddrNotFound
</s> add return address, err </s> remove lc, err := ListenConfig()
if err != nil {
return nil, err
}
if ListenPacketHook != nil && address == "" {
ip, err := ListenPacketHook()
</s> add cfg := &net.ListenConfig{}
if ListenPacketHook != nil {
var err error
address, err = ListenPacketHook(cfg, address) </s> remove return lc.ListenPacket(context.Background(), network, address)
</s> add return cfg.ListenPacket(context.Background(), network, address) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/50b3d497f6ff89ac05aa7d648ced801c1d6b8a8e | component/dialer/hook.go |
shouldTCPIgnore := false
shouldUDPIgnore := false
| <mask> func ReCreateSocks(port int) error {
<mask> addr := genAddr(bindAddress, port, allowLan)
<mask>
<mask> if socksListener != nil {
<mask> if socksListener.Address() != addr {
<mask> socksListener.Close()
<mask> socksListener = nil
</s> Fix: hot recreate socks should ignore when receive same address | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/521a190b0f93a36e438a31ecd303342a43484ce0 | proxy/listener.go |
} else {
shouldTCPIgnore = true | <mask> if socksListener.Address() != addr {
<mask> socksListener.Close()
<mask> socksListener = nil
<mask> }
<mask> }
<mask>
<mask> if socksUDPListener != nil {
<mask> if socksUDPListener.Address() != addr {
<mask> socksUDPListener.Close()
</s> Fix: hot recreate socks should ignore when receive same address | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/521a190b0f93a36e438a31ecd303342a43484ce0 | proxy/listener.go |
} else {
shouldUDPIgnore = true | <mask> if socksUDPListener != nil {
<mask> if socksUDPListener.Address() != addr {
<mask> socksUDPListener.Close()
<mask> socksUDPListener = nil
<mask> }
<mask> }
<mask>
<mask> if shouldTCPIgnore && shouldUDPIgnore {
<mask> return nil
</s> Fix: hot recreate socks should ignore when receive same address | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/521a190b0f93a36e438a31ecd303342a43484ce0 | proxy/listener.go |
if shouldTCPIgnore && shouldUDPIgnore {
return nil
}
| <mask> }
<mask>
<mask> if portIsZero(addr) {
<mask> return nil
<mask> }
<mask>
</s> Fix: hot recreate socks should ignore when receive same address | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/521a190b0f93a36e438a31ecd303342a43484ce0 | proxy/listener.go |
authenticator := []string{}
if auth := authStore.Authenticator(); auth != nil {
authenticator = auth.Users()
}
general := &config.General{ | <mask> }
<mask>
<mask> func GetGeneral() *config.General {
<mask> ports := P.GetPorts()
<mask> return &config.General{
<mask> Port: ports.Port,
<mask> SocksPort: ports.SocksPort,
<mask> RedirPort: ports.RedirPort,
<mask> Authentication: authStore.Authenticator().Users(),
<mask> AllowLan: P.AllowLan(),
</s> Fix: crash when authenticator is nil </s> remove Authentication: authStore.Authenticator().Users(),
</s> add Authentication: authenticator, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53528f82753b389eadd99b60131cb7e3c84c4f92 | hub/executor/executor.go |
Authentication: authenticator, | <mask> return &config.General{
<mask> Port: ports.Port,
<mask> SocksPort: ports.SocksPort,
<mask> RedirPort: ports.RedirPort,
<mask> Authentication: authStore.Authenticator().Users(),
<mask> AllowLan: P.AllowLan(),
<mask> Mode: T.Instance().Mode(),
<mask> LogLevel: log.Level(),
<mask> }
<mask> }
</s> Fix: crash when authenticator is nil </s> remove return &config.General{
</s> add authenticator := []string{}
if auth := authStore.Authenticator(); auth != nil {
authenticator = auth.Users()
}
general := &config.General{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53528f82753b389eadd99b60131cb7e3c84c4f92 | hub/executor/executor.go |
return general | <mask> AllowLan: P.AllowLan(),
<mask> Mode: T.Instance().Mode(),
<mask> LogLevel: log.Level(),
<mask> }
<mask> }
<mask>
<mask> func updateExperimental(c *config.Experimental) {
<mask> T.Instance().UpdateExperimental(c.IgnoreResolveFail)
</s> Fix: crash when authenticator is nil </s> remove return &config.General{
</s> add authenticator := []string{}
if auth := authStore.Authenticator(); auth != nil {
authenticator = auth.Users()
}
general := &config.General{ </s> remove Authentication: authStore.Authenticator().Users(),
</s> add Authentication: authenticator, | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53528f82753b389eadd99b60131cb7e3c84c4f92 | hub/executor/executor.go |
bolt "go.etcd.io/bbolt" | <mask> "github.com/Dreamacro/clash/component/profile"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/log"
<mask> )
<mask>
<mask> var (
<mask> initOnce sync.Once
<mask> fileMode os.FileMode = 0666
</s> Change: use bbolt as cache db </s> remove )
</s> add </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB </s> remove }
c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
model.Selected[group] = selected
c.buf.Reset()
if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
</s> add } else if c.db == nil { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
<mask> var (
<mask> initOnce sync.Once
<mask> fileMode os.FileMode = 0666
<mask> defaultCache *CacheFile
<mask> )
<mask>
<mask> type cache struct {
<mask> Selected map[string]string
<mask> }
<mask>
</s> Change: use bbolt as cache db </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) </s> remove initOnce.Do(func() {
defaultCache = &CacheFile{
path: C.Path.Cache(),
buf: &bytes.Buffer{},
}
})
</s> add initOnce.Do(migrateCache) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go | |
bucketSelected = []byte("selected")
) | <mask> fileMode os.FileMode = 0666
<mask> defaultCache *CacheFile
<mask> )
<mask>
<mask> type cache struct {
<mask> Selected map[string]string
<mask> }
<mask>
<mask> // CacheFile store and update the cache file
<mask> type CacheFile struct {
<mask> path string
<mask> model *cache
</s> Change: use bbolt as cache db </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB </s> remove )
</s> add </s> remove initOnce.Do(func() {
defaultCache = &CacheFile{
path: C.Path.Cache(),
buf: &bytes.Buffer{},
}
})
</s> add initOnce.Do(migrateCache) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
db *bolt.DB | <mask> }
<mask>
<mask> // CacheFile store and update the cache file
<mask> type CacheFile struct {
<mask> path string
<mask> model *cache
<mask> buf *bytes.Buffer
<mask> mux sync.Mutex
<mask> }
<mask>
<mask> func (c *CacheFile) SetSelected(group, selected string) {
<mask> if !profile.StoreSelected.Load() {
<mask> return
</s> Change: use bbolt as cache db </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) </s> remove }
c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
model.Selected[group] = selected
c.buf.Reset()
if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
</s> add } else if c.db == nil { </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
} else if c.db == nil { | <mask>
<mask> func (c *CacheFile) SetSelected(group, selected string) {
<mask> if !profile.StoreSelected.Load() {
<mask> return
<mask> }
<mask>
<mask> c.mux.Lock()
<mask> defer c.mux.Unlock()
<mask>
<mask> model := c.element()
<mask>
<mask> model.Selected[group] = selected
<mask> c.buf.Reset()
<mask> if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
<mask> log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
<mask> return
<mask> }
<mask>
<mask> if err := ioutil.WriteFile(c.path, c.buf.Bytes(), fileMode); err != nil {
<mask> log.Warnln("[CacheFile] write cache to %s failed: %s", c.path, err.Error())
</s> Change: use bbolt as cache db </s> remove if err := ioutil.WriteFile(c.path, c.buf.Bytes(), fileMode); err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.path, err.Error())
</s> add err := c.db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
return bucket.Put([]byte(group), []byte(selected))
})
if err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.db.Path(), err.Error()) </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
err := c.db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
return bucket.Put([]byte(group), []byte(selected))
})
if err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.db.Path(), err.Error()) | <mask> log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
<mask> return
<mask> }
<mask>
<mask> if err := ioutil.WriteFile(c.path, c.buf.Bytes(), fileMode); err != nil {
<mask> log.Warnln("[CacheFile] write cache to %s failed: %s", c.path, err.Error())
<mask> return
<mask> }
<mask> }
<mask>
<mask> func (c *CacheFile) SelectedMap() map[string]string {
</s> Change: use bbolt as cache db </s> remove }
c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
model.Selected[group] = selected
c.buf.Reset()
if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
</s> add } else if c.db == nil { </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove if buf, err := ioutil.ReadFile(c.path); err == nil {
bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
</s> add // write to new cache file
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
return </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
} else if c.db == nil {
return nil | <mask> if !profile.StoreSelected.Load() {
<mask> return nil
<mask> }
<mask>
<mask> mapping := map[string]string{}
<mask> c.db.View(func(t *bolt.Tx) error {
<mask> bucket := t.Bucket(bucketSelected)
<mask> if bucket == nil {
</s> Change: use bbolt as cache db </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) </s> remove c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
</s> add </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove }
c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
model.Selected[group] = selected
c.buf.Reset()
if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
</s> add } else if c.db == nil { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
<mask> if !profile.StoreSelected.Load() {
<mask> return nil
<mask> }
<mask>
<mask> c.mux.Lock()
<mask> defer c.mux.Unlock()
<mask>
<mask> model := c.element()
<mask>
<mask> mapping := map[string]string{}
<mask> for k, v := range model.Selected {
<mask> mapping[k] = v
<mask> }
<mask> return mapping
</s> Change: use bbolt as cache db </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) </s> remove }
c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
model.Selected[group] = selected
c.buf.Reset()
if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
</s> add } else if c.db == nil { </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go | |
c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) | <mask>
<mask> model := c.element()
<mask>
<mask> mapping := map[string]string{}
<mask> for k, v := range model.Selected {
<mask> mapping[k] = v
<mask> }
<mask> return mapping
<mask> }
<mask>
<mask> func (c *CacheFile) element() *cache {
<mask> if c.model != nil {
</s> Change: use bbolt as cache db </s> remove c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
</s> add </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return | <mask> }
<mask> return mapping
<mask> }
<mask>
<mask> func (c *CacheFile) element() *cache {
<mask> if c.model != nil {
<mask> return c.model
<mask> }
<mask>
<mask> model := &cache{
<mask> Selected: map[string]string{},
<mask> }
</s> Change: use bbolt as cache db </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) </s> remove if buf, err := ioutil.ReadFile(c.path); err == nil {
bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
</s> add // write to new cache file
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
return </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
defer os.Remove(C.Path.OldCache()) | <mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> // read old cache file
<mask> type cache struct {
<mask> Selected map[string]string
</s> Change: use bbolt as cache db </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) </s> remove )
</s> add </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB </s> remove if err := ioutil.WriteFile(c.path, c.buf.Bytes(), fileMode); err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.path, err.Error())
</s> add err := c.db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
return bucket.Put([]byte(group), []byte(selected))
})
if err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.db.Path(), err.Error()) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
// read old cache file
type cache struct {
Selected map[string]string
} | <mask> }
<mask> defer os.Remove(C.Path.OldCache())
<mask>
<mask> model := &cache{
<mask> Selected: map[string]string{},
<mask> }
<mask> bufReader := bytes.NewBuffer(buf)
</s> Change: use bbolt as cache db </s> remove if buf, err := ioutil.ReadFile(c.path); err == nil {
bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
</s> add // write to new cache file
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
return </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model) | <mask> }
<mask> model := &cache{
<mask> Selected: map[string]string{},
<mask> }
<mask>
<mask> // write to new cache file
<mask> db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
<mask> if err != nil {
</s> Change: use bbolt as cache db </s> remove if buf, err := ioutil.ReadFile(c.path); err == nil {
bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
</s> add // write to new cache file
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
return </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove if err := ioutil.WriteFile(c.path, c.buf.Bytes(), fileMode); err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.path, err.Error())
</s> add err := c.db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
return bucket.Put([]byte(group), []byte(selected))
})
if err != nil {
log.Warnln("[CacheFile] write cache to %s failed: %s", c.db.Path(), err.Error()) </s> remove }
c.mux.Lock()
defer c.mux.Unlock()
model := c.element()
model.Selected[group] = selected
c.buf.Reset()
if err := gob.NewEncoder(c.buf).Encode(model); err != nil {
log.Warnln("[CacheFile] encode gob failed: %s", err.Error())
</s> add } else if c.db == nil { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
// write to new cache file
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
return | <mask> model := &cache{
<mask> Selected: map[string]string{},
<mask> }
<mask>
<mask> if buf, err := ioutil.ReadFile(c.path); err == nil {
<mask> bufReader := bytes.NewBuffer(buf)
<mask> gob.NewDecoder(bufReader).Decode(model)
<mask> }
<mask>
<mask> c.model = model
<mask> return c.model
<mask> }
</s> Change: use bbolt as cache db </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) | <mask> if buf, err := ioutil.ReadFile(c.path); err == nil {
<mask> bufReader := bytes.NewBuffer(buf)
<mask> gob.NewDecoder(bufReader).Decode(model)
<mask> }
<mask>
<mask> c.model = model
<mask> return c.model
<mask> }
<mask>
<mask> // Cache return singleton of CacheFile
<mask> func Cache() *CacheFile {
<mask> initOnce.Do(func() {
</s> Change: use bbolt as cache db </s> remove initOnce.Do(func() {
defaultCache = &CacheFile{
path: C.Path.Cache(),
buf: &bytes.Buffer{},
}
})
</s> add initOnce.Do(migrateCache) </s> remove if buf, err := ioutil.ReadFile(c.path); err == nil {
bufReader := bytes.NewBuffer(buf)
gob.NewDecoder(bufReader).Decode(model)
</s> add // write to new cache file
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
return </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
initOnce.Do(migrateCache) | <mask> }
<mask>
<mask> // Cache return singleton of CacheFile
<mask> func Cache() *CacheFile {
<mask> initOnce.Do(func() {
<mask> defaultCache = &CacheFile{
<mask> path: C.Path.Cache(),
<mask> buf: &bytes.Buffer{},
<mask> }
<mask> })
<mask>
<mask> return defaultCache
<mask> }
</s> Change: use bbolt as cache db </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) </s> remove )
</s> add </s> remove func (p *path) Cache() string {
</s> add func (p *path) OldCache() string { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | component/profile/cachefile/cache.go |
func (p *path) OldCache() string { | <mask> func (p *path) MMDB() string {
<mask> return P.Join(p.homeDir, "Country.mmdb")
<mask> }
<mask>
<mask> func (p *path) Cache() string {
<mask> return P.Join(p.homeDir, ".cache")
<mask> }
</s> Change: use bbolt as cache db </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB </s> remove initOnce.Do(func() {
defaultCache = &CacheFile{
path: C.Path.Cache(),
buf: &bytes.Buffer{},
}
})
</s> add initOnce.Do(migrateCache) </s> remove
c.model = model
return c.model
</s> add defer db.Close()
db.Batch(func(t *bolt.Tx) error {
bucket, err := t.CreateBucketIfNotExists(bucketSelected)
if err != nil {
return err
}
for group, selected := range model.Selected {
if err := bucket.Put([]byte(group), []byte(selected)); err != nil {
return err
}
}
return nil
}) </s> remove func (c *CacheFile) element() *cache {
if c.model != nil {
return c.model
</s> add func (c *CacheFile) Close() error {
return c.db.Close()
}
func migrateCache() {
defer func() {
db, err := bolt.Open(C.Path.Cache(), fileMode, nil)
if err != nil {
log.Warnln("[CacheFile] can't open cache file: %s", err.Error())
}
defaultCache = &CacheFile{
db: db,
}
}()
buf, err := ioutil.ReadFile(C.Path.OldCache())
if err != nil {
return </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | constant/path.go |
go.etcd.io/bbolt v1.3.6 | <mask> github.com/oschwald/geoip2-golang v1.5.0
<mask> github.com/sirupsen/logrus v1.8.1
<mask> github.com/stretchr/testify v1.7.0
<mask> go.uber.org/atomic v1.9.0
<mask> golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
<mask> golang.org/x/net v0.0.0-20210903162142-ad29c8ab022f
<mask> golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
<mask> golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34
<mask> gopkg.in/yaml.v2 v2.4.0
</s> Change: use bbolt as cache db </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) </s> remove )
</s> add </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | go.mod |
go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= | <mask> github.com/u-root/uio v0.0.0-20210528114334-82958018845c h1:BFvcl34IGnw8yvJi8hlqLFo9EshRInwWBs2M5fGWzQA=
<mask> github.com/u-root/uio v0.0.0-20210528114334-82958018845c/go.mod h1:LpEX5FO/cB+WF4TYGY1V5qktpaZLkKkSegbr0V4eYXA=
<mask> go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
<mask> go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
<mask> golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
<mask> golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
<mask> golang.org/x/crypto v0.0.0-20210317152858-513c2a44f670/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
<mask> golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
</s> Change: use bbolt as cache db </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) </s> remove )
</s> add </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | go.sum |
golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= | <mask> golang.org/x/sys v0.0.0-20191224085550-c709ea063b76/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20201101102859-da207088b7d1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
<mask> golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
</s> Change: use bbolt as cache db </s> remove for k, v := range model.Selected {
mapping[k] = v
}
</s> add c.db.View(func(t *bolt.Tx) error {
bucket := t.Bucket(bucketSelected)
if bucket == nil {
return nil
}
c := bucket.Cursor()
for k, v := c.First(); k != nil; k, v = c.Next() {
mapping[string(k)] = string(v)
}
return nil
}) </s> remove )
</s> add </s> remove type cache struct {
Selected map[string]string
}
</s> add bucketSelected = []byte("selected")
) </s> remove path string
model *cache
buf *bytes.Buffer
mux sync.Mutex
</s> add db *bolt.DB | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/537b672fcf9917c51003291bc73145d6713520f2 | go.sum |
c, err := dialer.DialContext(ctx, "tcp", metadata.RemoteAddress()) | <mask> }
<mask>
<mask> // DialContext implements C.ProxyAdapter
<mask> func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> address := net.JoinHostPort(metadata.String(), metadata.DstPort)
<mask>
<mask> c, err := dialer.DialContext(ctx, "tcp", address)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> tcpKeepAlive(c)
<mask> return NewConn(c, d), nil
</s> Chore: logging remote port on request (#1494) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | adapter/outbound/direct.go |
log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) | <mask>
<mask> rawPc, err := proxy.DialUDP(metadata)
<mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
<mask> } else {
<mask> log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
<mask> }
<mask> return
<mask> }
</s> Chore: logging remote port on request (#1494) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove address := net.JoinHostPort(metadata.String(), metadata.DstPort)
c, err := dialer.DialContext(ctx, "tcp", address)
</s> add c, err := dialer.DialContext(ctx, "tcp", metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) | <mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
<mask> } else {
<mask> log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
<mask> }
<mask> return
<mask> }
<mask> ctx.InjectPacketConn(rawPc)
<mask> pc := statistic.NewUDPTracker(rawPc, statistic.DefaultManager, metadata, rule)
</s> Chore: logging remote port on request (#1494) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) </s> remove address := net.JoinHostPort(metadata.String(), metadata.DstPort)
c, err := dialer.DialContext(ctx, "tcp", address)
</s> add c, err := dialer.DialContext(ctx, "tcp", metadata.RemoteAddress()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) | <mask> pc := statistic.NewUDPTracker(rawPc, statistic.DefaultManager, metadata, rule)
<mask>
<mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) </s> remove log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) | <mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) </s> remove log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | <mask> log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask>
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) </s> remove log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | <mask> log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask>
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
<mask>
<mask> natTable.Set(key, pc)
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) </s> remove log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) | <mask>
<mask> remoteConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
<mask> } else {
<mask> log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
<mask> }
<mask> return
<mask> }
</s> Chore: logging remote port on request (#1494) </s> remove log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove address := net.JoinHostPort(metadata.String(), metadata.DstPort)
c, err := dialer.DialContext(ctx, "tcp", address)
</s> add c, err := dialer.DialContext(ctx, "tcp", metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) | <mask> if err != nil {
<mask> if rule == nil {
<mask> log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
<mask> } else {
<mask> log.Warnln("[TCP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
<mask> }
<mask> return
<mask> }
<mask> remoteConn = statistic.NewTCPTracker(remoteConn, statistic.DefaultManager, metadata, rule)
<mask> defer remoteConn.Close()
</s> Chore: logging remote port on request (#1494) </s> remove log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[TCP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s (match %s/%s) to %s error: %s", proxy.Name(), rule.RuleType().String(), rule.Payload(), metadata.RemoteAddress(), err.Error()) </s> remove log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.String(), err.Error())
</s> add log.Warnln("[UDP] dial %s to %s error: %s", proxy.Name(), metadata.RemoteAddress(), err.Error()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) </s> remove log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) | <mask> defer remoteConn.Close()
<mask>
<mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) | <mask> switch true {
<mask> case rule != nil:
<mask> log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) </s> remove log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String())
</s> add log.Infoln("[UDP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | <mask> log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
<mask> case mode == Global:
<mask> log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask>
<mask> handleSocket(ctx, remoteConn)
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) | <mask> log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
<mask> case mode == Direct:
<mask> log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> default:
<mask> log.Infoln("[TCP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
<mask> }
<mask>
<mask> handleSocket(ctx, remoteConn)
<mask> }
<mask>
</s> Chore: logging remote port on request (#1494) </s> remove log.Infoln("[TCP] %s --> %v using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[TCP] %s --> %v match %s(%s) using %s", metadata.SourceAddress(), metadata.String(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String())
</s> add log.Infoln("[TCP] %s --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) </s> remove log.Infoln("[UDP] %s --> %v doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) </s> remove log.Infoln("[UDP] %s --> %v using GLOBAL", metadata.SourceAddress(), metadata.String())
</s> add log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceAddress(), metadata.RemoteAddress()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/53e17a916bb08a042b610b256bf640327895bfa9 | tunnel/tunnel.go |
"net/netip" | <mask>
<mask> import (
<mask> "errors"
<mask> "net"
<mask> "time"
<mask>
<mask> N "github.com/Dreamacro/clash/common/net"
<mask> "github.com/Dreamacro/clash/common/pool"
</s> Fix: fakeip udp should not replace with another ip </s> remove "github.com/Dreamacro/clash/component/resolver"
</s> add </s> remove go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add oAddr, _ := netip.AddrFromSlice(metadata.DstIP)
oAddr = oAddr.Unmap()
go handleUDPToLocal(packet.UDPPacket, pc, key, oAddr, fAddr) </s> remove fAddr = metadata.UDPAddr()
</s> add fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/connection.go |
<mask> "time"
<mask>
<mask> N "github.com/Dreamacro/clash/common/net"
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/component/resolver"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) error {
<mask> defer packet.Drop()
</s> Fix: fakeip udp should not replace with another ip </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, fAddr net.Addr) {
</s> add func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, oAddr, fAddr netip.Addr) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/connection.go | |
<mask>
<mask> func handleUDPToRemote(packet C.UDPPacket, pc C.PacketConn, metadata *C.Metadata) error {
<mask> defer packet.Drop()
<mask>
<mask> // local resolve UDP dns
<mask> if !metadata.Resolved() {
<mask> ip, err := resolver.ResolveIP(metadata.Host)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> metadata.DstIP = ip
<mask> }
<mask>
<mask> addr := metadata.UDPAddr()
<mask> if addr == nil {
<mask> return errors.New("udp addr invalid")
<mask> }
<mask>
</s> Fix: fakeip udp should not replace with another ip </s> remove "github.com/Dreamacro/clash/component/resolver"
</s> add </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr </s> remove _, err = packet.WriteBack(buf[:n], from)
</s> add _, err = packet.WriteBack(buf[:n], fromUDPAddr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/connection.go | |
func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, oAddr, fAddr netip.Addr) { | <mask>
<mask> return nil
<mask> }
<mask>
<mask> func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, fAddr net.Addr) {
<mask> buf := pool.Get(pool.UDPBufferSize)
<mask> defer pool.Put(buf)
<mask> defer natTable.Delete(key)
<mask> defer pc.Close()
<mask>
</s> Fix: fakeip udp should not replace with another ip </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove "github.com/Dreamacro/clash/component/resolver"
</s> add </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/connection.go |
fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} | <mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> if fAddr != nil {
<mask> from = fAddr
<mask> }
<mask>
<mask> _, err = packet.WriteBack(buf[:n], from)
<mask> if err != nil {
<mask> return
</s> Fix: fakeip udp should not replace with another ip </s> remove _, err = packet.WriteBack(buf[:n], from)
</s> add _, err = packet.WriteBack(buf[:n], fromUDPAddr) </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove fAddr = metadata.UDPAddr()
</s> add fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/connection.go |
_, err = packet.WriteBack(buf[:n], fromUDPAddr) | <mask> if fAddr != nil {
<mask> from = fAddr
<mask> }
<mask>
<mask> _, err = packet.WriteBack(buf[:n], from)
<mask> if err != nil {
<mask> return
<mask> }
<mask> }
<mask> }
</s> Fix: fakeip udp should not replace with another ip </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove fAddr = metadata.UDPAddr()
</s> add fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/connection.go |
"net/netip" | <mask> "context"
<mask> "fmt"
<mask> "net"
<mask> "runtime"
<mask> "strconv"
<mask> "sync"
<mask> "time"
</s> Fix: fakeip udp should not replace with another ip </s> remove "github.com/Dreamacro/clash/component/resolver"
</s> add </s> remove go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
</s> add oAddr, _ := netip.AddrFromSlice(metadata.DstIP)
oAddr = oAddr.Unmap()
go handleUDPToLocal(packet.UDPPacket, pc, key, oAddr, fAddr) </s> remove fAddr = metadata.UDPAddr()
</s> add fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/tunnel.go |
var fAddr netip.Addr | <mask> return
<mask> }
<mask>
<mask> // make a fAddr if request ip is fakeip
<mask> var fAddr net.Addr
<mask> if resolver.IsExistFakeIP(metadata.DstIP) {
<mask> fAddr = metadata.UDPAddr()
<mask> }
<mask>
<mask> if err := preHandleMetadata(metadata); err != nil {
</s> Fix: fakeip udp should not replace with another ip </s> remove fAddr = metadata.UDPAddr()
</s> add fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove _, err = packet.WriteBack(buf[:n], from)
</s> add _, err = packet.WriteBack(buf[:n], fromUDPAddr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/tunnel.go |
fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() | <mask>
<mask> // make a fAddr if request ip is fakeip
<mask> var fAddr net.Addr
<mask> if resolver.IsExistFakeIP(metadata.DstIP) {
<mask> fAddr = metadata.UDPAddr()
<mask> }
<mask>
<mask> if err := preHandleMetadata(metadata); err != nil {
<mask> log.Debugln("[Metadata PreHandle] error: %s", err)
<mask> return
</s> Fix: fakeip udp should not replace with another ip </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove _, err = packet.WriteBack(buf[:n], from)
</s> add _, err = packet.WriteBack(buf[:n], fromUDPAddr) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/tunnel.go |
// local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return
}
metadata.DstIP = ip
}
| <mask> log.Debugln("[Metadata PreHandle] error: %s", err)
<mask> return
<mask> }
<mask>
<mask> key := packet.LocalAddr().String()
<mask>
<mask> handle := func() bool {
<mask> pc := natTable.Get(key)
<mask> if pc != nil {
</s> Fix: fakeip udp should not replace with another ip </s> remove fAddr = metadata.UDPAddr()
</s> add fAddr, _ = netip.AddrFromSlice(metadata.DstIP)
fAddr = fAddr.Unmap() </s> remove func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, fAddr net.Addr) {
</s> add func handleUDPToLocal(packet C.UDPPacket, pc net.PacketConn, key string, oAddr, fAddr netip.Addr) { </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/tunnel.go |
oAddr, _ := netip.AddrFromSlice(metadata.DstIP)
oAddr = oAddr.Unmap()
go handleUDPToLocal(packet.UDPPacket, pc, key, oAddr, fAddr) | <mask> default:
<mask> log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress())
<mask> }
<mask>
<mask> go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr)
<mask>
<mask> natTable.Set(key, pc)
<mask> handle()
<mask> }()
<mask> }
</s> Fix: fakeip udp should not replace with another ip </s> remove _, err = packet.WriteBack(buf[:n], from)
</s> add _, err = packet.WriteBack(buf[:n], fromUDPAddr) </s> remove if fAddr != nil {
from = fAddr
</s> add fromUDPAddr := from.(*net.UDPAddr)
if fAddr.IsValid() {
fromAddr, _ := netip.AddrFromSlice(fromUDPAddr.IP)
fromAddr.Unmap()
if oAddr == fromAddr {
fromUDPAddr.IP = fAddr.AsSlice()
} </s> remove // local resolve UDP dns
if !metadata.Resolved() {
ip, err := resolver.ResolveIP(metadata.Host)
if err != nil {
return err
}
metadata.DstIP = ip
}
</s> add </s> remove var fAddr net.Addr
</s> add var fAddr netip.Addr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/5497adaba1ff81be5225ebd0849964bba5b23987 | tunnel/tunnel.go |
// PatchFrom clone cache from old pool
func (p *Pool) PatchFrom(o *Pool) {
o.cache.CloneTo(p.cache)
}
| <mask> func (p *Pool) Gateway() net.IP {
<mask> return uintToIP(p.gateway)
<mask> }
<mask>
<mask> func (p *Pool) get(host string) net.IP {
<mask> current := p.offset
<mask> for {
<mask> p.offset = (p.offset + 1) % (p.max - p.min)
<mask> // Avoid infinite loops
<mask> if p.offset == current {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove // SetResolver set custom dns resolver for enhanced mode
func SetResolver(r *dns.Resolver) {
enhancedMode = r
}
</s> add </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | component/fakeip/pool.go |
"time" | <mask> import (
<mask> "net"
<mask> "strings"
<mask>
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> "github.com/Dreamacro/clash/component/fakeip"
<mask> "github.com/Dreamacro/clash/component/trie"
<mask> "github.com/Dreamacro/clash/log"
<mask>
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove "strings"
</s> add </s> remove "github.com/Dreamacro/clash/dns"
</s> add </s> remove tcpQueue = channels.NewInfiniteChannel()
udpQueue = channels.NewInfiniteChannel()
natTable = nat.New()
rules []C.Rule
proxies = make(map[string]C.Proxy)
providers map[string]provider.ProxyProvider
configMux sync.RWMutex
enhancedMode *dns.Resolver
</s> add tcpQueue = channels.NewInfiniteChannel()
udpQueue = channels.NewInfiniteChannel()
natTable = nat.New()
rules []C.Rule
proxies = make(map[string]C.Proxy)
providers map[string]provider.ProxyProvider
configMux sync.RWMutex </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
"github.com/Dreamacro/clash/common/cache" | <mask> "net"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/component/fakeip"
<mask> "github.com/Dreamacro/clash/component/trie"
<mask> "github.com/Dreamacro/clash/log"
<mask>
<mask> D "github.com/miekg/dns"
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove "strings"
</s> add </s> remove type handler func(w D.ResponseWriter, r *D.Msg)
</s> add type handler func(r *D.Msg) (*D.Msg, error) </s> remove "github.com/Dreamacro/clash/dns"
</s> add </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
type handler func(r *D.Msg) (*D.Msg, error) | <mask>
<mask> D "github.com/miekg/dns"
<mask> )
<mask>
<mask> type handler func(w D.ResponseWriter, r *D.Msg)
<mask> type middleware func(next handler) handler
<mask>
<mask> func withHosts(hosts *trie.DomainTrie) middleware {
<mask> return func(next handler) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return func(r *D.Msg) (*D.Msg, error) { | <mask> type middleware func(next handler) handler
<mask>
<mask> func withHosts(hosts *trie.DomainTrie) middleware {
<mask> return func(next handler) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask>
<mask> if !isIPRequest(q) {
<mask> next(w, r)
<mask> return
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove type handler func(w D.ResponseWriter, r *D.Msg)
</s> add type handler func(r *D.Msg) (*D.Msg, error) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return next(r) | <mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask>
<mask> if !isIPRequest(q) {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> record := hosts.Search(strings.TrimRight(q.Name, "."))
<mask> if record == nil {
<mask> next(w, r)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove next(w, r)
return
</s> add return next(r) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove next(w, r)
return
</s> add return next(r) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return next(r) | <mask> }
<mask>
<mask> record := hosts.Search(strings.TrimRight(q.Name, "."))
<mask> if record == nil {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> ip := record.Data.(net.IP)
<mask> msg := r.Copy()
<mask>
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove next(w, r)
return
</s> add return next(r) </s> remove } else if enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add } else if resolver.IsFakeIP(metadata.DstIP) { </s> remove next(w, r)
return
</s> add return next(r) </s> remove next(w, r)
return
</s> add return next(r) </s> remove if r.mapping || r.fakeip {
ips := r.msgToIP(msg)
for _, ip := range ips {
putMsgToCache(r.lruCache, ip.String(), msg)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return next(r) | <mask> rr.AAAA = v6
<mask>
<mask> msg.Answer = []D.RR{rr}
<mask> } else {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> msg.SetRcode(r, D.RcodeSuccess)
<mask> msg.Authoritative = true
<mask> msg.RecursionAvailable = true
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | <mask> msg.SetRcode(r, D.RcodeSuccess)
<mask> msg.Authoritative = true
<mask> msg.RecursionAvailable = true
<mask>
<mask> w.WriteMsg(msg)
<mask> }
<mask> }
<mask> }
<mask>
<mask> func withFakeIP(fakePool *fakeip.Pool) middleware {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return func(r *D.Msg) (*D.Msg, error) { | <mask> }
<mask>
<mask> func withFakeIP(fakePool *fakeip.Pool) middleware {
<mask> return func(next handler) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask>
<mask> if q.Qtype == D.TypeAAAA {
<mask> msg := &D.Msg{}
<mask> msg.Answer = []D.RR{}
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove type handler func(w D.ResponseWriter, r *D.Msg)
</s> add type handler func(r *D.Msg) (*D.Msg, error) </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return msg, nil | <mask> msg.SetRcode(r, D.RcodeSuccess)
<mask> msg.Authoritative = true
<mask> msg.RecursionAvailable = true
<mask>
<mask> w.WriteMsg(msg)
<mask> return
<mask> } else if q.Qtype != D.TypeA {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove D.HandleFailed(w, r)
return
</s> add return msg, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return next(r) | <mask>
<mask> w.WriteMsg(msg)
<mask> return
<mask> } else if q.Qtype != D.TypeA {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> host := strings.TrimRight(q.Name, ".")
<mask> if fakePool.LookupHost(host) {
<mask> next(w, r)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove next(w, r)
return
</s> add return next(r) </s> remove next(w, r)
return
</s> add return next(r) </s> remove s.handler(w, r)
</s> add msg, err := s.handler(r)
if err != nil {
D.HandleFailed(w, r)
return
}
w.WriteMsg(msg) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return next(r) | <mask> }
<mask>
<mask> host := strings.TrimRight(q.Name, ".")
<mask> if fakePool.LookupHost(host) {
<mask> next(w, r)
<mask> return
<mask> }
<mask>
<mask> rr := &D.A{}
<mask> rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
<mask> ip := fakePool.Lookup(host)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove next(w, r)
return
</s> add return next(r) </s> remove s.handler(w, r)
</s> add msg, err := s.handler(r)
if err != nil {
D.HandleFailed(w, r)
return
}
w.WriteMsg(msg) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return msg, nil | <mask> msg.SetRcode(r, D.RcodeSuccess)
<mask> msg.Authoritative = true
<mask> msg.RecursionAvailable = true
<mask>
<mask> w.WriteMsg(msg)
<mask> }
<mask> }
<mask> }
<mask>
<mask> func withResolver(resolver *Resolver) handler {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return func(r *D.Msg) (*D.Msg, error) { | <mask> }
<mask> }
<mask>
<mask> func withResolver(resolver *Resolver) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask>
<mask> // return a empty AAAA msg when ipv6 disabled
<mask> if !resolver.ipv6 && q.Qtype == D.TypeAAAA {
<mask> msg := &D.Msg{}
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove next(w, r)
return
</s> add return next(r) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove next(w, r)
return
</s> add return next(r) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return msg, nil | <mask> msg.SetRcode(r, D.RcodeSuccess)
<mask> msg.Authoritative = true
<mask> msg.RecursionAvailable = true
<mask>
<mask> w.WriteMsg(msg)
<mask> return
<mask> }
<mask>
<mask> msg, err := resolver.Exchange(r)
<mask> if err != nil {
<mask> log.Debugln("[DNS Server] Exchange %s failed: %v", q.String(), err)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove D.HandleFailed(w, r)
return
</s> add return msg, err </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove next(w, r)
return
</s> add return next(r) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return msg, err | <mask>
<mask> msg, err := resolver.Exchange(r)
<mask> if err != nil {
<mask> log.Debugln("[DNS Server] Exchange %s failed: %v", q.String(), err)
<mask> D.HandleFailed(w, r)
<mask> return
<mask> }
<mask> msg.SetRcode(r, msg.Rcode)
<mask> msg.Authoritative = true
<mask> w.WriteMsg(msg)
<mask> }
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove s.handler(w, r)
</s> add msg, err := s.handler(r)
if err != nil {
D.HandleFailed(w, r)
return
}
w.WriteMsg(msg) </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
return msg, nil | <mask> return
<mask> }
<mask> msg.SetRcode(r, msg.Rcode)
<mask> msg.Authoritative = true
<mask> w.WriteMsg(msg)
<mask> }
<mask> }
<mask>
<mask> func compose(middlewares []middleware, endpoint handler) handler {
<mask> length := len(middlewares)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove D.HandleFailed(w, r)
return
</s> add return msg, err </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
func newHandler(resolver *Resolver, mapper *ResolverEnhancer) handler { | <mask>
<mask> return h
<mask> }
<mask>
<mask> func newHandler(resolver *Resolver) handler {
<mask> middlewares := []middleware{}
<mask>
<mask> if resolver.hosts != nil {
<mask> middlewares = append(middlewares, withHosts(resolver.hosts))
<mask> }
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove if resolver.FakeIPEnabled() {
middlewares = append(middlewares, withFakeIP(resolver.pool))
</s> add if mapper.mode == FAKEIP {
middlewares = append(middlewares, withFakeIP(mapper.fakePool))
}
if mapper.mode != NORMAL {
middlewares = append(middlewares, withMapping(mapper.mapping)) </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
</s> add func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove w.WriteMsg(msg)
</s> add return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
if mapper.mode == FAKEIP {
middlewares = append(middlewares, withFakeIP(mapper.fakePool))
}
if mapper.mode != NORMAL {
middlewares = append(middlewares, withMapping(mapper.mapping)) | <mask> if resolver.hosts != nil {
<mask> middlewares = append(middlewares, withHosts(resolver.hosts))
<mask> }
<mask>
<mask> if resolver.FakeIPEnabled() {
<mask> middlewares = append(middlewares, withFakeIP(resolver.pool))
<mask> }
<mask>
<mask> return compose(middlewares, withResolver(resolver))
<mask> }
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove func newHandler(resolver *Resolver) handler {
</s> add func newHandler(resolver *Resolver, mapper *ResolverEnhancer) handler { </s> remove if enhancedMode.FakeIPEnabled() {
</s> add if resolver.FakeIPEnabled() { </s> remove } else if enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add } else if resolver.IsFakeIP(metadata.DstIP) { </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/middleware.go |
<mask> "errors"
<mask> "fmt"
<mask> "math/rand"
<mask> "net"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> "github.com/Dreamacro/clash/common/picker"
<mask> "github.com/Dreamacro/clash/component/fakeip"
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove next(w, r)
return
</s> add return next(r) </s> remove if resolver.FakeIPEnabled() {
middlewares = append(middlewares, withFakeIP(resolver.pool))
</s> add if mapper.mode == FAKEIP {
middlewares = append(middlewares, withFakeIP(mapper.fakePool))
}
if mapper.mode != NORMAL {
middlewares = append(middlewares, withMapping(mapper.mapping)) </s> remove func newHandler(resolver *Resolver) handler {
</s> add func newHandler(resolver *Resolver, mapper *ResolverEnhancer) handler { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go | |
<mask> }
<mask>
<mask> type Resolver struct {
<mask> ipv6 bool
<mask> mapping bool
<mask> fakeip bool
<mask> hosts *trie.DomainTrie
<mask> pool *fakeip.Pool
<mask> main []dnsClient
<mask> fallback []dnsClient
<mask> fallbackFilters []fallbackFilter
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove pool *fakeip.Pool
</s> add </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove func New(config Config) *Resolver {
</s> add func NewResolver(config Config) *Resolver { </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove type handler func(w D.ResponseWriter, r *D.Msg)
</s> add type handler func(r *D.Msg) (*D.Msg, error) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go | |
<mask> ipv6 bool
<mask> mapping bool
<mask> fakeip bool
<mask> hosts *trie.DomainTrie
<mask> pool *fakeip.Pool
<mask> main []dnsClient
<mask> fallback []dnsClient
<mask> fallbackFilters []fallbackFilter
<mask> group singleflight.Group
<mask> lruCache *cache.LruCache
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove mapping bool
fakeip bool
</s> add </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove func New(config Config) *Resolver {
</s> add func NewResolver(config Config) *Resolver { </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go | |
<mask>
<mask> msg := result.(*D.Msg)
<mask>
<mask> putMsgToCache(r.lruCache, q.String(), msg)
<mask> if r.mapping || r.fakeip {
<mask> ips := r.msgToIP(msg)
<mask> for _, ip := range ips {
<mask> putMsgToCache(r.lruCache, ip.String(), msg)
<mask> }
<mask> }
<mask> }()
<mask>
<mask> isIPReq := isIPRequest(q)
<mask> if isIPReq {
<mask> return r.fallbackExchange(m)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go | |
<mask>
<mask> return
<mask> }
<mask>
<mask> // IPToHost return fake-ip or redir-host mapping host
<mask> func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
<mask> if r.fakeip {
<mask> record, existed := r.pool.LookBack(ip)
<mask> if existed {
<mask> return record, true
<mask> }
<mask> }
<mask>
<mask> cache, _ := r.lruCache.Get(ip.String())
<mask> if cache == nil {
<mask> return "", false
<mask> }
<mask> fqdn := cache.(*D.Msg).Question[0].Name
<mask> return strings.TrimRight(fqdn, "."), true
<mask> }
<mask>
<mask> func (r *Resolver) IsMapping() bool {
<mask> return r.mapping
<mask> }
<mask>
<mask> // FakeIPEnabled returns if fake-ip is enabled
<mask> func (r *Resolver) FakeIPEnabled() bool {
<mask> return r.fakeip
<mask> }
<mask>
<mask> // IsFakeIP determine if given ip is a fake-ip
<mask> func (r *Resolver) IsFakeIP(ip net.IP) bool {
<mask> if r.FakeIPEnabled() {
<mask> return r.pool.Exist(ip)
<mask> }
<mask> return false
<mask> }
<mask>
<mask> // PatchCache overwrite lruCache to the new resolver
<mask> func (r *Resolver) PatchCache(n *Resolver) {
<mask> r.lruCache.CloneTo(n.lruCache)
<mask> }
<mask>
<mask> func (r *Resolver) batchExchange(clients []dnsClient, m *D.Msg) (msg *D.Msg, err error) {
<mask> fast, ctx := picker.WithTimeout(context.Background(), time.Second*5)
<mask> for _, client := range clients {
<mask> r := client
<mask> fast.Go(func() (interface{}, error) {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove if r.mapping || r.fakeip {
ips := r.msgToIP(msg)
for _, ip := range ips {
putMsgToCache(r.lruCache, ip.String(), msg)
}
}
</s> add </s> remove func newHandler(resolver *Resolver) handler {
</s> add func newHandler(resolver *Resolver, mapper *ResolverEnhancer) handler { | [
"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/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go | |
func NewResolver(config Config) *Resolver { | <mask> Pool *fakeip.Pool
<mask> Hosts *trie.DomainTrie
<mask> }
<mask>
<mask> func New(config Config) *Resolver {
<mask> defaultResolver := &Resolver{
<mask> main: transform(config.Default, nil),
<mask> lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
<mask> }
<mask>
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove mapping: config.EnhancedMode == MAPPING,
fakeip: config.EnhancedMode == FAKEIP,
pool: config.Pool,
</s> add </s> remove mapping bool
fakeip bool
</s> add </s> remove pool *fakeip.Pool
</s> add </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go |
<mask> r := &Resolver{
<mask> ipv6: config.IPv6,
<mask> main: transform(config.Main, defaultResolver),
<mask> lruCache: cache.NewLRUCache(cache.WithSize(4096), cache.WithStale(true)),
<mask> mapping: config.EnhancedMode == MAPPING,
<mask> fakeip: config.EnhancedMode == FAKEIP,
<mask> pool: config.Pool,
<mask> hosts: config.Hosts,
<mask> }
<mask>
<mask> if len(config.Fallback) != 0 {
<mask> r.fallback = transform(config.Fallback, defaultResolver)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove func New(config Config) *Resolver {
</s> add func NewResolver(config Config) *Resolver { </s> remove next(w, r)
return
</s> add return next(r) </s> remove if resolver.FakeIPEnabled() {
middlewares = append(middlewares, withFakeIP(resolver.pool))
</s> add if mapper.mode == FAKEIP {
middlewares = append(middlewares, withFakeIP(mapper.fakePool))
}
if mapper.mode != NORMAL {
middlewares = append(middlewares, withMapping(mapper.mapping)) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/resolver.go | |
msg, err := s.handler(r)
if err != nil {
D.HandleFailed(w, r)
return
}
w.WriteMsg(msg) | <mask> D.HandleFailed(w, r)
<mask> return
<mask> }
<mask>
<mask> s.handler(w, r)
<mask> }
<mask>
<mask> func (s *Server) setHandler(handler handler) {
<mask> s.handler = handler
<mask> }
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
</s> add func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { </s> remove D.HandleFailed(w, r)
return
</s> add return msg, err </s> remove w.WriteMsg(msg)
</s> add return msg, nil </s> remove next(w, r)
return
</s> add return next(r) </s> remove next(w, r)
return
</s> add return next(r) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/server.go |
func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { | <mask> func (s *Server) setHandler(handler handler) {
<mask> s.handler = handler
<mask> }
<mask>
<mask> func ReCreateServer(addr string, resolver *Resolver) error {
<mask> if addr == address && resolver != nil {
<mask> handler := newHandler(resolver)
<mask> server.setHandler(handler)
<mask> return nil
<mask> }
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove s.handler(w, r)
</s> add msg, err := s.handler(r)
if err != nil {
D.HandleFailed(w, r)
return
}
w.WriteMsg(msg) </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove func newHandler(resolver *Resolver) handler {
</s> add func newHandler(resolver *Resolver, mapper *ResolverEnhancer) handler { </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/server.go |
handler := newHandler(resolver, mapper) | <mask> }
<mask>
<mask> func ReCreateServer(addr string, resolver *Resolver) error {
<mask> if addr == address && resolver != nil {
<mask> handler := newHandler(resolver)
<mask> server.setHandler(handler)
<mask> return nil
<mask> }
<mask>
<mask> if server.Server != nil {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
</s> add func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove func newHandler(resolver *Resolver) handler {
</s> add func newHandler(resolver *Resolver, mapper *ResolverEnhancer) handler { </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/server.go |
handler := newHandler(resolver, mapper) | <mask> log.Warnln("Failed to Reuse UDP Address: %s", err)
<mask> }
<mask>
<mask> address = addr
<mask> handler := newHandler(resolver)
<mask> server = &Server{handler: handler}
<mask> server.Server = &D.Server{Addr: addr, PacketConn: p, Handler: server}
<mask>
<mask> go func() {
<mask> server.ActivateAndServe()
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
</s> add func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { </s> remove // SetResolver set custom dns resolver for enhanced mode
func SetResolver(r *dns.Resolver) {
enhancedMode = r
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | dns/server.go |
resolver.DefaultHostMapper = nil
dns.ReCreateServer("", nil, nil) | <mask>
<mask> func updateDNS(c *config.DNS) {
<mask> if !c.Enable {
<mask> resolver.DefaultResolver = nil
<mask> tunnel.SetResolver(nil)
<mask> dns.ReCreateServer("", nil)
<mask> return
<mask> }
<mask> r := dns.New(dns.Config{
<mask> Main: c.NameServer,
<mask> Fallback: c.Fallback,
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove r := dns.New(dns.Config{
</s> add cfg := dns.Config{ </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove next(w, r)
return
</s> add return next(r) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | hub/executor/executor.go |
cfg := dns.Config{ | <mask> tunnel.SetResolver(nil)
<mask> dns.ReCreateServer("", nil)
<mask> return
<mask> }
<mask> r := dns.New(dns.Config{
<mask> Main: c.NameServer,
<mask> Fallback: c.Fallback,
<mask> IPv6: c.IPv6,
<mask> EnhancedMode: c.EnhancedMode,
<mask> Pool: c.FakeIPRange,
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove tunnel.SetResolver(nil)
dns.ReCreateServer("", nil)
</s> add resolver.DefaultHostMapper = nil
dns.ReCreateServer("", nil, nil) </s> remove next(w, r)
return
</s> add return next(r) </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove return func(w D.ResponseWriter, r *D.Msg) {
</s> add return func(r *D.Msg) (*D.Msg, error) { </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | hub/executor/executor.go |
} | <mask> GeoIP: c.FallbackFilter.GeoIP,
<mask> IPCIDR: c.FallbackFilter.IPCIDR,
<mask> },
<mask> Default: c.DefaultNameserver,
<mask> })
<mask>
<mask> // reuse cache of old resolver
<mask> if resolver.DefaultResolver != nil {
<mask> if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
<mask> o.PatchCache(r)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
</s> add func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | hub/executor/executor.go |
r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) | <mask> },
<mask> Default: c.DefaultNameserver,
<mask> })
<mask>
<mask> // reuse cache of old resolver
<mask> if resolver.DefaultResolver != nil {
<mask> if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
<mask> o.PatchCache(r)
<mask> }
<mask> }
<mask>
<mask> resolver.DefaultResolver = r
<mask> tunnel.SetResolver(r)
<mask> if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove })
</s> add } </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { </s> remove tunnel.SetResolver(nil)
dns.ReCreateServer("", nil)
</s> add resolver.DefaultHostMapper = nil
dns.ReCreateServer("", nil, nil) </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | hub/executor/executor.go |
resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { | <mask> }
<mask> }
<mask>
<mask> resolver.DefaultResolver = r
<mask> tunnel.SetResolver(r)
<mask> if err := dns.ReCreateServer(c.Listen, r); err != nil {
<mask> log.Errorln("Start DNS server error: %s", err.Error())
<mask> return
<mask> }
<mask>
<mask> if c.Listen != "" {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { </s> remove s.handler(w, r)
</s> add msg, err := s.handler(r)
if err != nil {
D.HandleFailed(w, r)
return
}
w.WriteMsg(msg) </s> remove } else if enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add } else if resolver.IsFakeIP(metadata.DstIP) { </s> remove D.HandleFailed(w, r)
return
</s> add return msg, err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | hub/executor/executor.go |
<mask> "github.com/Dreamacro/clash/adapters/provider"
<mask> "github.com/Dreamacro/clash/component/nat"
<mask> "github.com/Dreamacro/clash/component/resolver"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/dns"
<mask> "github.com/Dreamacro/clash/log"
<mask>
<mask> channels "gopkg.in/eapache/channels.v1"
<mask> )
<mask>
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove tcpQueue = channels.NewInfiniteChannel()
udpQueue = channels.NewInfiniteChannel()
natTable = nat.New()
rules []C.Rule
proxies = make(map[string]C.Proxy)
providers map[string]provider.ProxyProvider
configMux sync.RWMutex
enhancedMode *dns.Resolver
</s> add tcpQueue = channels.NewInfiniteChannel()
udpQueue = channels.NewInfiniteChannel()
natTable = nat.New()
rules []C.Rule
proxies = make(map[string]C.Proxy)
providers map[string]provider.ProxyProvider
configMux sync.RWMutex </s> remove type handler func(w D.ResponseWriter, r *D.Msg)
</s> add type handler func(r *D.Msg) (*D.Msg, error) </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go | |
tcpQueue = channels.NewInfiniteChannel()
udpQueue = channels.NewInfiniteChannel()
natTable = nat.New()
rules []C.Rule
proxies = make(map[string]C.Proxy)
providers map[string]provider.ProxyProvider
configMux sync.RWMutex | <mask> channels "gopkg.in/eapache/channels.v1"
<mask> )
<mask>
<mask> var (
<mask> tcpQueue = channels.NewInfiniteChannel()
<mask> udpQueue = channels.NewInfiniteChannel()
<mask> natTable = nat.New()
<mask> rules []C.Rule
<mask> proxies = make(map[string]C.Proxy)
<mask> providers map[string]provider.ProxyProvider
<mask> configMux sync.RWMutex
<mask> enhancedMode *dns.Resolver
<mask>
<mask> // Outbound Rule
<mask> mode = Rule
<mask>
<mask> // default timeout for UDP session
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove // SetResolver set custom dns resolver for enhanced mode
func SetResolver(r *dns.Resolver) {
enhancedMode = r
}
</s> add </s> remove "github.com/Dreamacro/clash/dns"
</s> add </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go |
<mask> func SetMode(m TunnelMode) {
<mask> mode = m
<mask> }
<mask>
<mask> // SetResolver set custom dns resolver for enhanced mode
<mask> func SetResolver(r *dns.Resolver) {
<mask> enhancedMode = r
<mask> }
<mask>
<mask> // processUDP starts a loop to handle udp packet
<mask> func processUDP() {
<mask> queue := udpQueue.Out()
<mask> for elm := range queue {
<mask> conn := elm.(*inbound.PacketAdapter)
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove // IPToHost return fake-ip or redir-host mapping host
func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
if r.fakeip {
record, existed := r.pool.LookBack(ip)
if existed {
return record, true
}
}
cache, _ := r.lruCache.Get(ip.String())
if cache == nil {
return "", false
}
fqdn := cache.(*D.Msg).Question[0].Name
return strings.TrimRight(fqdn, "."), true
}
func (r *Resolver) IsMapping() bool {
return r.mapping
}
// FakeIPEnabled returns if fake-ip is enabled
func (r *Resolver) FakeIPEnabled() bool {
return r.fakeip
}
// IsFakeIP determine if given ip is a fake-ip
func (r *Resolver) IsFakeIP(ip net.IP) bool {
if r.FakeIPEnabled() {
return r.pool.Exist(ip)
}
return false
}
// PatchCache overwrite lruCache to the new resolver
func (r *Resolver) PatchCache(n *Resolver) {
r.lruCache.CloneTo(n.lruCache)
}
</s> add </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) </s> remove if r.mapping || r.fakeip {
ips := r.msgToIP(msg)
for _, ip := range ips {
putMsgToCache(r.lruCache, ip.String(), msg)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go | |
return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil | <mask> }
<mask> }
<mask>
<mask> func needLookupIP(metadata *C.Metadata) bool {
<mask> return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
<mask> }
<mask>
<mask> func preHandleMetadata(metadata *C.Metadata) error {
<mask> // handle IP string on host
<mask> if ip := net.ParseIP(metadata.Host); ip != nil {
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove handler := newHandler(resolver)
</s> add handler := newHandler(resolver, mapper) </s> remove if enhancedMode != nil && enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add if resolver.IsFakeIP(metadata.DstIP) { </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
</s> add func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) error { </s> remove if enhancedMode.FakeIPEnabled() {
</s> add if resolver.FakeIPEnabled() { </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go |
host, exist := resolver.FindHostByIP(metadata.DstIP) | <mask> }
<mask>
<mask> // preprocess enhanced-mode metadata
<mask> if needLookupIP(metadata) {
<mask> host, exist := enhancedMode.IPToHost(metadata.DstIP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if enhancedMode.FakeIPEnabled() {
<mask> metadata.DstIP = nil
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove if enhancedMode.FakeIPEnabled() {
</s> add if resolver.FakeIPEnabled() { </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove } else if enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add } else if resolver.IsFakeIP(metadata.DstIP) { </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go |
if resolver.FakeIPEnabled() { | <mask> host, exist := enhancedMode.IPToHost(metadata.DstIP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if enhancedMode.FakeIPEnabled() {
<mask> metadata.DstIP = nil
<mask> } else if node := resolver.DefaultHosts.Search(host); node != nil {
<mask> // redir-host should lookup the hosts
<mask> metadata.DstIP = node.Data.(net.IP)
<mask> }
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove host, exist := enhancedMode.IPToHost(metadata.DstIP)
</s> add host, exist := resolver.FindHostByIP(metadata.DstIP) </s> remove } else if enhancedMode.IsFakeIP(metadata.DstIP) {
</s> add } else if resolver.IsFakeIP(metadata.DstIP) { </s> remove return enhancedMode != nil && (enhancedMode.IsMapping() || enhancedMode.FakeIPEnabled()) && metadata.Host == "" && metadata.DstIP != nil
</s> add return resolver.MappingEnabled() && metadata.Host == "" && metadata.DstIP != nil </s> remove w.WriteMsg(msg)
</s> add return msg, nil
}
}
}
func withMapping(mapping *cache.LruCache) middleware {
return func(next handler) handler {
return func(r *D.Msg) (*D.Msg, error) {
q := r.Question[0]
if !isIPRequest(q) {
return next(r)
}
msg, err := next(r)
if err != nil {
return nil, err
}
host := strings.TrimRight(q.Name, ".")
for _, ans := range msg.Answer {
var ip net.IP
var ttl uint32
switch a := ans.(type) {
case *D.A:
ip = a.A
ttl = a.Hdr.Ttl
case *D.AAAA:
ip = a.AAAA
ttl = a.Hdr.Ttl
default:
continue
}
mapping.SetWithExpire(ip.String(), host, time.Now().Add(time.Second*time.Duration(ttl)))
}
return msg, nil </s> remove // reuse cache of old resolver
if resolver.DefaultResolver != nil {
if o, ok := resolver.DefaultResolver.(*dns.Resolver); ok {
o.PatchCache(r)
}
</s> add r := dns.NewResolver(cfg)
m := dns.NewEnhancer(cfg)
// reuse cache of old host mapper
if old := resolver.DefaultHostMapper; old != nil {
m.PatchFrom(old.(*dns.ResolverEnhancer)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go |
} else if resolver.IsFakeIP(metadata.DstIP) { | <mask> } else if node := resolver.DefaultHosts.Search(host); node != nil {
<mask> // redir-host should lookup the hosts
<mask> metadata.DstIP = node.Data.(net.IP)
<mask> }
<mask> } else if enhancedMode.IsFakeIP(metadata.DstIP) {
<mask> return fmt.Errorf("fake DNS record %s missing", metadata.DstIP)
<mask> }
<mask> }
<mask>
<mask> return nil
</s> Chore: split enhanced mode instance (#936)
Co-authored-by: Dreamacro <305009791@qq.com> </s> remove if enhancedMode.FakeIPEnabled() {
</s> add if resolver.FakeIPEnabled() { </s> remove w.WriteMsg(msg)
return
</s> add return msg, nil </s> remove tunnel.SetResolver(r)
if err := dns.ReCreateServer(c.Listen, r); err != nil {
</s> add resolver.DefaultHostMapper = m
if err := dns.ReCreateServer(c.Listen, r, m); err != nil { </s> remove next(w, r)
return
</s> add return next(r) </s> remove next(w, r)
return
</s> add return next(r) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/558ac6b96576e1c06d53219e022a5392048a99c5 | tunnel/tunnel.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.