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 |
|---|---|---|---|---|
go f.pullLoop(immediatelyUpdate) | <mask> f.hash = md5.Sum(buf)
<mask>
<mask> // pull proxies automatically
<mask> if f.ticker != nil {
<mask> go f.pullLoop()
<mask> }
<mask>
<mask> return proxies, nil
<mask> }
<mask>
</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 buf []byte
err error
isLocal bool
</s> add buf []byte
err error
isLocal bool
immediatelyUpdate bool | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
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()
}
| <mask> }
<mask> return nil
<mask> }
<mask>
<mask> func (f *fetcher) pullLoop() {
<mask> for {
<mask> select {
<mask> case <-f.ticker.C:
<mask> elm, same, err := f.Update()
<mask> if err != nil {
</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 buf []byte
err error
isLocal bool
</s> add buf []byte
err error
isLocal bool
immediatelyUpdate bool </s> remove go f.pullLoop()
</s> add go f.pullLoop(immediatelyUpdate) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
update() | <mask> func (f *fetcher) pullLoop() {
<mask> for {
<mask> select {
<mask> case <-f.ticker.C:
<mask> elm, same, err := f.Update()
<mask> if err != nil {
<mask> log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
<mask> continue
<mask> }
<mask>
<mask> if same {
<mask> log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
<mask> continue
<mask> }
<mask>
<mask> log.Infoln("[Provider] %s's proxies update", f.Name())
<mask> if f.onUpdate != nil {
<mask> f.onUpdate(elm)
<mask> }
<mask> case <-f.done:
<mask> f.ticker.Stop()
<mask> return
<mask> }
<mask> }
</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 go f.pullLoop()
</s> add go f.pullLoop(immediatelyUpdate) </s> remove buf []byte
err error
isLocal bool
</s> add buf []byte
err error
isLocal bool
immediatelyUpdate bool | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
interval: interval, | <mask> name: name,
<mask> ticker: ticker,
<mask> vehicle: vehicle,
<mask> parser: parser,
<mask> done: make(chan struct{}, 1),
<mask> onUpdate: onUpdate,
<mask> }
<mask> }
</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) </s> remove buf []byte
err error
isLocal bool
</s> add buf []byte
err error
isLocal bool
immediatelyUpdate bool | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2301b909d25587f2846f049363af5b9b4769d098 | adapter/provider/fetcher.go |
<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> keepalive := true
<mask>
<mask> for {
<mask> if strings.ToLower(req.Header.Get("Connection")) == "close" {
<mask> keepalive = false
<mask> }
</s> Fix: http request keepAlive with right http header </s> remove if strings.ToLower(req.Header.Get("Connection")) == "close" {
keepalive = false
}
</s> add keepAlive := strings.TrimSpace(strings.ToLower(req.Header.Get("Proxy-Connection"))) == "keep-alive" </s> remove if !keepalive {
</s> add if !keepAlive { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/23bb01a4df2f1296856d60228710ba315d478c9f | tunnel/connection.go | |
keepAlive := strings.TrimSpace(strings.ToLower(req.Header.Get("Proxy-Connection"))) == "keep-alive" | <mask> host := req.Host
<mask> keepalive := true
<mask>
<mask> for {
<mask> if strings.ToLower(req.Header.Get("Connection")) == "close" {
<mask> keepalive = false
<mask> }
<mask>
<mask> req.Header.Set("Connection", "close")
<mask> req.RequestURI = ""
<mask> adapters.RemoveHopByHopHeaders(req.Header)
<mask> err := req.Write(conn)
</s> Fix: http request keepAlive with right http header </s> remove keepalive := true
</s> add </s> remove if !keepalive {
</s> add if !keepAlive { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/23bb01a4df2f1296856d60228710ba315d478c9f | tunnel/connection.go |
if !keepAlive { | <mask> if err != nil || resp.Close {
<mask> break
<mask> }
<mask>
<mask> if !keepalive {
<mask> break
<mask> }
<mask>
<mask> req, err = http.ReadRequest(bufio.NewReader(request.Conn()))
<mask> if err != nil {
</s> Fix: http request keepAlive with right http header </s> remove if strings.ToLower(req.Header.Get("Connection")) == "close" {
keepalive = false
}
</s> add keepAlive := strings.TrimSpace(strings.ToLower(req.Header.Get("Proxy-Connection"))) == "keep-alive" </s> remove keepalive := true
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/23bb01a4df2f1296856d60228710ba315d478c9f | tunnel/connection.go |
"net" | <mask> import (
<mask> "bytes"
<mask> "encoding/json"
<mask> "net/http"
<mask> "strings"
<mask> "time"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/log"
</s> Chore: logging real listen port (#1492) </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} </s> remove log.Infoln("RESTful API listening at: %s", addr)
err := http.ListenAndServe(addr, r)
</s> add l, err := net.Listen("tcp", addr) </s> remove log.Errorln("External controller error: %s", err.Error())
</s> add log.Errorln("External controller listen error: %s", err)
return
}
serverAddr = l.Addr().String()
log.Infoln("RESTful API listening at: %s", serverAddr)
if err = http.Serve(l, r); err != nil {
log.Errorln("External controller serve error: %s", err) </s> remove address string
</s> add </s> remove address: addr,
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | hub/route/server.go |
l, err := net.Listen("tcp", addr) | <mask> })
<mask> })
<mask> }
<mask>
<mask> log.Infoln("RESTful API listening at: %s", addr)
<mask> err := http.ListenAndServe(addr, r)
<mask> if err != nil {
<mask> log.Errorln("External controller error: %s", err.Error())
<mask> }
<mask> }
<mask>
</s> Chore: logging real listen port (#1492) </s> remove log.Errorln("External controller error: %s", err.Error())
</s> add log.Errorln("External controller listen error: %s", err)
return
}
serverAddr = l.Addr().String()
log.Infoln("RESTful API listening at: %s", serverAddr)
if err = http.Serve(l, r); err != nil {
log.Errorln("External controller serve error: %s", err) </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | hub/route/server.go |
log.Errorln("External controller listen error: %s", err)
return
}
serverAddr = l.Addr().String()
log.Infoln("RESTful API listening at: %s", serverAddr)
if err = http.Serve(l, r); err != nil {
log.Errorln("External controller serve error: %s", err) | <mask>
<mask> log.Infoln("RESTful API listening at: %s", addr)
<mask> err := http.ListenAndServe(addr, r)
<mask> if err != nil {
<mask> log.Errorln("External controller error: %s", err.Error())
<mask> }
<mask> }
<mask>
<mask> func authentication(next http.Handler) http.Handler {
<mask> fn := func(w http.ResponseWriter, r *http.Request) {
</s> Chore: logging real listen port (#1492) </s> remove log.Infoln("RESTful API listening at: %s", addr)
err := http.ListenAndServe(addr, r)
</s> add l, err := net.Listen("tcp", addr) </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | hub/route/server.go |
<mask> )
<mask>
<mask> type Listener struct {
<mask> listener net.Listener
<mask> address string
<mask> closed bool
<mask> }
<mask>
<mask> func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
<mask> return NewWithAuthenticate(addr, in, true)
</s> Chore: logging real listen port (#1492) </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/http/server.go | |
<mask> }
<mask>
<mask> hl := &Listener{
<mask> listener: l,
<mask> address: addr,
<mask> }
<mask> go func() {
<mask> for {
<mask> conn, err := hl.listener.Accept()
<mask> if err != nil {
</s> Chore: logging real listen port (#1492) </s> remove address: addr,
</s> add </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
</s> add ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/http/server.go | |
return l.listener.Addr().String() | <mask> l.listener.Close()
<mask> }
<mask>
<mask> func (l *Listener) Address() string {
<mask> return l.address
<mask> }
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/http/server.go |
<mask> )
<mask>
<mask> type Listener struct {
<mask> listener net.Listener
<mask> address string
<mask> closed bool
<mask> cache *cache.Cache
<mask> }
<mask>
<mask> func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
</s> Chore: logging real listen port (#1492) </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/mixed/mixed.go | |
ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
<mask> go func() {
<mask> for {
<mask> c, err := ml.listener.Accept()
<mask> if err != nil {
<mask> if ml.closed {
</s> Chore: logging real listen port (#1492) </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove address: addr,
</s> add </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} </s> remove address: addr,
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/mixed/mixed.go |
return l.listener.Addr().String() | <mask> l.listener.Close()
<mask> }
<mask>
<mask> func (l *Listener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
<mask> bufConn := N.NewBufferedConn(conn)
<mask> head, err := bufConn.Peek(1)
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/mixed/mixed.go |
<mask> )
<mask>
<mask> type Listener struct {
<mask> listener net.Listener
<mask> address string
<mask> closed bool
<mask> }
<mask>
<mask> func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
<mask> l, err := net.Listen("tcp", addr)
</s> Chore: logging real listen port (#1492) </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/redir/tcp.go | |
rl := &Listener{
listener: l,
} | <mask> l, err := net.Listen("tcp", addr)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> rl := &Listener{l, addr, false}
<mask>
<mask> go func() {
<mask> for {
<mask> c, err := l.Accept()
<mask> if err != nil {
</s> Chore: logging real listen port (#1492) </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove address: addr,
</s> add </s> remove ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
</s> add ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/redir/tcp.go |
return l.listener.Addr().String() | <mask> l.listener.Close()
<mask> }
<mask>
<mask> func (l *Listener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handleRedir(conn net.Conn, in chan<- C.ConnContext) {
<mask> target, err := parserPacket(conn)
<mask> if err != nil {
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/redir/tcp.go |
<mask> )
<mask>
<mask> type Listener struct {
<mask> listener net.Listener
<mask> address string
<mask> closed bool
<mask> }
<mask>
<mask> func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
<mask> l, err := net.Listen("tcp", addr)
</s> Chore: logging real listen port (#1492) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/socks/tcp.go | |
sl := &Listener{
listener: l,
} | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> sl := &Listener{l, addr, false}
<mask> go func() {
<mask> for {
<mask> c, err := l.Accept()
<mask> if err != nil {
<mask> if sl.closed {
</s> Chore: logging real listen port (#1492) </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
</s> add ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} </s> remove address: addr,
</s> add </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/socks/tcp.go |
return l.listener.Addr().String() | <mask> l.listener.Close()
<mask> }
<mask>
<mask> func (l *Listener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handleSocks(conn net.Conn, in chan<- C.ConnContext) {
<mask> bufConn := N.NewBufferedConn(conn)
<mask> head, err := bufConn.Peek(1)
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/socks/tcp.go |
<mask> )
<mask>
<mask> type UDPListener struct {
<mask> packetConn net.PacketConn
<mask> address string
<mask> closed bool
<mask> }
<mask>
<mask> func NewUDP(addr string, in chan<- *inbound.PacketAdapter) (*UDPListener, error) {
<mask> l, err := net.ListenPacket("udp", addr)
</s> Chore: logging real listen port (#1492) </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add </s> remove address string
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/socks/udp.go | |
sl := &UDPListener{
packetConn: l,
} | <mask> if err := sockopt.UDPReuseaddr(l.(*net.UDPConn)); err != nil {
<mask> log.Warnln("Failed to Reuse UDP Address: %s", err)
<mask> }
<mask>
<mask> sl := &UDPListener{l, addr, false}
<mask> go func() {
<mask> for {
<mask> buf := pool.Get(pool.RelayBufferSize)
<mask> n, remoteAddr, err := l.ReadFrom(buf)
<mask> if err != nil {
</s> Chore: logging real listen port (#1492) </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} </s> remove address: addr,
</s> add </s> remove ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
</s> add ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/socks/udp.go |
return l.packetConn.LocalAddr().String() | <mask> return l.packetConn.Close()
<mask> }
<mask>
<mask> func (l *UDPListener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handleSocksUDP(pc net.PacketConn, in chan<- *inbound.PacketAdapter, buf []byte, addr net.Addr) {
<mask> target, payload, err := socks5.DecodeUDPPacket(buf)
<mask> if err != nil {
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/socks/udp.go |
<mask> )
<mask>
<mask> type Listener struct {
<mask> listener net.Listener
<mask> address string
<mask> closed bool
<mask> }
<mask>
<mask> func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
<mask> l, err := net.Listen("tcp", addr)
</s> Chore: logging real listen port (#1492) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/tproxy/tproxy.go | |
<mask> }
<mask>
<mask> rl := &Listener{
<mask> listener: l,
<mask> address: addr,
<mask> }
<mask>
<mask> go func() {
<mask> for {
<mask> c, err := l.Accept()
</s> Chore: logging real listen port (#1492) </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove address: addr,
</s> add </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
</s> add ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} </s> remove rl := &UDPListener{l, addr, false}
</s> add rl := &UDPListener{
packetConn: l,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/tproxy/tproxy.go | |
return l.listener.Addr().String() | <mask> l.listener.Close()
<mask> }
<mask>
<mask> func (l *Listener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func (l *Listener) handleTProxy(conn net.Conn, in chan<- C.ConnContext) {
<mask> target := socks5.ParseAddrToSocksAddr(conn.LocalAddr())
<mask> conn.(*net.TCPConn).SetKeepAlive(true)
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/tproxy/tproxy.go |
<mask> )
<mask>
<mask> type UDPListener struct {
<mask> packetConn net.PacketConn
<mask> address string
<mask> closed bool
<mask> }
<mask>
<mask> func NewUDP(addr string, in chan<- *inbound.PacketAdapter) (*UDPListener, error) {
<mask> l, err := net.ListenPacket("udp", addr)
</s> Chore: logging real listen port (#1492) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/tproxy/udp.go | |
rl := &UDPListener{
packetConn: l,
} | <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> rl := &UDPListener{l, addr, false}
<mask>
<mask> c := l.(*net.UDPConn)
<mask>
<mask> rc, err := c.SyscallConn()
<mask> if err != nil {
</s> Chore: logging real listen port (#1492) </s> remove rl := &Listener{l, addr, false}
</s> add rl := &Listener{
listener: l,
} </s> remove sl := &Listener{l, addr, false}
</s> add sl := &Listener{
listener: l,
} </s> remove sl := &UDPListener{l, addr, false}
</s> add sl := &UDPListener{
packetConn: l,
} </s> remove ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
</s> add ml := &Listener{
listener: l,
cache: cache.New(30 * time.Second),
} </s> remove address: addr,
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/tproxy/udp.go |
return l.packetConn.LocalAddr().String() | <mask> return l.packetConn.Close()
<mask> }
<mask>
<mask> func (l *UDPListener) Address() string {
<mask> return l.address
<mask> }
<mask>
<mask> func handlePacketConn(pc net.PacketConn, in chan<- *inbound.PacketAdapter, buf []byte, lAddr *net.UDPAddr, rAddr *net.UDPAddr) {
<mask> target := socks5.ParseAddrToSocksAddr(rAddr)
<mask> pkt := &packet{
</s> Chore: logging real listen port (#1492) </s> remove return l.address
</s> add return l.packetConn.LocalAddr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() </s> remove return l.address
</s> add return l.listener.Addr().String() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/247dd84970f00f2e1f43fac3b73cb710ff4f5a5d | listener/tproxy/udp.go |
<mask> mux.Lock()
<mask> defer mux.Unlock()
<mask>
<mask> updateUsers(cfg.Users)
<mask> updateGeneral(cfg.General, force)
<mask> updateProxies(cfg.Proxies, cfg.Providers)
<mask> updateRules(cfg.Rules)
<mask> updateDNS(cfg.DNS)
<mask> updateHosts(cfg.Hosts)
<mask> updateExperimental(cfg)
</s> Fix: reorder apply config to ensure update proxies and rules </s> remove updateExperimental(cfg)
</s> add </s> remove updateDNS(cfg.DNS)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/250a9f4f847cad95f1960d280603d4bf07991d47 | hub/executor/executor.go | |
<mask> updateUsers(cfg.Users)
<mask> updateGeneral(cfg.General, force)
<mask> updateProxies(cfg.Proxies, cfg.Providers)
<mask> updateRules(cfg.Rules)
<mask> updateDNS(cfg.DNS)
<mask> updateHosts(cfg.Hosts)
<mask> updateExperimental(cfg)
<mask> updateProfile(cfg)
<mask> }
<mask>
</s> Fix: reorder apply config to ensure update proxies and rules </s> remove updateExperimental(cfg)
</s> add </s> remove updateGeneral(cfg.General, force)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/250a9f4f847cad95f1960d280603d4bf07991d47 | hub/executor/executor.go | |
<mask> updateProxies(cfg.Proxies, cfg.Providers)
<mask> updateRules(cfg.Rules)
<mask> updateDNS(cfg.DNS)
<mask> updateHosts(cfg.Hosts)
<mask> updateExperimental(cfg)
<mask> updateProfile(cfg)
<mask> }
<mask>
<mask> func GetGeneral() *config.General {
<mask> ports := P.GetPorts()
</s> Fix: reorder apply config to ensure update proxies and rules </s> remove updateGeneral(cfg.General, force)
</s> add </s> remove updateDNS(cfg.DNS)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/250a9f4f847cad95f1960d280603d4bf07991d47 | hub/executor/executor.go | |
updateGeneral(cfg.General, force)
updateDNS(cfg.DNS)
updateExperimental(cfg) | <mask> updateHosts(cfg.Hosts)
<mask> updateProfile(cfg)
<mask> }
<mask>
<mask> func GetGeneral() *config.General {
<mask> ports := P.GetPorts()
</s> Fix: reorder apply config to ensure update proxies and rules </s> remove updateGeneral(cfg.General, force)
</s> add </s> remove updateExperimental(cfg)
</s> add </s> remove updateDNS(cfg.DNS)
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/250a9f4f847cad95f1960d280603d4bf07991d47 | hub/executor/executor.go |
// updating TTL by subtracting common delta time from each DNS record
updateMsgTTL(msg, uint32(time.Until(expireTime).Seconds())) | <mask> if expireTime.Before(now) {
<mask> setMsgTTL(msg, uint32(1)) // Continue fetch
<mask> go r.exchangeWithoutCache(ctx, m)
<mask> } else {
<mask> setMsgTTL(msg, uint32(time.Until(expireTime).Seconds()))
<mask> }
<mask> return
<mask> }
<mask> return r.exchangeWithoutCache(ctx, m)
<mask> }
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove ttl = msg.Extra[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Extra) </s> remove ttl = msg.Ns[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Ns) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/resolver.go |
"github.com/samber/lo" | <mask>
<mask> D "github.com/miekg/dns"
<mask> )
<mask>
<mask> func minimalTTL(records []D.RR) uint32 {
<mask> return lo.MinBy(records, func(r1 D.RR, r2 D.RR) bool {
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove setMsgTTL(msg, uint32(time.Until(expireTime).Seconds()))
</s> add // updating TTL by subtracting common delta time from each DNS record
updateMsgTTL(msg, uint32(time.Until(expireTime).Seconds())) </s> remove ttl = msg.Answer[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Answer) </s> remove ttl = msg.Ns[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Ns) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/util.go |
func minimalTTL(records []D.RR) uint32 {
return lo.MinBy(records, func(r1 D.RR, r2 D.RR) bool {
return r1.Header().Ttl < r2.Header().Ttl
}).Header().Ttl
}
func updateTTL(records []D.RR, ttl uint32) {
if len(records) == 0 {
return
}
delta := minimalTTL(records) - ttl
for i := range records {
records[i].Header().Ttl = lo.Clamp(records[i].Header().Ttl-delta, 1, records[i].Header().Ttl)
}
}
| <mask> "github.com/samber/lo"
<mask> )
<mask>
<mask> func putMsgToCache(c *cache.LruCache, key string, q D.Question, msg *D.Msg) {
<mask> // skip dns cache for acme challenge
<mask> if q.Qtype == D.TypeTXT && strings.HasPrefix(q.Name, "_acme-challenge.") {
<mask> log.Debugln("[DNS] dns cache ignored because of acme challenge for: %s", q.Name)
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove setMsgTTL(msg, uint32(time.Until(expireTime).Seconds()))
</s> add // updating TTL by subtracting common delta time from each DNS record
updateMsgTTL(msg, uint32(time.Until(expireTime).Seconds())) </s> remove ttl = msg.Ns[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Ns) </s> remove ttl = msg.Answer[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Answer) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/util.go |
ttl = minimalTTL(msg.Answer) | <mask>
<mask> var ttl uint32
<mask> switch {
<mask> case len(msg.Answer) != 0:
<mask> ttl = msg.Answer[0].Header().Ttl
<mask> case len(msg.Ns) != 0:
<mask> ttl = msg.Ns[0].Header().Ttl
<mask> case len(msg.Extra) != 0:
<mask> ttl = msg.Extra[0].Header().Ttl
<mask> default:
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove ttl = msg.Ns[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Ns) </s> remove ttl = msg.Extra[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Extra) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/util.go |
ttl = minimalTTL(msg.Ns) | <mask> switch {
<mask> case len(msg.Answer) != 0:
<mask> ttl = msg.Answer[0].Header().Ttl
<mask> case len(msg.Ns) != 0:
<mask> ttl = msg.Ns[0].Header().Ttl
<mask> case len(msg.Extra) != 0:
<mask> ttl = msg.Extra[0].Header().Ttl
<mask> default:
<mask> log.Debugln("[DNS] response msg empty: %#v", msg)
<mask> return
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove ttl = msg.Extra[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Extra) </s> remove ttl = msg.Answer[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Answer) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/util.go |
ttl = minimalTTL(msg.Extra) | <mask> ttl = msg.Answer[0].Header().Ttl
<mask> case len(msg.Ns) != 0:
<mask> ttl = msg.Ns[0].Header().Ttl
<mask> case len(msg.Extra) != 0:
<mask> ttl = msg.Extra[0].Header().Ttl
<mask> default:
<mask> log.Debugln("[DNS] response msg empty: %#v", msg)
<mask> return
<mask> }
<mask>
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove ttl = msg.Ns[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Ns) </s> remove ttl = msg.Answer[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Answer) </s> remove setMsgTTL(msg, uint32(time.Until(expireTime).Seconds()))
</s> add // updating TTL by subtracting common delta time from each DNS record
updateMsgTTL(msg, uint32(time.Until(expireTime).Seconds())) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/util.go |
func updateMsgTTL(msg *D.Msg, ttl uint32) {
updateTTL(msg.Answer, ttl)
updateTTL(msg.Ns, ttl)
updateTTL(msg.Extra, ttl)
}
| <mask> extra.Header().Ttl = ttl
<mask> }
<mask> }
<mask>
<mask> func isIPRequest(q D.Question) bool {
<mask> return q.Qclass == D.ClassINET && (q.Qtype == D.TypeA || q.Qtype == D.TypeAAAA)
<mask> }
<mask>
<mask> func transform(servers []NameServer, resolver *Resolver) []dnsClient {
</s> Fix: adjust DNS TTL values based on minimum value (#2706)
This commit adds an updated function that adjusts
the TTL values of DNS records are based on the minimum TTL
the value found in the records list so that all records share the
same TTL value. This ensures consistency in the cache
expiry time for all records to prevent caching issues. </s> remove setMsgTTL(msg, uint32(time.Until(expireTime).Seconds()))
</s> add // updating TTL by subtracting common delta time from each DNS record
updateMsgTTL(msg, uint32(time.Until(expireTime).Seconds())) </s> remove ttl = msg.Extra[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Extra) </s> remove ttl = msg.Ns[0].Header().Ttl
</s> add ttl = minimalTTL(msg.Ns) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/257fcef0b817c2cd461640dc6e9a808a3257f942 | dns/util.go |
"github.com/stretchr/testify/assert" | <mask> "runtime"
<mask> "testing"
<mask> "time"
<mask> )
<mask>
<mask> func TestCache_Basic(t *testing.T) {
<mask> interval := 200 * time.Millisecond
<mask> ttl := 20 * time.Millisecond
<mask> c := New(interval)
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if s.(string) != "a" {
t.Error("should recv 'a'")
}
</s> add assert.Equal(t, s.(string), "a", "should recv 'a'") </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
assert.Equal(t, i.(int), 1, "should recv 1") | <mask> c.Put("int", 1, ttl)
<mask> c.Put("string", "a", ttl)
<mask>
<mask> i := c.Get("int")
<mask> if i.(int) != 1 {
<mask> t.Error("should recv 1")
<mask> }
<mask>
<mask> s := c.Get("string")
<mask> if s.(string) != "a" {
<mask> t.Error("should recv 'a'")
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if s.(string) != "a" {
t.Error("should recv 'a'")
}
</s> add assert.Equal(t, s.(string), "a", "should recv 'a'") </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add _, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
assert.Equal(t, s.(string), "a", "should recv 'a'") | <mask> t.Error("should recv 1")
<mask> }
<mask>
<mask> s := c.Get("string")
<mask> if s.(string) != "a" {
<mask> t.Error("should recv 'a'")
<mask> }
<mask> }
<mask>
<mask> func TestCache_TTL(t *testing.T) {
<mask> interval := 200 * time.Millisecond
<mask> ttl := 20 * time.Millisecond
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add assert.Equal(t, i.(int), 1, "should recv 1") </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add _, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
now := time.Now() | <mask> interval := 200 * time.Millisecond
<mask> ttl := 20 * time.Millisecond
<mask> c := New(interval)
<mask> c.Put("int", 1, ttl)
<mask> c.Put("int2", 2, ttl)
<mask>
<mask> i := c.Get("int")
<mask> _, expired := c.GetWithExpire("int2")
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add _, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") </s> remove if s.(string) != "a" {
t.Error("should recv 'a'")
}
</s> add assert.Equal(t, s.(string), "a", "should recv 'a'") | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
c.Put("int2", 2, ttl) | <mask> ttl := 20 * time.Millisecond
<mask> now := time.Now()
<mask> c := New(interval)
<mask> c.Put("int", 1, ttl)
<mask>
<mask> i := c.Get("int")
<mask> _, expired := c.GetWithExpire("int2")
<mask> assert.Equal(t, i.(int), 1, "should recv 1")
<mask> assert.True(t, now.Before(expired))
<mask>
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add _, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add assert.Equal(t, i.(int), 1, "should recv 1") </s> remove if s.(string) != "a" {
t.Error("should recv 'a'")
}
</s> add assert.Equal(t, s.(string), "a", "should recv 'a'") </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
_, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) | <mask> c := New(interval)
<mask> c.Put("int", 1, ttl)
<mask>
<mask> i := c.Get("int")
<mask> if i.(int) != 1 {
<mask> t.Error("should recv 1")
<mask> }
<mask>
<mask> time.Sleep(ttl * 2)
<mask> i = c.Get("int")
<mask> if i != nil {
<mask> t.Error("should recv nil")
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add assert.Equal(t, i.(int), 1, "should recv 1") </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") | <mask> }
<mask>
<mask> time.Sleep(ttl * 2)
<mask> i = c.Get("int")
<mask> if i != nil {
<mask> t.Error("should recv nil")
<mask> }
<mask> }
<mask>
<mask> func TestCache_AutoCleanup(t *testing.T) {
<mask> interval := 10 * time.Millisecond
<mask> ttl := 15 * time.Millisecond
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add _, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) </s> remove if s.(string) != "a" {
t.Error("should recv 'a'")
}
</s> add assert.Equal(t, s.(string), "a", "should recv 'a'") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
j, _ := c.GetWithExpire("int")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") | <mask> c.Put("int", 1, ttl)
<mask>
<mask> time.Sleep(ttl * 2)
<mask> i := c.Get("int")
<mask> if i != nil {
<mask> t.Error("should recv nil")
<mask> }
<mask> }
<mask>
<mask> func TestCache_AutoGC(t *testing.T) {
<mask> sign := make(chan struct{})
<mask> go func() {
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add _, expired := c.GetWithExpire("int2")
assert.Equal(t, i.(int), 1, "should recv 1")
assert.True(t, now.Before(expired)) </s> remove if i != nil {
t.Error("should recv nil")
}
</s> add j, _ := c.GetWithExpire("int2")
assert.Nil(t, i, "should recv nil")
assert.Nil(t, j, "should recv nil") </s> remove if i.(int) != 1 {
t.Error("should recv 1")
}
</s> add assert.Equal(t, i.(int), 1, "should recv 1") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | common/cache/cache_test.go |
"github.com/Dreamacro/clash/common/cache" | <mask> "errors"
<mask> "net"
<mask> "sync"
<mask> )
<mask>
<mask> // Pool is a implementation about fake ip generator without storage
<mask> type Pool struct {
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { </s> remove func New(ipnet *net.IPNet) (*Pool, error) {
min := ipToUint(ipnet.IP) + 1
</s> add func New(ipnet *net.IPNet, size int) (*Pool, error) {
min := ipToUint(ipnet.IP) + 2 </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip | <mask> )
<mask>
<mask> // Pool is a implementation about fake ip generator without storage
<mask> type Pool struct {
<mask> max uint32
<mask> min uint32
<mask> offset uint32
<mask> mux *sync.Mutex
<mask> }
<mask>
<mask> // Get return a new fake ip
<mask> func (p *Pool) Get() net.IP {
<mask> p.mux.Lock()
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove func New(ipnet *net.IPNet) (*Pool, error) {
min := ipToUint(ipnet.IP) + 1
</s> add func New(ipnet *net.IPNet, size int) (*Pool, error) {
min := ipToUint(ipnet.IP) + 2 </s> remove max := min + uint32(total)
</s> add max := min + uint32(total) - 1 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
// LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { | <mask> offset uint32
<mask> mux *sync.Mutex
<mask> }
<mask>
<mask> // Get return a new fake ip
<mask> func (p *Pool) Get() net.IP {
<mask> p.mux.Lock()
<mask> defer p.mux.Unlock()
<mask> ip := uintToIP(p.min + p.offset)
<mask> p.offset = (p.offset + 1) % (p.max - p.min)
<mask> return ip
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") </s> remove putMsgToCache(cache, "fakeip:"+q.String(), msg)
putMsgToCache(cache, ip.String(), msg)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) | <mask> // Get return a new fake ip
<mask> func (p *Pool) Get() net.IP {
<mask> p.mux.Lock()
<mask> defer p.mux.Unlock()
<mask> ip := uintToIP(p.min + p.offset)
<mask> p.offset = (p.offset + 1) % (p.max - p.min)
<mask> return ip
<mask> }
<mask>
<mask> func ipToUint(ip net.IP) uint32 {
<mask> v := uint32(ip[0]) << 24
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") </s> remove putMsgToCache(cache, "fakeip:"+q.String(), msg)
putMsgToCache(cache, ip.String(), msg)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
func New(ipnet *net.IPNet, size int) (*Pool, error) {
min := ipToUint(ipnet.IP) + 2 | <mask> return net.IPv4(byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
<mask> }
<mask>
<mask> // New return Pool instance
<mask> func New(ipnet *net.IPNet) (*Pool, error) {
<mask> min := ipToUint(ipnet.IP) + 1
<mask>
<mask> ones, bits := ipnet.Mask.Size()
<mask> total := 1<<uint(bits-ones) - 2
<mask>
<mask> if total <= 0 {
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove max := min + uint32(total)
</s> add max := min + uint32(total) - 1 </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { </s> remove min: min,
max: max,
mux: &sync.Mutex{},
</s> add min: min,
max: max,
gateway: min - 1,
mux: &sync.Mutex{},
cache: cache.NewLRUCache(cache.WithSize(size * 2)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
max := min + uint32(total) - 1 | <mask> if total <= 0 {
<mask> return nil, errors.New("ipnet don't have valid ip")
<mask> }
<mask>
<mask> max := min + uint32(total)
<mask> return &Pool{
<mask> min: min,
<mask> max: max,
<mask> mux: &sync.Mutex{},
<mask> }, nil
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove min: min,
max: max,
mux: &sync.Mutex{},
</s> add min: min,
max: max,
gateway: min - 1,
mux: &sync.Mutex{},
cache: cache.NewLRUCache(cache.WithSize(size * 2)), </s> remove func New(ipnet *net.IPNet) (*Pool, error) {
min := ipToUint(ipnet.IP) + 1
</s> add func New(ipnet *net.IPNet, size int) (*Pool, error) {
min := ipToUint(ipnet.IP) + 2 </s> remove pool, err := fakeip.New(ipnet)
</s> add pool, err := fakeip.New(ipnet, 1000) </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
min: min,
max: max,
gateway: min - 1,
mux: &sync.Mutex{},
cache: cache.NewLRUCache(cache.WithSize(size * 2)), | <mask> }
<mask>
<mask> max := min + uint32(total)
<mask> return &Pool{
<mask> min: min,
<mask> max: max,
<mask> mux: &sync.Mutex{},
<mask> }, nil
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove max := min + uint32(total)
</s> add max := min + uint32(total) - 1 </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove func New(ipnet *net.IPNet) (*Pool, error) {
min := ipToUint(ipnet.IP) + 1
</s> add func New(ipnet *net.IPNet, size int) (*Pool, error) {
min := ipToUint(ipnet.IP) + 2 </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove _, err := New(ipnet)
</s> add _, err := New(ipnet, 10) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool.go |
"github.com/stretchr/testify/assert" | <mask> "net"
<mask> "testing"
<mask> )
<mask>
<mask> func TestPool_Basic(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
pool, _ := New(ipnet)
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) </s> remove first := pool.Get()
last := pool.Get()
</s> add first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) </s> remove if err == nil {
t.Error("should return err")
}
</s> add assert.Error(t, err) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
_, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) | <mask> "testing"
<mask> )
<mask>
<mask> func TestPool_Basic(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
<mask> pool, _ := New(ipnet)
<mask>
<mask> first := pool.Get()
<mask> last := pool.Get()
<mask>
<mask> if !first.Equal(net.IP{192, 168, 0, 1}) {
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove first := pool.Get()
last := pool.Get()
</s> add first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) </s> remove if !first.Equal(net.IP{192, 168, 0, 1}) {
t.Error("should get right first ip, instead of", first.String())
}
if !last.Equal(net.IP{192, 168, 0, 2}) {
t.Error("should get right last ip, instead of", first.String())
}
</s> add assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
assert.True(t, exist)
assert.Equal(t, bar, "bar.com") </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) | <mask> func TestPool_Basic(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
<mask> pool, _ := New(ipnet)
<mask>
<mask> first := pool.Get()
<mask> last := pool.Get()
<mask>
<mask> if !first.Equal(net.IP{192, 168, 0, 1}) {
<mask> t.Error("should get right first ip, instead of", first.String())
<mask> }
<mask>
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if !first.Equal(net.IP{192, 168, 0, 1}) {
t.Error("should get right first ip, instead of", first.String())
}
if !last.Equal(net.IP{192, 168, 0, 2}) {
t.Error("should get right last ip, instead of", first.String())
}
</s> add assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
assert.True(t, exist)
assert.Equal(t, bar, "bar.com") </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
pool, _ := New(ipnet)
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
assert.True(t, exist)
assert.Equal(t, bar, "bar.com") | <mask>
<mask> first := pool.Get()
<mask> last := pool.Get()
<mask>
<mask> if !first.Equal(net.IP{192, 168, 0, 1}) {
<mask> t.Error("should get right first ip, instead of", first.String())
<mask> }
<mask>
<mask> if !last.Equal(net.IP{192, 168, 0, 2}) {
<mask> t.Error("should get right last ip, instead of", first.String())
<mask> }
<mask> }
<mask>
<mask> func TestPool_Cycle(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
<mask> pool, _ := New(ipnet)
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove first := pool.Get()
last := pool.Get()
</s> add first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
pool, _ := New(ipnet)
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) | <mask> }
<mask>
<mask> func TestPool_Cycle(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
<mask> pool, _ := New(ipnet)
<mask>
<mask> first := pool.Get()
<mask> pool.Get()
<mask> same := pool.Get()
<mask>
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
pool, _ := New(ipnet)
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) </s> remove first := pool.Get()
last := pool.Get()
</s> add first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) </s> remove if !first.Equal(net.IP{192, 168, 0, 1}) {
t.Error("should get right first ip, instead of", first.String())
}
if !last.Equal(net.IP{192, 168, 0, 2}) {
t.Error("should get right last ip, instead of", first.String())
}
</s> add assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
assert.True(t, exist)
assert.Equal(t, bar, "bar.com") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") | <mask> func TestPool_Cycle(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
<mask> pool, _ := New(ipnet)
<mask>
<mask> first := pool.Get()
<mask> pool.Get()
<mask> same := pool.Get()
<mask>
<mask> if !first.Equal(same) {
<mask> t.Error("should return same ip", first.String())
<mask> }
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) </s> remove first := pool.Get()
last := pool.Get()
</s> add first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) </s> remove if !first.Equal(net.IP{192, 168, 0, 1}) {
t.Error("should get right first ip, instead of", first.String())
}
if !last.Equal(net.IP{192, 168, 0, 2}) {
t.Error("should get right last ip, instead of", first.String())
}
</s> add assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
assert.True(t, exist)
assert.Equal(t, bar, "bar.com") </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
pool, _ := New(ipnet)
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
assert.False(t, first.Equal(next)) | <mask> first := pool.Get()
<mask> pool.Get()
<mask> same := pool.Get()
<mask>
<mask> if !first.Equal(same) {
<mask> t.Error("should return same ip", first.String())
<mask> }
<mask> }
<mask>
<mask> func TestPool_Error(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/31")
<mask> _, err := New(ipnet)
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) </s> remove _, err := New(ipnet)
</s> add _, err := New(ipnet, 10) </s> remove if err == nil {
t.Error("should return err")
}
</s> add assert.Error(t, err) </s> remove first := pool.Get()
last := pool.Get()
</s> add first := pool.Lookup("foo.com")
last := pool.Lookup("bar.com")
bar, exist := pool.LookBack(last) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
_, err := New(ipnet, 10) | <mask> }
<mask>
<mask> func TestPool_Error(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/31")
<mask> _, err := New(ipnet)
<mask>
<mask> if err == nil {
<mask> t.Error("should return err")
<mask> }
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove if err == nil {
t.Error("should return err")
}
</s> add assert.Error(t, err) </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) </s> remove pool, err := fakeip.New(ipnet)
</s> add pool, err := fakeip.New(ipnet, 1000) </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
assert.Error(t, err) | <mask> func TestPool_Error(t *testing.T) {
<mask> _, ipnet, _ := net.ParseCIDR("192.168.0.1/31")
<mask> _, err := New(ipnet)
<mask>
<mask> if err == nil {
<mask> t.Error("should return err")
<mask> }
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove _, err := New(ipnet)
</s> add _, err := New(ipnet, 10) </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) </s> remove pool, err := fakeip.New(ipnet)
</s> add pool, err := fakeip.New(ipnet, 1000) </s> remove first := pool.Get()
pool.Get()
same := pool.Get()
</s> add first := pool.Lookup("foo.com")
pool.Lookup("bar.com")
pool.Lookup("baz.com")
next := pool.Lookup("foo.com") </s> remove pool, _ := New(ipnet)
</s> add pool, _ := New(ipnet, 10)
first := pool.Lookup("foo.com")
same := pool.Lookup("baz.com")
assert.True(t, first.Equal(same))
}
func TestPool_MaxCacheSize(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
pool, _ := New(ipnet, 2) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | component/fakeip/pool_test.go |
pool, err := fakeip.New(ipnet, 1000) | <mask> _, ipnet, err := net.ParseCIDR(cfg.FakeIPRange)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> pool, err := fakeip.New(ipnet)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> dnsCfg.FakeIPRange = pool
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove _, err := New(ipnet)
</s> add _, err := New(ipnet, 10) </s> remove if err == nil {
t.Error("should return err")
}
</s> add assert.Error(t, err) </s> remove if !first.Equal(same) {
t.Error("should return same ip", first.String())
}
</s> add assert.False(t, first.Equal(next)) </s> remove max := min + uint32(total)
</s> add max := min + uint32(total) - 1 </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | config/config.go |
<mask> "fmt"
<mask> "net"
<mask> "strings"
<mask>
<mask> "github.com/Dreamacro/clash/common/cache"
<mask> "github.com/Dreamacro/clash/component/fakeip"
<mask> "github.com/Dreamacro/clash/log"
<mask>
<mask> D "github.com/miekg/dns"
<mask> )
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove _, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
pool, _ := New(ipnet)
</s> add _, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
pool, _ := New(ipnet, 10) </s> remove func withFakeIP(cache *cache.Cache, pool *fakeip.Pool) handler {
</s> add func withFakeIP(pool *fakeip.Pool) handler { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go | |
func withFakeIP(pool *fakeip.Pool) handler { | <mask> )
<mask>
<mask> type handler func(w D.ResponseWriter, r *D.Msg)
<mask>
<mask> func withFakeIP(cache *cache.Cache, pool *fakeip.Pool) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask>
<mask> cacheItem := cache.Get("fakeip:" + q.String())
<mask> if cacheItem != nil {
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") </s> remove return withFakeIP(resolver.cache, resolver.pool)
</s> add return withFakeIP(resolver.pool) </s> remove pool, err := fakeip.New(ipnet)
</s> add pool, err := fakeip.New(ipnet, 1000) </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove func New(ipnet *net.IPNet) (*Pool, error) {
min := ipToUint(ipnet.IP) + 1
</s> add func New(ipnet *net.IPNet, size int) (*Pool, error) {
min := ipToUint(ipnet.IP) + 2 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go |
host := strings.TrimRight(q.Name, ".") | <mask>
<mask> func withFakeIP(cache *cache.Cache, pool *fakeip.Pool) handler {
<mask> return func(w D.ResponseWriter, r *D.Msg) {
<mask> q := r.Question[0]
<mask>
<mask> cacheItem := cache.Get("fakeip:" + q.String())
<mask> if cacheItem != nil {
<mask> msg := cacheItem.(*D.Msg).Copy()
<mask> setMsgTTL(msg, 1)
<mask> msg.SetReply(r)
<mask> w.WriteMsg(msg)
<mask> return
<mask> }
<mask>
<mask> rr := &D.A{}
<mask> rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
<mask> ip := pool.Get()
<mask> rr.A = ip
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove func withFakeIP(cache *cache.Cache, pool *fakeip.Pool) handler {
</s> add func withFakeIP(pool *fakeip.Pool) handler { </s> remove ip := pool.Get()
</s> add ip := pool.Lookup(host) </s> remove putMsgToCache(cache, "fakeip:"+q.String(), msg)
putMsgToCache(cache, ip.String(), msg)
</s> add </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go |
ip := pool.Lookup(host) | <mask> }
<mask>
<mask> rr := &D.A{}
<mask> rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
<mask> ip := pool.Get()
<mask> rr.A = ip
<mask> msg := r.Copy()
<mask> msg.Answer = []D.RR{rr}
<mask> putMsgToCache(cache, "fakeip:"+q.String(), msg)
<mask> putMsgToCache(cache, ip.String(), msg)
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove putMsgToCache(cache, "fakeip:"+q.String(), msg)
putMsgToCache(cache, ip.String(), msg)
</s> add </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go |
<mask> ip := pool.Get()
<mask> rr.A = ip
<mask> msg := r.Copy()
<mask> msg.Answer = []D.RR{rr}
<mask> putMsgToCache(cache, "fakeip:"+q.String(), msg)
<mask> putMsgToCache(cache, ip.String(), msg)
<mask>
<mask> setMsgTTL(msg, 1)
<mask> w.WriteMsg(msg)
<mask> return
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove ip := pool.Get()
</s> add ip := pool.Lookup(host) </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go | |
msg.SetReply(r) | <mask> msg := r.Copy()
<mask> msg.Answer = []D.RR{rr}
<mask>
<mask> setMsgTTL(msg, 1)
<mask> w.WriteMsg(msg)
<mask> return
<mask> }
<mask> }
<mask>
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove putMsgToCache(cache, "fakeip:"+q.String(), msg)
putMsgToCache(cache, ip.String(), msg)
</s> add </s> remove ip := pool.Get()
</s> add ip := pool.Lookup(host) </s> remove
cacheItem := cache.Get("fakeip:" + q.String())
if cacheItem != nil {
msg := cacheItem.(*D.Msg).Copy()
setMsgTTL(msg, 1)
msg.SetReply(r)
w.WriteMsg(msg)
return
}
</s> add host := strings.TrimRight(q.Name, ".") </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove pool, err := fakeip.New(ipnet)
</s> add pool, err := fakeip.New(ipnet, 1000) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go |
return withFakeIP(resolver.pool) | <mask> }
<mask>
<mask> func newHandler(resolver *Resolver) handler {
<mask> if resolver.IsFakeIP() {
<mask> return withFakeIP(resolver.cache, resolver.pool)
<mask> }
<mask>
<mask> if resolver.hosts != nil {
<mask> return withHost(resolver, withResolver(resolver))
<mask> }
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove func withFakeIP(cache *cache.Cache, pool *fakeip.Pool) handler {
</s> add func withFakeIP(pool *fakeip.Pool) handler { </s> remove pool, err := fakeip.New(ipnet)
</s> add pool, err := fakeip.New(ipnet, 1000) </s> remove _, err := New(ipnet)
</s> add _, err := New(ipnet, 10) </s> remove if err == nil {
t.Error("should return err")
}
</s> add assert.Error(t, err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/middleware.go |
if r.fakeip {
return r.pool.LookBack(ip)
}
| <mask> }
<mask>
<mask> // IPToHost return fake-ip or redir-host mapping host
<mask> func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
<mask> cache := r.cache.Get(ip.String())
<mask> if cache == nil {
<mask> return "", false
<mask> }
<mask> fqdn := cache.(*D.Msg).Question[0].Name
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove _, err := New(ipnet)
</s> add _, err := New(ipnet, 10) </s> remove if err == nil {
t.Error("should return err")
}
</s> add assert.Error(t, err) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | dns/resolver.go |
github.com/stretchr/testify v1.2.2 | <mask> github.com/oschwald/geoip2-golang v1.3.0
<mask> github.com/oschwald/maxminddb-golang v1.3.1 // indirect
<mask> github.com/sirupsen/logrus v1.4.2
<mask> golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734
<mask> golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3
<mask> golang.org/x/sync v0.0.0-20190423024810-112230192c58
<mask> gopkg.in/eapache/channels.v1 v1.1.0
<mask> gopkg.in/yaml.v2 v2.2.2
</s> Improve(fakeip): use lru cache to avoid outdate </s> remove // Get return a new fake ip
func (p *Pool) Get() net.IP {
</s> add // LookBack return host with the fake ip
func (p *Pool) LookBack(ip net.IP) (string, bool) { </s> remove max uint32
min uint32
offset uint32
mux *sync.Mutex
</s> add max uint32
min uint32
gateway uint32
offset uint32
mux *sync.Mutex
cache *cache.LruCache
}
// Lookup return a fake ip with host
func (p *Pool) Lookup(host string) net.IP {
p.mux.Lock()
defer p.mux.Unlock()
if ip, exist := p.cache.Get(host); exist {
return ip.(net.IP)
}
ip := p.get(host)
p.cache.Set(host, ip)
return ip </s> remove ip := uintToIP(p.min + p.offset)
p.offset = (p.offset + 1) % (p.max - p.min)
</s> add if ip = ip.To4(); ip == nil {
return "", false
}
n := ipToUint(ip.To4())
offset := n - p.min + 1
if host, exist := p.cache.Get(offset); exist {
return host.(string), true
}
return "", false
}
// Gateway return gateway ip
func (p *Pool) Gateway() net.IP {
return uintToIP(p.gateway)
}
func (p *Pool) get(host string) net.IP {
current := p.offset
for {
p.offset = (p.offset + 1) % (p.max - p.min)
// Avoid infinite loops
if p.offset == current {
break
}
if _, exist := p.cache.Get(p.offset); !exist {
break
}
}
ip := uintToIP(p.min + p.offset - 1)
p.cache.Set(p.offset, host) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/271ed2b9c16c967f265d353a4768f45f9dad6494 | go.mod |
"github.com/Dreamacro/clash/common/sockopt"
| <mask>
<mask> import (
<mask> "net"
<mask>
<mask> D "github.com/miekg/dns"
<mask> )
<mask>
<mask> var (
</s> Fix: set SO_REUSEADDR for UDP listeners on linux (#630) </s> remove err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
</s> add err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2750c7ead04f441f1760e7c005076bf437e2a984 | dns/server.go |
err = sockopt.UDPReuseaddr(p)
if err != nil {
return err
}
| <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> address = addr
<mask> handler := newHandler(resolver)
<mask> server = &Server{handler: handler}
<mask> server.Server = &D.Server{Addr: addr, PacketConn: p, Handler: server}
<mask>
<mask> go func() {
</s> Fix: set SO_REUSEADDR for UDP listeners on linux (#630) </s> remove err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
</s> add err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2750c7ead04f441f1760e7c005076bf437e2a984 | dns/server.go |
err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
} | <mask> return err
<mask> }
<mask>
<mask> rc.Control(func(fd uintptr) {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
<mask> if err == nil && isIPv6 {
<mask> err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
<mask> }
<mask>
<mask> if err == nil {
</s> Fix: set SO_REUSEADDR for UDP listeners on linux (#630) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2750c7ead04f441f1760e7c005076bf437e2a984 | proxy/redir/udp_linux.go |
"github.com/Dreamacro/clash/common/sockopt" | <mask>
<mask> adapters "github.com/Dreamacro/clash/adapters/inbound"
<mask> "github.com/Dreamacro/clash/common/pool"
<mask> "github.com/Dreamacro/clash/component/socks5"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/tunnel"
<mask> )
</s> Fix: set SO_REUSEADDR for UDP listeners on linux (#630) </s> remove err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
</s> add err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2750c7ead04f441f1760e7c005076bf437e2a984 | proxy/socks/udp.go |
err = sockopt.UDPReuseaddr(l.(*net.UDPConn))
if err != nil {
return nil, err
}
| <mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> sl := &SockUDPListener{l, addr, false}
<mask> go func() {
<mask> for {
<mask> buf := pool.BufPool.Get().([]byte)
<mask> n, remoteAddr, err := l.ReadFrom(buf)
</s> Fix: set SO_REUSEADDR for UDP listeners on linux (#630) </s> remove err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
</s> add err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err == nil {
err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2750c7ead04f441f1760e7c005076bf437e2a984 | proxy/socks/udp.go |
"net/url" | <mask> "io/ioutil"
<mask> "net/http"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/component/dialer"
<mask> )
<mask>
</s> Improve: add basic auth support for provider URL (#645) </s> remove req, err := http.NewRequest(http.MethodGet, h.url, nil)
</s> add uri, err := url.Parse(h.url) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/27dd1d7944bb212f9bbe5cd0c5fc9e4b0a9b0183 | adapters/provider/vehicle.go |
uri, err := url.Parse(h.url) | <mask> func (h *HTTPVehicle) Read() ([]byte, error) {
<mask> ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
<mask> defer cancel()
<mask>
<mask> req, err := http.NewRequest(http.MethodGet, h.url, nil)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask> req = req.WithContext(ctx)
<mask>
</s> Improve: add basic auth support for provider URL (#645) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/27dd1d7944bb212f9bbe5cd0c5fc9e4b0a9b0183 | adapters/provider/vehicle.go |
req, err := http.NewRequest(http.MethodGet, uri.String(), nil)
if err != nil {
return nil, err
}
if user := uri.User; user != nil {
password, _ := user.Password()
req.SetBasicAuth(user.Username(), password)
}
| <mask> return nil, err
<mask> }
<mask> req = req.WithContext(ctx)
<mask>
<mask> transport := &http.Transport{
<mask> // from http.DefaultTransport
</s> Improve: add basic auth support for provider URL (#645) </s> remove req, err := http.NewRequest(http.MethodGet, h.url, nil)
</s> add uri, err := url.Parse(h.url) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/27dd1d7944bb212f9bbe5cd0c5fc9e4b0a9b0183 | adapters/provider/vehicle.go |
type RawDNS struct { | <mask> Proxies map[string]C.Proxy
<mask> Providers map[string]provider.ProxyProvider
<mask> }
<mask>
<mask> type rawDNS struct {
<mask> Enable bool `yaml:"enable"`
<mask> IPv6 bool `yaml:"ipv6"`
<mask> NameServer []string `yaml:"nameserver"`
<mask> Fallback []string `yaml:"fallback"`
<mask> FallbackFilter rawFallbackFilter `yaml:"fallback-filter"`
</s> Chore: export raw config struct (#475) </s> remove FallbackFilter rawFallbackFilter `yaml:"fallback-filter"`
</s> add FallbackFilter RawFallbackFilter `yaml:"fallback-filter"` </s> remove type rawFallbackFilter struct {
</s> add type RawFallbackFilter struct { </s> remove type rawConfig struct {
</s> add type RawConfig struct { </s> remove DNS rawDNS `yaml:"dns"`
</s> add DNS RawDNS `yaml:"dns"` </s> remove func parseDNS(cfg rawDNS) (*DNS, error) {
</s> add func parseDNS(cfg RawDNS) (*DNS, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
FallbackFilter RawFallbackFilter `yaml:"fallback-filter"` | <mask> Enable bool `yaml:"enable"`
<mask> IPv6 bool `yaml:"ipv6"`
<mask> NameServer []string `yaml:"nameserver"`
<mask> Fallback []string `yaml:"fallback"`
<mask> FallbackFilter rawFallbackFilter `yaml:"fallback-filter"`
<mask> Listen string `yaml:"listen"`
<mask> EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
<mask> FakeIPRange string `yaml:"fake-ip-range"`
<mask> FakeIPFilter []string `yaml:"fake-ip-filter"`
<mask> }
</s> Chore: export raw config struct (#475) </s> remove type rawDNS struct {
</s> add type RawDNS struct { </s> remove type rawFallbackFilter struct {
</s> add type RawFallbackFilter struct { </s> remove type rawConfig struct {
</s> add type RawConfig struct { </s> remove DNS rawDNS `yaml:"dns"`
</s> add DNS RawDNS `yaml:"dns"` </s> remove func parseDNS(cfg rawDNS) (*DNS, error) {
</s> add func parseDNS(cfg RawDNS) (*DNS, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
type RawFallbackFilter struct { | <mask> FakeIPRange string `yaml:"fake-ip-range"`
<mask> FakeIPFilter []string `yaml:"fake-ip-filter"`
<mask> }
<mask>
<mask> type rawFallbackFilter struct {
<mask> GeoIP bool `yaml:"geoip"`
<mask> IPCIDR []string `yaml:"ipcidr"`
<mask> }
<mask>
<mask> type rawConfig struct {
</s> Chore: export raw config struct (#475) </s> remove type rawConfig struct {
</s> add type RawConfig struct { </s> remove type rawDNS struct {
</s> add type RawDNS struct { </s> remove FallbackFilter rawFallbackFilter `yaml:"fallback-filter"`
</s> add FallbackFilter RawFallbackFilter `yaml:"fallback-filter"` </s> remove DNS rawDNS `yaml:"dns"`
</s> add DNS RawDNS `yaml:"dns"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
type RawConfig struct { | <mask> GeoIP bool `yaml:"geoip"`
<mask> IPCIDR []string `yaml:"ipcidr"`
<mask> }
<mask>
<mask> type rawConfig struct {
<mask> Port int `yaml:"port"`
<mask> SocksPort int `yaml:"socks-port"`
<mask> RedirPort int `yaml:"redir-port"`
<mask> Authentication []string `yaml:"authentication"`
<mask> AllowLan bool `yaml:"allow-lan"`
</s> Chore: export raw config struct (#475) </s> remove type rawFallbackFilter struct {
</s> add type RawFallbackFilter struct { </s> remove type rawDNS struct {
</s> add type RawDNS struct { </s> remove FallbackFilter rawFallbackFilter `yaml:"fallback-filter"`
</s> add FallbackFilter RawFallbackFilter `yaml:"fallback-filter"` </s> remove DNS rawDNS `yaml:"dns"`
</s> add DNS RawDNS `yaml:"dns"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
DNS RawDNS `yaml:"dns"` | <mask> Secret string `yaml:"secret"`
<mask>
<mask> ProxyProvider map[string]map[string]interface{} `yaml:"proxy-provider"`
<mask> Hosts map[string]string `yaml:"hosts"`
<mask> DNS rawDNS `yaml:"dns"`
<mask> Experimental Experimental `yaml:"experimental"`
<mask> Proxy []map[string]interface{} `yaml:"Proxy"`
<mask> ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
<mask> Rule []string `yaml:"Rule"`
<mask> }
</s> Chore: export raw config struct (#475) </s> remove FallbackFilter rawFallbackFilter `yaml:"fallback-filter"`
</s> add FallbackFilter RawFallbackFilter `yaml:"fallback-filter"` </s> remove type rawDNS struct {
</s> add type RawDNS struct { </s> remove type rawFallbackFilter struct {
</s> add type RawFallbackFilter struct { </s> remove func parseDNS(cfg rawDNS) (*DNS, error) {
</s> add func parseDNS(cfg RawDNS) (*DNS, error) { </s> remove type rawConfig struct {
</s> add type RawConfig struct { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} | <mask> }
<mask>
<mask> // Parse config
<mask> func Parse(buf []byte) (*Config, error) {
<mask> config := &Config{}
<mask>
<mask> // config with some default value
<mask> rawCfg := &rawConfig{
<mask> AllowLan: false,
<mask> BindAddress: "*",
</s> Chore: export raw config struct (#475) </s> remove rawCfg := &rawConfig{
</s> add rawCfg := &RawConfig{ </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
func UnmarshalRawConfig(buf []byte) (*RawConfig, error) { | <mask> return ParseRawConfig(rawCfg)
<mask> }
<mask>
<mask> // config with some default value
<mask> rawCfg := &RawConfig{
<mask> AllowLan: false,
<mask> BindAddress: "*",
</s> Chore: export raw config struct (#475) </s> remove rawCfg := &rawConfig{
</s> add rawCfg := &RawConfig{ </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { </s> remove FallbackFilter: rawFallbackFilter{
</s> add FallbackFilter: RawFallbackFilter{ | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
rawCfg := &RawConfig{ | <mask> func Parse(buf []byte) (*Config, error) {
<mask> config := &Config{}
<mask>
<mask> // config with some default value
<mask> rawCfg := &rawConfig{
<mask> AllowLan: false,
<mask> BindAddress: "*",
<mask> Mode: T.Rule,
<mask> Authentication: []string{},
<mask> LogLevel: log.INFO,
</s> Chore: export raw config struct (#475) </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
DNS: RawDNS{ | <mask> ProxyGroup: []map[string]interface{}{},
<mask> Experimental: Experimental{
<mask> IgnoreResolveFail: true,
<mask> },
<mask> DNS: rawDNS{
<mask> Enable: false,
<mask> FakeIPRange: "198.18.0.1/16",
<mask> FallbackFilter: rawFallbackFilter{
<mask> GeoIP: true,
<mask> IPCIDR: []string{},
</s> Chore: export raw config struct (#475) </s> remove FallbackFilter: rawFallbackFilter{
</s> add FallbackFilter: RawFallbackFilter{ </s> remove rawCfg := &rawConfig{
</s> add rawCfg := &RawConfig{ </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseDNS(cfg rawDNS) (*DNS, error) {
</s> add func parseDNS(cfg RawDNS) (*DNS, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
FallbackFilter: RawFallbackFilter{ | <mask> },
<mask> DNS: rawDNS{
<mask> Enable: false,
<mask> FakeIPRange: "198.18.0.1/16",
<mask> FallbackFilter: rawFallbackFilter{
<mask> GeoIP: true,
<mask> IPCIDR: []string{},
<mask> },
<mask> },
<mask> }
</s> Chore: export raw config struct (#475) </s> remove DNS: rawDNS{
</s> add DNS: RawDNS{ </s> remove rawCfg := &rawConfig{
</s> add rawCfg := &RawConfig{ </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
return rawCfg, nil
}
func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
config := &Config{}
| <mask> }
<mask>
<mask> config.Experimental = &rawCfg.Experimental
<mask>
<mask> general, err := parseGeneral(rawCfg)
<mask> if err != nil {
</s> Chore: export raw config struct (#475) </s> remove func parseProxies(cfg *rawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) {
</s> add func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) { </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
</s> add func parseHosts(cfg *RawConfig) (*trie.Trie, error) { </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
func parseGeneral(cfg *RawConfig) (*General, error) { | <mask> config.Users = parseAuthentication(rawCfg.Authentication)
<mask> return config, nil
<mask> }
<mask>
<mask> func parseGeneral(cfg *rawConfig) (*General, error) {
<mask> port := cfg.Port
<mask> socksPort := cfg.SocksPort
<mask> redirPort := cfg.RedirPort
<mask> allowLan := cfg.AllowLan
<mask> bindAddress := cfg.BindAddress
</s> Chore: export raw config struct (#475) </s> remove func parseProxies(cfg *rawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) {
</s> add func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) { </s> remove func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
</s> add func parseHosts(cfg *RawConfig) (*trie.Trie, error) { </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) { | <mask> }
<mask> return general, nil
<mask> }
<mask>
<mask> func parseProxies(cfg *rawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) {
<mask> proxies = make(map[string]C.Proxy)
<mask> providersMap = make(map[string]provider.ProxyProvider)
<mask> proxyList := []string{}
<mask> proxiesConfig := cfg.Proxy
<mask> groupsConfig := cfg.ProxyGroup
</s> Chore: export raw config struct (#475) </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
</s> add func parseHosts(cfg *RawConfig) (*trie.Trie, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { | <mask> proxies["GLOBAL"] = outbound.NewProxy(global)
<mask> return proxies, providersMap, nil
<mask> }
<mask>
<mask> func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
<mask> rules := []C.Rule{}
<mask>
<mask> rulesConfig := cfg.Rule
<mask> // parse rules
<mask> for idx, line := range rulesConfig {
</s> Chore: export raw config struct (#475) </s> remove func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
</s> add func parseHosts(cfg *RawConfig) (*trie.Trie, error) { </s> remove func parseProxies(cfg *rawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) {
</s> add func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) { </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
func parseHosts(cfg *RawConfig) (*trie.Trie, error) { | <mask>
<mask> return rules, nil
<mask> }
<mask>
<mask> func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
<mask> tree := trie.New()
<mask> if len(cfg.Hosts) != 0 {
<mask> for domain, ipStr := range cfg.Hosts {
<mask> ip := net.ParseIP(ipStr)
<mask> if ip == nil {
</s> Chore: export raw config struct (#475) </s> remove func parseDNS(cfg rawDNS) (*DNS, error) {
</s> add func parseDNS(cfg RawDNS) (*DNS, error) { </s> remove func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
</s> add func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
func parseDNS(cfg RawDNS) (*DNS, error) { | <mask>
<mask> return ipNets, nil
<mask> }
<mask>
<mask> func parseDNS(cfg rawDNS) (*DNS, error) {
<mask> if cfg.Enable && len(cfg.NameServer) == 0 {
<mask> return nil, fmt.Errorf("If DNS configuration is turned on, NameServer cannot be empty")
<mask> }
<mask>
<mask> dnsCfg := &DNS{
</s> Chore: export raw config struct (#475) </s> remove func parseHosts(cfg *rawConfig) (*trie.Trie, error) {
</s> add func parseHosts(cfg *RawConfig) (*trie.Trie, error) { </s> remove config := &Config{}
</s> add rawCfg, err := UnmarshalRawConfig(buf)
if err != nil {
return nil, err
}
return ParseRawConfig(rawCfg)
} </s> remove func parseProxies(cfg *rawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) {
</s> add func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) { </s> remove func parseGeneral(cfg *rawConfig) (*General, error) {
</s> add func parseGeneral(cfg *RawConfig) (*General, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/2810533df45161f12e16a54599dcb7401fc39271 | config/config.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.