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 |
|---|---|---|---|---|
"encoding/json" | <mask>
<mask> import (
<mask> "net"
<mask> )
<mask>
<mask> // Socks addr type
</s> Feature: add experimental connections API </s> remove NetWork NetWork
Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string
AddrType int
Host string
</s> add NetWork NetWork `json:"network"`
Type Type `json:"type"`
SrcIP net.IP `json:"sourceIP"`
DstIP net.IP `json:"destinationIP"`
SrcPort string `json:"sourcePort"`
DstPort string `json:"destinationPort"`
AddrType int `json:"-"`
Host string `json:"host"` </s> remove pc = rawPc
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | constant/metadata.go |
HTTPCONNECT | <mask> TCP NetWork = iota
<mask> UDP
<mask>
<mask> HTTP Type = iota
<mask> SOCKS
<mask> REDIR
<mask> )
<mask>
<mask> type NetWork int
<mask>
</s> Feature: add experimental connections API </s> remove NetWork NetWork
Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string
AddrType int
Host string
</s> add NetWork NetWork `json:"network"`
Type Type `json:"type"`
SrcIP net.IP `json:"sourceIP"`
DstIP net.IP `json:"destinationIP"`
SrcPort string `json:"sourcePort"`
DstPort string `json:"destinationPort"`
AddrType int `json:"-"`
Host string `json:"host"` </s> remove conn := newTrafficTrack(outbound, t.traffic)
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | constant/metadata.go |
func (n NetWork) MarshalJSON() ([]byte, error) {
return json.Marshal(n.String())
}
| <mask> }
<mask> return "udp"
<mask> }
<mask>
<mask> type Type int
<mask>
<mask> func (t Type) String() string {
<mask> switch t {
<mask> case HTTP:
<mask> return "HTTP"
</s> Feature: add experimental connections API </s> remove NetWork NetWork
Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string
AddrType int
Host string
</s> add NetWork NetWork `json:"network"`
Type Type `json:"type"`
SrcIP net.IP `json:"sourceIP"`
DstIP net.IP `json:"destinationIP"`
SrcPort string `json:"sourcePort"`
DstPort string `json:"destinationPort"`
AddrType int `json:"-"`
Host string `json:"host"` </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove return "MATCH"
</s> add return "Match" | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | constant/metadata.go |
NetWork NetWork `json:"network"`
Type Type `json:"type"`
SrcIP net.IP `json:"sourceIP"`
DstIP net.IP `json:"destinationIP"`
SrcPort string `json:"sourcePort"`
DstPort string `json:"destinationPort"`
AddrType int `json:"-"`
Host string `json:"host"` | <mask> type Type int
<mask>
<mask> // Metadata is used to store connection address
<mask> type Metadata struct {
<mask> NetWork NetWork
<mask> Type Type
<mask> SrcIP *net.IP
<mask> DstIP *net.IP
<mask> SrcPort string
<mask> DstPort string
<mask> AddrType int
<mask> Host string
<mask> }
<mask>
<mask> func (m *Metadata) RemoteAddress() string {
<mask> return net.JoinHostPort(m.String(), m.DstPort)
<mask> }
</s> Feature: add experimental connections API </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | constant/metadata.go |
return "GeoIP" | <mask> return "DomainSuffix"
<mask> case DomainKeyword:
<mask> return "DomainKeyword"
<mask> case GEOIP:
<mask> return "GEOIP"
<mask> case IPCIDR:
<mask> return "IPCIDR"
<mask> case SrcIPCIDR:
<mask> return "SrcIPCIDR"
<mask> case SrcPort:
</s> Feature: add experimental connections API </s> remove return "MATCH"
</s> add return "Match" </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return &ip, port, nil
</s> add return ip, port, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | constant/rule.go |
return "Match" | <mask> return "SrcPort"
<mask> case DstPort:
<mask> return "DstPort"
<mask> case MATCH:
<mask> return "MATCH"
<mask> default:
<mask> return "Unknown"
<mask> }
<mask> }
<mask>
</s> Feature: add experimental connections API </s> remove return "GEOIP"
</s> add return "GeoIP" </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return &ip, port, nil
</s> add return ip, port, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | constant/rule.go |
r.Mount("/connections", connectionRouter()) | <mask> r.Mount("/configs", configRouter())
<mask> r.Mount("/proxies", proxyRouter())
<mask> r.Mount("/rules", ruleRouter())
<mask> })
<mask>
<mask> if uiPath != "" {
<mask> r.Group(func(r chi.Router) {
</s> Feature: add experimental connections API </s> remove err := req.Write(conn)
</s> add err := req.Write(outbound) </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | hub/route/server.go |
t := T.DefaultManager | <mask> render.Status(r, http.StatusOK)
<mask> }
<mask>
<mask> tick := time.NewTicker(time.Second)
<mask> t := T.Instance().Traffic()
<mask> buf := &bytes.Buffer{}
<mask> var err error
<mask> for range tick.C {
<mask> buf.Reset()
<mask> up, down := t.Now()
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove outboundReeder := bufio.NewReader(conn)
</s> add outboundReeder := bufio.NewReader(outbound) </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) </s> remove err := req.Write(conn)
</s> add err := req.Write(outbound) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | hub/route/server.go |
record, _ := mmdb.Country(metadata.DstIP) | <mask> func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
<mask> if metadata.DstIP == nil {
<mask> return false
<mask> }
<mask> record, _ := mmdb.Country(*metadata.DstIP)
<mask> return record.Country.IsoCode == g.country
<mask> }
<mask>
<mask> func (g *GEOIP) Adapter() string {
<mask> return g.adapter
</s> Feature: add experimental connections API </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | rules/geoip.go |
return ip != nil && i.ipnet.Contains(ip) | <mask> ip := metadata.DstIP
<mask> if i.isSourceIP {
<mask> ip = metadata.SrcIP
<mask> }
<mask> return ip != nil && i.ipnet.Contains(*ip)
<mask> }
<mask>
<mask> func (i *IPCIDR) Adapter() string {
<mask> return i.adapter
<mask> }
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | rules/ipcidr.go |
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> )
<mask>
<mask> func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, outbound net.Conn) {
<mask> conn := newTrafficTrack(outbound, t.traffic)
<mask> req := request.R
<mask> host := req.Host
<mask>
<mask> inboundReeder := bufio.NewReader(request)
<mask> outboundReeder := bufio.NewReader(conn)
</s> Feature: add experimental connections API </s> remove outboundReeder := bufio.NewReader(conn)
</s> add outboundReeder := bufio.NewReader(outbound) </s> remove conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
</s> add relay(request, outbound) </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) </s> remove host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP)
</s> add host, exist := dns.DefaultResolver.IPToHost(metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/connection.go | |
outboundReeder := bufio.NewReader(outbound) | <mask> req := request.R
<mask> host := req.Host
<mask>
<mask> inboundReeder := bufio.NewReader(request)
<mask> outboundReeder := bufio.NewReader(conn)
<mask>
<mask> for {
<mask> keepAlive := strings.TrimSpace(strings.ToLower(req.Header.Get("Proxy-Connection"))) == "keep-alive"
<mask>
<mask> req.Header.Set("Connection", "close")
</s> Feature: add experimental connections API </s> remove conn := newTrafficTrack(outbound, t.traffic)
</s> add </s> remove err := req.Write(conn)
</s> add err := req.Write(outbound) </s> remove t := T.Instance().Traffic()
</s> add t := T.DefaultManager </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/connection.go |
err := req.Write(outbound) | <mask>
<mask> req.Header.Set("Connection", "close")
<mask> req.RequestURI = ""
<mask> adapters.RemoveHopByHopHeaders(req.Header)
<mask> err := req.Write(conn)
<mask> if err != nil {
<mask> break
<mask> }
<mask>
<mask> handleResponse:
</s> Feature: add experimental connections API </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove outboundReeder := bufio.NewReader(conn)
</s> add outboundReeder := bufio.NewReader(outbound) </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/connection.go |
DefaultManager.Upload() <- int64(n) | <mask> }
<mask> if _, err = pc.WriteTo(buf[:n], addr); err != nil {
<mask> return
<mask> }
<mask> t.traffic.Up() <- int64(n)
<mask> }
<mask>
<mask> func (t *Tunnel) handleUDPToLocal(conn net.Conn, pc net.PacketConn, key string, timeout time.Duration) {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> defer pool.BufPool.Put(buf[:cap(buf)])
</s> Feature: add experimental connections API </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add </s> remove err := req.Write(conn)
</s> add err := req.Write(outbound) </s> remove t := T.Instance().Traffic()
</s> add t := T.DefaultManager | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/connection.go |
DefaultManager.Download() <- int64(n) | <mask> n, err = conn.Write(buf[:n])
<mask> if err != nil {
<mask> return
<mask> }
<mask> t.traffic.Down() <- int64(n)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
<mask> conn := newTrafficTrack(outbound, t.traffic)
</s> Feature: add experimental connections API </s> remove conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
</s> add relay(request, outbound) </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) </s> remove conn := newTrafficTrack(outbound, t.traffic)
</s> add </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/connection.go |
relay(request, outbound) | <mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
<mask> conn := newTrafficTrack(outbound, t.traffic)
<mask> relay(request, conn)
<mask> }
<mask>
<mask> // relay copies between left and right bidirectionally.
<mask> func relay(leftConn, rightConn net.Conn) {
<mask> ch := make(chan error)
</s> Feature: add experimental connections API </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) </s> remove conn := newTrafficTrack(outbound, t.traffic)
</s> add </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/connection.go |
configMux sync.RWMutex | <mask> udpQueue *channels.InfiniteChannel
<mask> natTable *nat.Table
<mask> rules []C.Rule
<mask> proxies map[string]C.Proxy
<mask> configMux *sync.RWMutex
<mask> traffic *C.Traffic
<mask>
<mask> // experimental features
<mask> ignoreResolveFail bool
<mask>
<mask> // Outbound Rule
</s> Feature: add experimental connections API </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
<mask> t.udpQueue.In() <- req
<mask> }
<mask> }
<mask>
<mask> // Traffic return traffic of all connections
<mask> func (t *Tunnel) Traffic() *C.Traffic {
<mask> return t.traffic
<mask> }
<mask>
<mask> // Rules return all rules
<mask> func (t *Tunnel) Rules() []C.Rule {
<mask> return t.rules
<mask> }
<mask>
</s> Feature: add experimental connections API </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) </s> remove configMux *sync.RWMutex
traffic *C.Traffic
</s> add configMux sync.RWMutex </s> remove conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
</s> add relay(request, outbound) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go | |
host, exist := dns.DefaultResolver.IPToHost(metadata.DstIP) | <mask>
<mask> func (t *Tunnel) resolveMetadata(metadata *C.Metadata) (C.Proxy, C.Rule, error) {
<mask> // preprocess enhanced-mode metadata
<mask> if t.needLookupIP(metadata) {
<mask> host, exist := dns.DefaultResolver.IPToHost(*metadata.DstIP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if dns.DefaultResolver.IsFakeIP() {
<mask> metadata.DstIP = nil
</s> Feature: add experimental connections API </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove conn := newTrafficTrack(outbound, t.traffic)
relay(request, conn)
</s> add relay(request, outbound) </s> remove conn := newTrafficTrack(outbound, t.traffic)
</s> add </s> remove t.traffic.Down() <- int64(n)
</s> add DefaultManager.Download() <- int64(n) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
<mask> t.natTable.Delete(lockKey)
<mask> wg.Done()
<mask> return
<mask> }
<mask> pc = rawPc
<mask> addr = nAddr
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
<mask> } else {
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go | |
pc = newUDPTracker(rawPc, DefaultManager, metadata, rule) | <mask> return
<mask> }
<mask> addr = nAddr
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String())
<mask> } else {
</s> Feature: add experimental connections API </s> remove pc = rawPc
</s> add </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
remoteConn = newTCPTracker(remoteConn, DefaultManager, metadata, rule) | <mask> return
<mask> }
<mask> defer remoteConn.Close()
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String())
<mask> } else {
</s> Feature: add experimental connections API </s> remove pc = rawPc
</s> add </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
metadata.DstIP = ip | <mask> var resolved bool
<mask>
<mask> if node := dns.DefaultHosts.Search(metadata.Host); node != nil {
<mask> ip := node.Data.(net.IP)
<mask> metadata.DstIP = &ip
<mask> resolved = true
<mask> }
<mask>
<mask> for _, rule := range t.rules {
<mask> if !resolved && t.shouldResolveIP(rule, metadata) {
</s> Feature: add experimental connections API </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove t := T.Instance().Traffic()
</s> add t := T.DefaultManager </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove t.traffic.Up() <- int64(n)
</s> add DefaultManager.Upload() <- int64(n) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
metadata.DstIP = ip | <mask> }
<mask> log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
<mask> } else {
<mask> log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
<mask> metadata.DstIP = &ip
<mask> }
<mask> resolved = true
<mask> }
<mask>
<mask> if rule.IsMatch(metadata) {
</s> Feature: add experimental connections API </s> remove pc = rawPc
</s> add </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip </s> remove metadata.DstIP = &ip
</s> add metadata.DstIP = ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
tcpQueue: channels.NewInfiniteChannel(),
udpQueue: channels.NewInfiniteChannel(),
natTable: nat.New(),
proxies: make(map[string]C.Proxy),
mode: Rule, | <mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> return &Tunnel{
<mask> tcpQueue: channels.NewInfiniteChannel(),
<mask> udpQueue: channels.NewInfiniteChannel(),
<mask> natTable: nat.New(),
<mask> proxies: make(map[string]C.Proxy),
<mask> configMux: &sync.RWMutex{},
<mask> traffic: C.NewTraffic(time.Second),
<mask> mode: Rule,
<mask> }
<mask> }
<mask>
<mask> // Instance return singleton instance of Tunnel
<mask> func Instance() *Tunnel {
</s> Feature: add experimental connections API </s> remove // Traffic return traffic of all connections
func (t *Tunnel) Traffic() *C.Traffic {
return t.traffic
}
</s> add </s> remove return ip != nil && i.ipnet.Contains(*ip)
</s> add return ip != nil && i.ipnet.Contains(ip) </s> remove record, _ := mmdb.Country(*metadata.DstIP)
</s> add record, _ := mmdb.Country(metadata.DstIP) </s> remove func parseAddr(addr string) (*net.IP, string, error) {
</s> add func parseAddr(addr string) (net.IP, string, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/207371aeaeec4cac5a8ca695a7aaf8a846138260 | tunnel/tunnel.go |
<mask>
<mask> import (
<mask> "bufio"
<mask> "bytes"
<mask> "crypto/tls"
<mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "net/http"
<mask> "net/http/httputil"
</s> Fixed: https proxy doesn't works in Safari </s> remove rw: rw,
</s> add </s> remove rw *bufio.ReadWriter
</s> add </s> remove w.WriteHeader(http.StatusOK)
</s> add </s> remove // Disable HTTP/2.
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a3c231de6b5b04964144fd4a757bb8b27d85a5 | proxy/http.go | |
<mask> } else {
<mask> handleHTTP(w, r)
<mask> }
<mask> }),
<mask> // Disable HTTP/2.
<mask> TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
<mask> }
<mask> log.Infof("HTTP proxy :%s", port)
<mask> server.ListenAndServe()
<mask> }
<mask>
</s> Fixed: https proxy doesn't works in Safari </s> remove w.WriteHeader(http.StatusOK)
</s> add </s> remove rw: rw,
</s> add </s> remove rw *bufio.ReadWriter
</s> add </s> remove "crypto/tls"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a3c231de6b5b04964144fd4a757bb8b27d85a5 | proxy/http.go | |
<mask> tun.Add(NewHttp(addr, conn, rw, buf))
<mask> }
<mask>
<mask> func handleTunneling(w http.ResponseWriter, r *http.Request) {
<mask> w.WriteHeader(http.StatusOK)
<mask> hijacker, ok := w.(http.Hijacker)
<mask> if !ok {
<mask> return
<mask> }
<mask> conn, rw, err := hijacker.Hijack()
</s> Fixed: https proxy doesn't works in Safari </s> remove rw: rw,
</s> add </s> remove rw *bufio.ReadWriter
</s> add </s> remove // Disable HTTP/2.
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
</s> add </s> remove "crypto/tls"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a3c231de6b5b04964144fd4a757bb8b27d85a5 | proxy/http.go | |
// w.WriteHeader(http.StatusOK) doesn't works in Safari
conn.Write([]byte("HTTP/1.1 200 OK\r\n\r\n")) | <mask> return
<mask> }
<mask> tun.Add(NewHttp(r.Host, conn, rw, []byte{}))
<mask> }
<mask>
<mask> type HttpAdapter struct {
<mask> addr *constant.Addr
<mask> conn net.Conn
</s> Fixed: https proxy doesn't works in Safari </s> remove rw *bufio.ReadWriter
</s> add </s> remove w.WriteHeader(http.StatusOK)
</s> add </s> remove // Disable HTTP/2.
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
</s> add </s> remove rw: rw,
</s> add </s> remove "crypto/tls"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a3c231de6b5b04964144fd4a757bb8b27d85a5 | proxy/http.go |
<mask>
<mask> type HttpAdapter struct {
<mask> addr *constant.Addr
<mask> conn net.Conn
<mask> rw *bufio.ReadWriter
<mask> r io.Reader
<mask> }
<mask>
<mask> func (h *HttpAdapter) Writer() io.Writer {
<mask> return h.conn
</s> Fixed: https proxy doesn't works in Safari </s> remove w.WriteHeader(http.StatusOK)
</s> add </s> remove // Disable HTTP/2.
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
</s> add </s> remove rw: rw,
</s> add </s> remove "crypto/tls"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a3c231de6b5b04964144fd4a757bb8b27d85a5 | proxy/http.go | |
<mask> r := io.MultiReader(bytes.NewReader(payload), rw)
<mask> return &HttpAdapter{
<mask> conn: conn,
<mask> addr: parseHttpAddr(host),
<mask> rw: rw,
<mask> r: r,
<mask> }
<mask> }
</s> Fixed: https proxy doesn't works in Safari </s> remove w.WriteHeader(http.StatusOK)
</s> add </s> remove // Disable HTTP/2.
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
</s> add </s> remove rw *bufio.ReadWriter
</s> add </s> remove "crypto/tls"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a3c231de6b5b04964144fd4a757bb8b27d85a5 | proxy/http.go | |
options := []dialer.Option{
dialer.WithInterface(ifaceName),
dialer.WithAddrReuse(true),
}
// fallback bind on windows, because syscall bind can not receive broadcast
if runtime.GOOS == "windows" {
options = append(options, dialer.WithFallbackBind(true))
}
return dialer.ListenPacket(ctx, "udp4", listenAddr, options...) | <mask> if runtime.GOOS == "linux" || runtime.GOOS == "android" {
<mask> listenAddr = "255.255.255.255:68"
<mask> }
<mask>
<mask> return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
<mask> }
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dhcp/conn.go |
//go:build !linux && !darwin && !windows | <mask> //go:build !linux && !darwin
<mask>
<mask> package dialer
<mask>
<mask> import (
<mask> "net"
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove "strings"
"github.com/Dreamacro/clash/component/iface"
</s> add </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add | [
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/bind_others.go |
<mask>
<mask> import (
<mask> "net"
<mask> "strconv"
<mask> "strings"
<mask>
<mask> "github.com/Dreamacro/clash/component/iface"
<mask> )
<mask>
<mask> func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
<mask> ifaceObj, err := iface.ResolveInterface(ifaceName)
<mask> if err != nil {
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add </s> remove //go:build !linux && !darwin
</s> add //go:build !linux && !darwin && !windows </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/bind_others.go | |
<mask>
<mask> "github.com/Dreamacro/clash/component/iface"
<mask> )
<mask>
<mask> func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
<mask> ifaceObj, err := iface.ResolveInterface(ifaceName)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> var addr *net.IPNet
<mask> switch network {
<mask> case "udp4", "tcp4":
<mask> addr, err = ifaceObj.PickIPv4Addr(destination)
<mask> case "tcp6", "udp6":
<mask> addr, err = ifaceObj.PickIPv6Addr(destination)
<mask> default:
<mask> if destination != nil {
<mask> if destination.To4() != nil {
<mask> addr, err = ifaceObj.PickIPv4Addr(destination)
<mask> } else {
<mask> addr, err = ifaceObj.PickIPv6Addr(destination)
<mask> }
<mask> } else {
<mask> addr, err = ifaceObj.PickIPv4Addr(destination)
<mask> }
<mask> }
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> if strings.HasPrefix(network, "tcp") {
<mask> return &net.TCPAddr{
<mask> IP: addr.IP,
<mask> Port: port,
<mask> }, nil
<mask> } else if strings.HasPrefix(network, "udp") {
<mask> return &net.UDPAddr{
<mask> IP: addr.IP,
<mask> Port: port,
<mask> }, nil
<mask> }
<mask>
<mask> return nil, iface.ErrAddrNotFound
<mask> }
<mask>
<mask> func bindIfaceToDialer(ifaceName string, dialer *net.Dialer, network string, destination net.IP) error {
<mask> if !destination.IsGlobalUnicast() {
<mask> return nil
<mask> }
<mask>
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove "strings"
"github.com/Dreamacro/clash/component/iface"
</s> add </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} </s> remove return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
</s> add options := []dialer.Option{
dialer.WithInterface(ifaceName),
dialer.WithAddrReuse(true),
}
// fallback bind on windows, because syscall bind can not receive broadcast
if runtime.GOOS == "windows" {
options = append(options, dialer.WithFallbackBind(true))
}
return dialer.ListenPacket(ctx, "udp4", listenAddr, options...) | [
"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/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/bind_others.go | |
var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} | <mask> }
<mask>
<mask> lc := &net.ListenConfig{}
<mask> if cfg.interfaceName != "" {
<mask> addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> address = addr
<mask> }
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add </s> remove return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
</s> add options := []dialer.Option{
dialer.WithInterface(ifaceName),
dialer.WithAddrReuse(true),
}
// fallback bind on windows, because syscall bind can not receive broadcast
if runtime.GOOS == "windows" {
options = append(options, dialer.WithFallbackBind(true))
}
return dialer.ListenPacket(ctx, "udp4", listenAddr, options...) </s> remove "strings"
"github.com/Dreamacro/clash/component/iface"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/dialer.go |
if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} | <mask> }
<mask>
<mask> dialer := &net.Dialer{}
<mask> if opt.interfaceName != "" {
<mask> if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
<mask> return nil, err
<mask> }
<mask> }
<mask> if opt.routingMark != 0 {
<mask> bindMarkToDialer(opt.routingMark, dialer, network, destination)
<mask> }
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add </s> remove return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
</s> add options := []dialer.Option{
dialer.WithInterface(ifaceName),
dialer.WithAddrReuse(true),
}
// fallback bind on windows, because syscall bind can not receive broadcast
if runtime.GOOS == "windows" {
options = append(options, dialer.WithFallbackBind(true))
}
return dialer.ListenPacket(ctx, "udp4", listenAddr, options...) </s> remove "strings"
"github.com/Dreamacro/clash/component/iface"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/dialer.go |
fallbackBind bool | <mask>
<mask> type option struct {
<mask> interfaceName string
<mask> addrReuse bool
<mask> routingMark int
<mask> }
<mask>
<mask> type Option func(opt *option)
<mask>
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add </s> remove return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
</s> add options := []dialer.Option{
dialer.WithInterface(ifaceName),
dialer.WithAddrReuse(true),
}
// fallback bind on windows, because syscall bind can not receive broadcast
if runtime.GOOS == "windows" {
options = append(options, dialer.WithFallbackBind(true))
}
return dialer.ListenPacket(ctx, "udp4", listenAddr, options...) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/options.go |
func WithFallbackBind(fallback bool) Option {
return func(opt *option) {
opt.fallbackBind = fallback
}
}
| <mask> }
<mask>
<mask> func WithAddrReuse(reuse bool) Option {
<mask> return func(opt *option) {
<mask> opt.addrReuse = reuse
<mask> }
<mask> }
<mask>
</s> Feature: bind socket to interface by native API on Windows (#2662) </s> remove func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
ifaceObj, err := iface.ResolveInterface(ifaceName)
if err != nil {
return nil, err
}
var addr *net.IPNet
switch network {
case "udp4", "tcp4":
addr, err = ifaceObj.PickIPv4Addr(destination)
case "tcp6", "udp6":
addr, err = ifaceObj.PickIPv6Addr(destination)
default:
if destination != nil {
if destination.To4() != nil {
addr, err = ifaceObj.PickIPv4Addr(destination)
} else {
addr, err = ifaceObj.PickIPv6Addr(destination)
}
} else {
addr, err = ifaceObj.PickIPv4Addr(destination)
}
}
if err != nil {
return nil, err
}
if strings.HasPrefix(network, "tcp") {
return &net.TCPAddr{
IP: addr.IP,
Port: port,
}, nil
} else if strings.HasPrefix(network, "udp") {
return &net.UDPAddr{
IP: addr.IP,
Port: port,
}, nil
}
return nil, iface.ErrAddrNotFound
}
</s> add </s> remove if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
</s> add if opt.fallbackBind {
if err := fallbackBindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
}
} else {
if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
return nil, err
} </s> remove addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
</s> add var (
addr string
err error
)
if cfg.fallbackBind {
addr, err = fallbackBindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} else {
addr, err = bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
} </s> remove return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
</s> add options := []dialer.Option{
dialer.WithInterface(ifaceName),
dialer.WithAddrReuse(true),
}
// fallback bind on windows, because syscall bind can not receive broadcast
if runtime.GOOS == "windows" {
options = append(options, dialer.WithFallbackBind(true))
}
return dialer.ListenPacket(ctx, "udp4", listenAddr, options...) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/20a521f02d495890f14b843e56ef56ef890fd6be | component/dialer/options.go |
if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} | <mask>
<mask> // NewHTTP is HTTPAdapter generator
<mask> func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
<mask> metadata := parseHTTPAddr(request)
<mask> metadata.SourceIP = parseSourceIP(conn)
<mask> return &HTTPAdapter{
<mask> metadata: metadata,
<mask> R: request,
<mask> Conn: conn,
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove metadata.Source = source
metadata.SourceIP = parseSourceIP(conn)
</s> add metadata.Type = source
if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove func NewSocket(target socks5.Addr, conn net.Conn, source C.SourceType, netType C.NetWork) *SocketAdapter {
</s> add func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter { </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/http.go |
if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} | <mask>
<mask> // NewHTTPS is HTTPAdapter generator
<mask> func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
<mask> metadata := parseHTTPAddr(request)
<mask> metadata.SourceIP = parseSourceIP(conn)
<mask> return &SocketAdapter{
<mask> metadata: metadata,
<mask> Conn: conn,
<mask> }
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove metadata.Source = source
metadata.SourceIP = parseSourceIP(conn)
</s> add metadata.Type = source
if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove func NewSocket(target socks5.Addr, conn net.Conn, source C.SourceType, netType C.NetWork) *SocketAdapter {
</s> add func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter { </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/https.go |
func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter { | <mask> return s.metadata
<mask> }
<mask>
<mask> // NewSocket is SocketAdapter generator
<mask> func NewSocket(target socks5.Addr, conn net.Conn, source C.SourceType, netType C.NetWork) *SocketAdapter {
<mask> metadata := parseSocksAddr(target)
<mask> metadata.NetWork = netType
<mask> metadata.Source = source
<mask> metadata.SourceIP = parseSourceIP(conn)
<mask>
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.Source = source
metadata.SourceIP = parseSourceIP(conn)
</s> add metadata.Type = source
if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/socket.go |
metadata.Type = source
if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} | <mask> // NewSocket is SocketAdapter generator
<mask> func NewSocket(target socks5.Addr, conn net.Conn, source C.SourceType, netType C.NetWork) *SocketAdapter {
<mask> metadata := parseSocksAddr(target)
<mask> metadata.NetWork = netType
<mask> metadata.Source = source
<mask> metadata.SourceIP = parseSourceIP(conn)
<mask>
<mask> return &SocketAdapter{
<mask> Conn: conn,
<mask> metadata: metadata,
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove func NewSocket(target socks5.Addr, conn net.Conn, source C.SourceType, netType C.NetWork) *SocketAdapter {
</s> add func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter { </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/socket.go |
metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) | <mask>
<mask> switch target[0] {
<mask> case socks5.AtypDomainName:
<mask> metadata.Host = string(target[2 : 2+target[1]])
<mask> metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
<mask> case socks5.AtypIPv4:
<mask> ip := net.IP(target[1 : 1+net.IPv4len])
<mask> metadata.IP = &ip
<mask> metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
<mask> case socks5.AtypIPv6:
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1])) </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() </s> remove host := metadata.IP.To4()
</s> add host := metadata.DstIP.To4() </s> remove copy(addr[:], metadata.IP.To4())
</s> add copy(addr[:], metadata.DstIP.To4()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) | <mask> metadata.Host = string(target[2 : 2+target[1]])
<mask> metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
<mask> case socks5.AtypIPv4:
<mask> ip := net.IP(target[1 : 1+net.IPv4len])
<mask> metadata.IP = &ip
<mask> metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
<mask> case socks5.AtypIPv6:
<mask> ip := net.IP(target[1 : 1+net.IPv6len])
<mask> metadata.IP = &ip
<mask> metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
</s> add metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1])) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() </s> remove host := metadata.IP.To4()
</s> add host := metadata.DstIP.To4() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1])) | <mask> metadata.IP = &ip
<mask> metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
<mask> case socks5.AtypIPv6:
<mask> ip := net.IP(target[1 : 1+net.IPv6len])
<mask> metadata.IP = &ip
<mask> metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
<mask> }
<mask>
<mask> return metadata
<mask> }
<mask>
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) </s> remove metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
</s> add metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
Type: C.HTTP, | <mask> }
<mask>
<mask> metadata := &C.Metadata{
<mask> NetWork: C.TCP,
<mask> Source: C.HTTP,
<mask> AddrType: C.AtypDomainName,
<mask> Host: host,
<mask> IP: nil,
<mask> Port: port,
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove port, _ := strconv.Atoi(metadata.Port)
</s> add port, _ := strconv.Atoi(metadata.DstPort) </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
DstIP: nil,
DstPort: port, | <mask> NetWork: C.TCP,
<mask> Source: C.HTTP,
<mask> AddrType: C.AtypDomainName,
<mask> Host: host,
<mask> IP: nil,
<mask> Port: port,
<mask> }
<mask>
<mask> ip := net.ParseIP(host)
<mask> if ip != nil {
<mask> switch {
</s> Feature: add DST-PORT and SRC-PORT </s> remove Source: C.HTTP,
</s> add Type: C.HTTP, </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove return nil
</s> add ip := net.ParseIP(host)
return &ip, port, nil </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
metadata.DstIP = &ip | <mask> metadata.AddrType = C.AtypIPv6
<mask> default:
<mask> metadata.AddrType = C.AtypIPv4
<mask> }
<mask> metadata.IP = &ip
<mask> }
<mask>
<mask> return metadata
<mask> }
<mask>
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.IP = nil
</s> add metadata.DstIP = nil </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1])) </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err | <mask>
<mask> return metadata
<mask> }
<mask>
<mask> func parseSourceIP(conn net.Conn) *net.IP {
<mask> if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
<mask> return &addr.IP
<mask> }
<mask> return nil
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove return nil
</s> add ip := net.ParseIP(host)
return &ip, port, nil </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
ip := net.ParseIP(host)
return &ip, port, nil | <mask> func parseSourceIP(conn net.Conn) *net.IP {
<mask> if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
<mask> return &addr.IP
<mask> }
<mask> return nil
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove IP *net.IP
Port string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/inbound/util.go |
address := net.JoinHostPort(metadata.Host, metadata.DstPort)
if metadata.DstIP != nil {
address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort) | <mask> *Base
<mask> }
<mask>
<mask> func (d *Direct) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> address := net.JoinHostPort(metadata.Host, metadata.Port)
<mask> if metadata.IP != nil {
<mask> address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
<mask> }
<mask>
<mask> c, err := net.DialTimeout("tcp", address, tcpTimeout)
<mask> if err != nil {
<mask> return nil, err
</s> Feature: add DST-PORT and SRC-PORT </s> remove remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/direct.go |
addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask> return pc, addr, nil
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove address := net.JoinHostPort(metadata.Host, metadata.Port)
if metadata.IP != nil {
address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
</s> add address := net.JoinHostPort(metadata.Host, metadata.DstPort)
if metadata.DstIP != nil {
address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/direct.go |
addr := net.JoinHostPort(metadata.String(), metadata.DstPort) | <mask> func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
<mask> var buf bytes.Buffer
<mask> var err error
<mask>
<mask> addr := net.JoinHostPort(metadata.String(), metadata.Port)
<mask> buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
<mask> buf.WriteString("Host: " + metadata.String() + "\r\n")
<mask> buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
<mask>
<mask> if h.user != "" && h.pass != "" {
</s> Feature: add DST-PORT and SRC-PORT </s> remove address := net.JoinHostPort(metadata.Host, metadata.Port)
if metadata.IP != nil {
address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
</s> add address := net.JoinHostPort(metadata.Host, metadata.DstPort)
if metadata.DstIP != nil {
address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort) </s> remove remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove return metadata.IP.String()
</s> add return metadata.DstIP.String() </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.IP != nil
</s> add return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/http.go |
if metadata.DstIP == nil { | <mask> return etld
<mask> }
<mask> }
<mask>
<mask> if metadata.IP == nil {
<mask> return ""
<mask> }
<mask>
<mask> return metadata.IP.String()
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove return metadata.IP.String()
</s> add return metadata.DstIP.String() </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove return m.IP.String()
</s> add return m.DstIP.String() </s> remove return m.Host != "" || m.IP != nil
</s> add return m.Host != "" || m.DstIP != nil </s> remove return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
</s> add return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/loadbalance.go |
return metadata.DstIP.String() | <mask> if metadata.IP == nil {
<mask> return ""
<mask> }
<mask>
<mask> return metadata.IP.String()
<mask> }
<mask>
<mask> func jumpHash(key uint64, buckets int32) int32 {
<mask> var b, j int64
<mask>
</s> Feature: add DST-PORT and SRC-PORT </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove return m.IP.String()
</s> add return m.DstIP.String() </s> remove return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
</s> add return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil </s> remove metadata.IP = nil
</s> add metadata.DstIP = nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/loadbalance.go |
remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | <mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
<mask> if err != nil {
<mask> return nil, nil, err
<mask> }
<mask>
<mask> pc = ss.cipher.PacketConn(pc)
</s> Feature: add DST-PORT and SRC-PORT </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove address := net.JoinHostPort(metadata.Host, metadata.Port)
if metadata.IP != nil {
address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
</s> add address := net.JoinHostPort(metadata.Host, metadata.DstPort)
if metadata.DstIP != nil {
address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/shadowsocks.go |
DstIP: nil,
DstPort: port, | <mask>
<mask> addr = C.Metadata{
<mask> AddrType: C.AtypDomainName,
<mask> Host: u.Hostname(),
<mask> IP: nil,
<mask> Port: port,
<mask> }
<mask> return
<mask> }
<mask>
<mask> func tcpKeepAlive(c net.Conn) {
</s> Feature: add DST-PORT and SRC-PORT </s> remove Source: C.HTTP,
</s> add Type: C.HTTP, </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove port, _ := strconv.Atoi(metadata.Port)
</s> add port, _ := strconv.Atoi(metadata.DstPort) </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove return nil
</s> add ip := net.ParseIP(host)
return &ip, port, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/util.go |
p, _ := strconv.Atoi(metadata.DstPort) | <mask>
<mask> func serializesSocksAddr(metadata *C.Metadata) []byte {
<mask> var buf [][]byte
<mask> aType := uint8(metadata.AddrType)
<mask> p, _ := strconv.Atoi(metadata.Port)
<mask> port := []byte{uint8(p >> 8), uint8(p & 0xff)}
<mask> switch metadata.AddrType {
<mask> case socks5.AtypDomainName:
<mask> len := uint8(len(metadata.Host))
<mask> host := []byte(metadata.Host)
</s> Feature: add DST-PORT and SRC-PORT </s> remove host := metadata.IP.To4()
</s> add host := metadata.DstIP.To4() </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) </s> remove port, _ := strconv.Atoi(metadata.Port)
</s> add port, _ := strconv.Atoi(metadata.DstPort) </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/util.go |
host := metadata.DstIP.To4() | <mask> len := uint8(len(metadata.Host))
<mask> host := []byte(metadata.Host)
<mask> buf = [][]byte{{aType, len}, host, port}
<mask> case socks5.AtypIPv4:
<mask> host := metadata.IP.To4()
<mask> buf = [][]byte{{aType}, host, port}
<mask> case socks5.AtypIPv6:
<mask> host := metadata.IP.To16()
<mask> buf = [][]byte{{aType}, host, port}
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() </s> remove p, _ := strconv.Atoi(metadata.Port)
</s> add p, _ := strconv.Atoi(metadata.DstPort) </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) </s> remove metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
</s> add metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/util.go |
host := metadata.DstIP.To16() | <mask> case socks5.AtypIPv4:
<mask> host := metadata.IP.To4()
<mask> buf = [][]byte{{aType}, host, port}
<mask> case socks5.AtypIPv6:
<mask> host := metadata.IP.To16()
<mask> buf = [][]byte{{aType}, host, port}
<mask> }
<mask> return bytes.Join(buf, nil)
<mask> }
<mask>
</s> Feature: add DST-PORT and SRC-PORT </s> remove host := metadata.IP.To4()
</s> add host := metadata.DstIP.To4() </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) </s> remove p, _ := strconv.Atoi(metadata.Port)
</s> add p, _ := strconv.Atoi(metadata.DstPort) </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) </s> remove metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
</s> add metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/util.go |
copy(addr[:], metadata.DstIP.To4()) | <mask> switch metadata.AddrType {
<mask> case C.AtypIPv4:
<mask> addrType = byte(vmess.AtypIPv4)
<mask> addr = make([]byte, net.IPv4len)
<mask> copy(addr[:], metadata.IP.To4())
<mask> case C.AtypIPv6:
<mask> addrType = byte(vmess.AtypIPv6)
<mask> addr = make([]byte, net.IPv6len)
<mask> copy(addr[:], metadata.IP.To16())
<mask> case C.AtypDomainName:
</s> Feature: add DST-PORT and SRC-PORT </s> remove copy(addr[:], metadata.IP.To16())
</s> add copy(addr[:], metadata.DstIP.To16()) </s> remove metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
</s> add metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/vmess.go |
copy(addr[:], metadata.DstIP.To16()) | <mask> copy(addr[:], metadata.IP.To4())
<mask> case C.AtypIPv6:
<mask> addrType = byte(vmess.AtypIPv6)
<mask> addr = make([]byte, net.IPv6len)
<mask> copy(addr[:], metadata.IP.To16())
<mask> case C.AtypDomainName:
<mask> addrType = byte(vmess.AtypDomainName)
<mask> addr = make([]byte, len(metadata.Host)+1)
<mask> addr[0] = byte(len(metadata.Host))
<mask> copy(addr[1:], []byte(metadata.Host))
</s> Feature: add DST-PORT and SRC-PORT </s> remove copy(addr[:], metadata.IP.To4())
</s> add copy(addr[:], metadata.DstIP.To4()) </s> remove port, _ := strconv.Atoi(metadata.Port)
</s> add port, _ := strconv.Atoi(metadata.DstPort) </s> remove metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
</s> add metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1])) </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/vmess.go |
port, _ := strconv.Atoi(metadata.DstPort) | <mask> addr[0] = byte(len(metadata.Host))
<mask> copy(addr[1:], []byte(metadata.Host))
<mask> }
<mask>
<mask> port, _ := strconv.Atoi(metadata.Port)
<mask> return &vmess.DstAddr{
<mask> UDP: metadata.NetWork == C.UDP,
<mask> AddrType: addrType,
<mask> Addr: addr,
<mask> Port: uint(port),
</s> Feature: add DST-PORT and SRC-PORT </s> remove copy(addr[:], metadata.IP.To16())
</s> add copy(addr[:], metadata.DstIP.To16()) </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove Source: C.HTTP,
</s> add Type: C.HTTP, </s> remove IP: nil,
Port: port,
</s> add DstIP: nil,
DstPort: port, </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | adapters/outbound/vmess.go |
// deprecated when bump to 1.0 | <mask> case "IP-CIDR", "IP-CIDR6":
<mask> if rule := R.NewIPCIDR(payload, target, false); rule != nil {
<mask> parsed = rule
<mask> }
<mask> case "SOURCE-IP-CIDR":
<mask> fallthrough
<mask> case "SRC-IP-CIDR":
<mask> if rule := R.NewIPCIDR(payload, target, true); rule != nil {
<mask> parsed = rule
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String()) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | config/config.go |
fallthrough
case "SRC-IP-CIDR": | <mask> // deprecated when bump to 1.0
<mask> case "SOURCE-IP-CIDR":
<mask> if rule := R.NewIPCIDR(payload, target, true); rule != nil {
<mask> parsed = rule
<mask> }
<mask> case "SRC-PORT":
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String()) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | config/config.go |
case "SRC-PORT":
if rule := R.NewPort(payload, target, true); rule != nil {
parsed = rule
}
case "DST-PORT":
if rule := R.NewPort(payload, target, false); rule != nil {
parsed = rule
} | <mask> parsed = rule
<mask> }
<mask> case "MATCH":
<mask> fallthrough
<mask> // deprecated when bump to 1.0
<mask> case "FINAL":
<mask> parsed = R.NewMatch(target)
</s> Feature: add DST-PORT and SRC-PORT </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() </s> remove copy(addr[:], metadata.IP.To4())
</s> add copy(addr[:], metadata.DstIP.To4()) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | config/config.go |
// deprecated when bump to 1.0 | <mask> parsed = rule
<mask> }
<mask> case "MATCH":
<mask> fallthrough
<mask> case "FINAL":
<mask> parsed = R.NewMatch(target)
<mask> }
<mask>
<mask> if parsed == nil {
<mask> return nil, fmt.Errorf("Rules[%d] [%s] error: payload invalid", idx, line)
</s> Feature: add DST-PORT and SRC-PORT </s> remove remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | config/config.go |
HTTP Type = iota | <mask>
<mask> TCP NetWork = iota
<mask> UDP
<mask>
<mask> HTTP SourceType = iota
<mask> SOCKS
<mask> REDIR
<mask> )
<mask>
<mask> type NetWork int
</s> Feature: add DST-PORT and SRC-PORT </s> remove type SourceType int
</s> add type Type int </s> remove Source SourceType
SourceIP *net.IP
</s> add Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string </s> remove SourceIPCIDR
</s> add SrcIPCIDR
SrcPort
DstPort </s> remove IP *net.IP
Port string
</s> add </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/metadata.go |
type Type int | <mask> }
<mask> return "udp"
<mask> }
<mask>
<mask> type SourceType int
<mask>
<mask> // Metadata is used to store connection address
<mask> type Metadata struct {
<mask> NetWork NetWork
<mask> Source SourceType
</s> Feature: add DST-PORT and SRC-PORT </s> remove Source SourceType
SourceIP *net.IP
</s> add Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string </s> remove HTTP SourceType = iota
</s> add HTTP Type = iota </s> remove IP *net.IP
Port string
</s> add </s> remove SourceIPCIDR
</s> add SrcIPCIDR
SrcPort
DstPort </s> remove address := net.JoinHostPort(metadata.Host, metadata.Port)
if metadata.IP != nil {
address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
</s> add address := net.JoinHostPort(metadata.Host, metadata.DstPort)
if metadata.DstIP != nil {
address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/metadata.go |
Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string | <mask>
<mask> // Metadata is used to store connection address
<mask> type Metadata struct {
<mask> NetWork NetWork
<mask> Source SourceType
<mask> SourceIP *net.IP
<mask> AddrType int
<mask> Host string
<mask> IP *net.IP
<mask> Port string
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove type SourceType int
</s> add type Type int </s> remove IP *net.IP
Port string
</s> add </s> remove HTTP SourceType = iota
</s> add HTTP Type = iota </s> remove return nil
</s> add ip := net.ParseIP(host)
return &ip, port, nil </s> remove return m.IP.String()
</s> add return m.DstIP.String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/metadata.go |
<mask> Source SourceType
<mask> SourceIP *net.IP
<mask> AddrType int
<mask> Host string
<mask> IP *net.IP
<mask> Port string
<mask> }
<mask>
<mask> func (m *Metadata) String() string {
<mask> if m.Host == "" {
<mask> return m.IP.String()
</s> Feature: add DST-PORT and SRC-PORT </s> remove Source SourceType
SourceIP *net.IP
</s> add Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string </s> remove return m.IP.String()
</s> add return m.DstIP.String() </s> remove return m.Host != "" || m.IP != nil
</s> add return m.Host != "" || m.DstIP != nil </s> remove type SourceType int
</s> add type Type int </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/metadata.go | |
return m.DstIP.String() | <mask> }
<mask>
<mask> func (m *Metadata) String() string {
<mask> if m.Host == "" {
<mask> return m.IP.String()
<mask> }
<mask> return m.Host
<mask> }
<mask>
<mask> func (m *Metadata) Valid() bool {
</s> Feature: add DST-PORT and SRC-PORT </s> remove IP *net.IP
Port string
</s> add </s> remove return m.Host != "" || m.IP != nil
</s> add return m.Host != "" || m.DstIP != nil </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/metadata.go |
return m.Host != "" || m.DstIP != nil | <mask> return m.Host
<mask> }
<mask>
<mask> func (m *Metadata) Valid() bool {
<mask> return m.Host != "" || m.IP != nil
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove return m.IP.String()
</s> add return m.DstIP.String() </s> remove IP *net.IP
Port string
</s> add </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.IP != nil
</s> add return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil </s> remove return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
</s> add return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/metadata.go |
SrcIPCIDR
SrcPort
DstPort | <mask> DomainSuffix
<mask> DomainKeyword
<mask> GEOIP
<mask> IPCIDR
<mask> SourceIPCIDR
<mask> MATCH
<mask> )
<mask>
<mask> type RuleType int
<mask>
</s> Feature: add DST-PORT and SRC-PORT </s> remove HTTP SourceType = iota
</s> add HTTP Type = iota </s> remove type SourceType int
</s> add type Type int </s> remove Source SourceType
SourceIP *net.IP
</s> add Type Type
SrcIP *net.IP
DstIP *net.IP
SrcPort string
DstPort string </s> remove IP *net.IP
Port string
</s> add </s> remove log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/rule.go |
case SrcIPCIDR:
return "SrcIPCIDR"
case SrcPort:
return "SrcPort"
case DstPort:
return "DstPort" | <mask> case GEOIP:
<mask> return "GEOIP"
<mask> case IPCIDR:
<mask> return "IPCIDR"
<mask> case SourceIPCIDR:
<mask> return "SourceIPCIDR"
<mask> case MATCH:
<mask> return "MATCH"
<mask> default:
<mask> return "Unknow"
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove host := metadata.IP.To16()
</s> add host := metadata.DstIP.To16() </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove metadata.IP = &ip
metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
</s> add metadata.DstIP = &ip
metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | constant/rule.go |
if metadata.DstIP == nil { | <mask> return C.GEOIP
<mask> }
<mask>
<mask> func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
<mask> if metadata.IP == nil {
<mask> return false
<mask> }
<mask> record, _ := mmdb.Country(*metadata.IP)
<mask> return record.Country.IsoCode == g.country
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) </s> remove return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
</s> add return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove return C.SourceIPCIDR
</s> add return C.SrcIPCIDR </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | rules/geoip.go |
record, _ := mmdb.Country(*metadata.DstIP) | <mask> func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
<mask> if metadata.IP == nil {
<mask> return false
<mask> }
<mask> record, _ := mmdb.Country(*metadata.IP)
<mask> return record.Country.IsoCode == g.country
<mask> }
<mask>
<mask> func (g *GEOIP) Adapter() string {
<mask> return g.adapter
</s> Feature: add DST-PORT and SRC-PORT </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove return m.IP.String()
</s> add return m.DstIP.String() </s> remove return C.SourceIPCIDR
</s> add return C.SrcIPCIDR | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | rules/geoip.go |
return C.SrcIPCIDR | <mask> }
<mask>
<mask> func (i *IPCIDR) RuleType() C.RuleType {
<mask> if i.isSourceIP {
<mask> return C.SourceIPCIDR
<mask> }
<mask> return C.IPCIDR
<mask> }
<mask>
<mask> func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
</s> Feature: add DST-PORT and SRC-PORT </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) </s> remove return m.IP.String()
</s> add return m.DstIP.String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | rules/ipcidr.go |
ip := metadata.DstIP | <mask> return C.IPCIDR
<mask> }
<mask>
<mask> func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
<mask> ip := metadata.IP
<mask> if i.isSourceIP {
<mask> ip = metadata.SourceIP
<mask> }
<mask> return ip != nil && i.ipnet.Contains(*ip)
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP </s> remove return C.SourceIPCIDR
</s> add return C.SrcIPCIDR </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) </s> remove return nil
</s> add ip := net.ParseIP(host)
return &ip, port, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | rules/ipcidr.go |
ip = metadata.SrcIP | <mask>
<mask> func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
<mask> ip := metadata.IP
<mask> if i.isSourceIP {
<mask> ip = metadata.SourceIP
<mask> }
<mask> return ip != nil && i.ipnet.Contains(*ip)
<mask> }
<mask>
<mask> func (i *IPCIDR) Adapter() string {
</s> Feature: add DST-PORT and SRC-PORT </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove return C.SourceIPCIDR
</s> add return C.SrcIPCIDR </s> remove record, _ := mmdb.Country(*metadata.IP)
</s> add record, _ := mmdb.Country(*metadata.DstIP) </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.IP != nil
</s> add return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | rules/ipcidr.go |
return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil | <mask> return t.resolver.ResolveIP(host)
<mask> }
<mask>
<mask> func (t *Tunnel) needLookupIP(metadata *C.Metadata) bool {
<mask> return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.IP != nil
<mask> }
<mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> metadata := localConn.Metadata()
</s> Feature: add DST-PORT and SRC-PORT </s> remove return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
</s> add return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP </s> remove return m.Host != "" || m.IP != nil
</s> add return m.Host != "" || m.DstIP != nil </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
host, exist := t.resolver.IPToHost(*metadata.DstIP) | <mask> }
<mask>
<mask> // preprocess enhanced-mode metadata
<mask> if t.needLookupIP(metadata) {
<mask> host, exist := t.resolver.IPToHost(*metadata.IP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if t.resolver.IsFakeIP() {
<mask> metadata.IP = nil
</s> Feature: add DST-PORT and SRC-PORT </s> remove metadata.IP = nil
</s> add metadata.DstIP = nil </s> remove address := net.JoinHostPort(metadata.Host, metadata.Port)
if metadata.IP != nil {
address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
</s> add address := net.JoinHostPort(metadata.Host, metadata.DstPort)
if metadata.DstIP != nil {
address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort) </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} </s> remove metadata.SourceIP = parseSourceIP(conn)
</s> add if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
metadata.SrcIP = ip
metadata.SrcPort = port
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
metadata.DstIP = nil | <mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> if t.resolver.IsFakeIP() {
<mask> metadata.IP = nil
<mask> }
<mask> }
<mask> }
<mask>
<mask> var proxy C.Proxy
</s> Feature: add DST-PORT and SRC-PORT </s> remove host, exist := t.resolver.IPToHost(*metadata.IP)
</s> add host, exist := t.resolver.IPToHost(*metadata.DstIP) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove return metadata.IP.String()
</s> add return metadata.DstIP.String() </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) | <mask> if metadata.NetWork == C.UDP {
<mask> pc, addr, err := proxy.DialUDP(metadata)
<mask> defer pc.Close()
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
<mask> }
<mask>
<mask> t.handleUDPOverTCP(localConn, pc, addr)
<mask> return
<mask> }
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove func parseSourceIP(conn net.Conn) *net.IP {
if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
return &addr.IP
</s> add func parseAddr(addr string) (*net.IP, string, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, "", err </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) | <mask> }
<mask>
<mask> remoConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
<mask>
<mask> switch adapter := localConn.(type) {
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.Port))
</s> add remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil | <mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) shouldResolveIP(rule C.Rule, metadata *C.Metadata) bool {
<mask> return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
<mask> }
<mask>
<mask> func (t *Tunnel) match(metadata *C.Metadata) (C.Proxy, error) {
<mask> t.configMux.RLock()
<mask> defer t.configMux.RUnlock()
</s> Feature: add DST-PORT and SRC-PORT </s> remove return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.IP != nil
</s> add return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { </s> remove ip := metadata.IP
</s> add ip := metadata.DstIP </s> remove ip = metadata.SourceIP
</s> add ip = metadata.SrcIP </s> remove return m.Host != "" || m.IP != nil
</s> add return m.Host != "" || m.DstIP != nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
metadata.DstIP = &ip | <mask> }
<mask> log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
<mask> } else {
<mask> log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
<mask> metadata.IP = &ip
<mask> }
<mask> resolved = true
<mask> }
<mask>
<mask> if rule.IsMatch(metadata) {
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String()) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) | <mask> if metadata.NetWork == C.UDP && !adapter.SupportUDP() {
<mask> continue
<mask> }
<mask>
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
<mask> return adapter, nil
<mask> }
<mask> }
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
<mask> return t.proxies["DIRECT"], nil
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
</s> add log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String()) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String()) | <mask> log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
<mask> return adapter, nil
<mask> }
<mask> }
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
<mask> return t.proxies["DIRECT"], nil
<mask> }
<mask>
<mask> func newTunnel() *Tunnel {
<mask> return &Tunnel{
</s> Feature: add DST-PORT and SRC-PORT </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter()) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
</s> add log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error()) </s> remove metadata.IP = &ip
</s> add metadata.DstIP = &ip </s> remove if metadata.IP == nil {
</s> add if metadata.DstIP == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/225c530d13833690a00a0241aea296c676312024 | tunnel/tunnel.go |
// Pool is an implementation about fake ip generator without storage | <mask> Exist(ip net.IP) bool
<mask> CloneTo(store)
<mask> }
<mask>
<mask> // Pool is a implementation about fake ip generator without storage
<mask> type Pool struct {
<mask> max uint32
<mask> min uint32
<mask> gateway uint32
<mask> offset uint32
</s> Fix: fake ip pool offset calculate (#2281) </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove
ip := uintToIP(p.min + p.offset - 1)
if !p.store.Exist(ip) {
break
}
</s> add </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar))
</s> add assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool.go |
ip := uintToIP(p.min + p.offset)
if !p.store.Exist(ip) {
break
}
| <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 {
<mask> p.offset = (p.offset + 1) % (p.max - p.min)
</s> Fix: fake ip pool offset calculate (#2281) </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove
ip := uintToIP(p.min + p.offset - 1)
if !p.store.Exist(ip) {
break
}
</s> add </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar))
</s> add assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) </s> remove // Pool is a implementation about fake ip generator without storage
</s> add // Pool is an implementation about fake ip generator without storage | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool.go |
ip := uintToIP(p.min + p.offset) | <mask> p.offset = (p.offset + 1) % (p.max - p.min)
<mask> // Avoid infinite loops
<mask> if p.offset == current {
<mask> p.offset = (p.offset + 1) % (p.max - p.min)
<mask> ip := uintToIP(p.min + p.offset - 1)
<mask> p.store.DelByIP(ip)
<mask> break
<mask> }
<mask>
<mask> ip := uintToIP(p.min + p.offset - 1)
</s> Fix: fake ip pool offset calculate (#2281) </s> remove
ip := uintToIP(p.min + p.offset - 1)
if !p.store.Exist(ip) {
break
}
</s> add </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove // Pool is a implementation about fake ip generator without storage
</s> add // Pool is an implementation about fake ip generator without storage </s> remove foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar))
</s> add assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool.go |
<mask> ip := uintToIP(p.min + p.offset - 1)
<mask> p.store.DelByIP(ip)
<mask> break
<mask> }
<mask>
<mask> ip := uintToIP(p.min + p.offset - 1)
<mask> if !p.store.Exist(ip) {
<mask> break
<mask> }
<mask> }
<mask> ip := uintToIP(p.min + p.offset - 1)
<mask> p.store.PutByIP(ip, host)
<mask> return ip
<mask> }
</s> Fix: fake ip pool offset calculate (#2281) </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar))
</s> add assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) </s> remove // Pool is a implementation about fake ip generator without storage
</s> add // Pool is an implementation about fake ip generator without storage | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool.go | |
ip := uintToIP(p.min + p.offset) | <mask> if !p.store.Exist(ip) {
<mask> break
<mask> }
<mask> }
<mask> ip := uintToIP(p.min + p.offset - 1)
<mask> p.store.PutByIP(ip, host)
<mask> return ip
<mask> }
<mask>
<mask> func ipToUint(ip net.IP) uint32 {
</s> Fix: fake ip pool offset calculate (#2281) </s> remove
ip := uintToIP(p.min + p.offset - 1)
if !p.store.Exist(ip) {
break
}
</s> add </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove // Pool is a implementation about fake ip generator without storage
</s> add // Pool is an implementation about fake ip generator without storage </s> remove foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar))
</s> add assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool.go |
<mask> package fakeip
<mask>
<mask> import (
<mask> "fmt"
<mask> "net"
<mask> "os"
<mask> "testing"
<mask> "time"
<mask>
</s> Fix: fake ip pool offset calculate (#2281) </s> remove foo := pool.Lookup("foo.com")
bar := pool.Lookup("bar.com")
for i := 0; i < 3; i++ {
pool.Lookup(fmt.Sprintf("%d.com", i))
}
baz := pool.Lookup("baz.com")
next := pool.Lookup("foo.com")
assert.True(t, foo.Equal(baz))
assert.True(t, next.Equal(bar))
</s> add assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove
ip := uintToIP(p.min + p.offset - 1)
if !p.store.Exist(ip) {
break
}
</s> add </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) | [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool_test.go | |
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("2.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com"))
assert.Equal(t, net.IP{192, 168, 0, 4}, pool.Lookup("4.com"))
assert.Equal(t, net.IP{192, 168, 0, 5}, pool.Lookup("5.com"))
assert.Equal(t, net.IP{192, 168, 0, 6}, pool.Lookup("6.com"))
assert.Equal(t, net.IP{192, 168, 0, 2}, pool.Lookup("12.com"))
assert.Equal(t, net.IP{192, 168, 0, 3}, pool.Lookup("3.com")) | <mask> assert.Nil(t, err)
<mask> defer os.Remove(tempfile)
<mask>
<mask> for _, pool := range pools {
<mask> foo := pool.Lookup("foo.com")
<mask> bar := pool.Lookup("bar.com")
<mask> for i := 0; i < 3; i++ {
<mask> pool.Lookup(fmt.Sprintf("%d.com", i))
<mask> }
<mask> baz := pool.Lookup("baz.com")
<mask> next := pool.Lookup("foo.com")
<mask> assert.True(t, foo.Equal(baz))
<mask> assert.True(t, next.Equal(bar))
<mask> }
<mask> }
<mask>
<mask> func TestPool_Skip(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
</s> Fix: fake ip pool offset calculate (#2281) </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove
ip := uintToIP(p.min + p.offset - 1)
if !p.store.Exist(ip) {
break
}
</s> add </s> remove ip := uintToIP(p.min + p.offset - 1)
</s> add ip := uintToIP(p.min + p.offset) </s> remove // Pool is a implementation about fake ip generator without storage
</s> add // Pool is an implementation about fake ip generator without storage | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/22b9befbda9ae6d7f1b302aac61b3627db57a5c8 | component/fakeip/pool_test.go |
interval time.Duration | <mask> name string
<mask> vehicle types.Vehicle
<mask> updatedAt *time.Time
<mask> ticker *time.Ticker
<mask> done chan struct{}
<mask> hash [16]byte
</s> Fix: immediately update provider when modtime too old </s> remove elm, same, err := f.Update()
if err != nil {
log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
continue
}
if same {
log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
continue
}
log.Infoln("[Provider] %s's proxies update", f.Name())
if f.onUpdate != nil {
f.onUpdate(elm)
}
</s> add update() </s> remove func (f *fetcher) pullLoop() {
</s> add func (f *fetcher) pullLoop(immediately bool) {
update := func() {
elm, same, err := f.Update()
if err != nil {
log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
return
}
if same {
log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
return
}
log.Infoln("[Provider] %s's proxies update", f.Name())
if f.onUpdate != nil {
f.onUpdate(elm)
}
}
if immediately {
update()
}
</s> remove go f.pullLoop()
</s> add go f.pullLoop(immediatelyUpdate) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
buf []byte
err error
isLocal bool
immediatelyUpdate bool | <mask> }
<mask>
<mask> func (f *fetcher) Initial() (any, error) {
<mask> var (
<mask> buf []byte
<mask> err error
<mask> isLocal bool
<mask> )
<mask> if stat, fErr := os.Stat(f.vehicle.Path()); fErr == nil {
<mask> buf, err = os.ReadFile(f.vehicle.Path())
<mask> modTime := stat.ModTime()
<mask> f.updatedAt = &modTime
</s> Fix: immediately update provider when modtime too old </s> remove func (f *fetcher) pullLoop() {
</s> add func (f *fetcher) pullLoop(immediately bool) {
update := func() {
elm, same, err := f.Update()
if err != nil {
log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
return
}
if same {
log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
return
}
log.Infoln("[Provider] %s's proxies update", f.Name())
if f.onUpdate != nil {
f.onUpdate(elm)
}
}
if immediately {
update()
}
</s> remove elm, same, err := f.Update()
if err != nil {
log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
continue
}
if same {
log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
continue
}
log.Infoln("[Provider] %s's proxies update", f.Name())
if f.onUpdate != nil {
f.onUpdate(elm)
}
</s> add update() </s> remove go f.pullLoop()
</s> add go f.pullLoop(immediatelyUpdate) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
immediatelyUpdate = time.Since(modTime) > f.interval | <mask> modTime := stat.ModTime()
<mask> f.updatedAt = &modTime
<mask> isLocal = true
<mask> } else {
<mask> buf, err = f.vehicle.Read()
<mask> }
<mask>
<mask> if err != nil {
<mask> return nil, err
</s> Fix: immediately update provider when modtime too old </s> remove buf []byte
err error
isLocal bool
</s> add buf []byte
err error
isLocal bool
immediatelyUpdate bool </s> remove func (f *fetcher) pullLoop() {
</s> add func (f *fetcher) pullLoop(immediately bool) {
update := func() {
elm, same, err := f.Update()
if err != nil {
log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
return
}
if same {
log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
return
}
log.Infoln("[Provider] %s's proxies update", f.Name())
if f.onUpdate != nil {
f.onUpdate(elm)
}
}
if immediately {
update()
}
</s> remove elm, same, err := f.Update()
if err != nil {
log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
continue
}
if same {
log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
continue
}
log.Infoln("[Provider] %s's proxies update", f.Name())
if f.onUpdate != nil {
f.onUpdate(elm)
}
</s> add update() </s> remove go f.pullLoop()
</s> add go f.pullLoop(immediatelyUpdate) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.