docstring_tokens
stringlengths 0
76.5k
| code_tokens
stringlengths 75
1.81M
| label_window
sequencelengths 4
2.12k
| html_url
stringlengths 74
116
| file_name
stringlengths 3
311
|
|---|---|---|---|---|
<mask> return result, nil
<mask> }
<mask> }
<mask>
<mask> // check safebrowsing if no match
<mask> if setts.SafeBrowsingEnabled {
<mask> result, err = d.checkSafeBrowsing(host)
<mask> if err != nil {
<mask> // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
<mask> log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeBrowsing: failed: %v", err) </s> remove // check parental if no match
</s> add </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do parental HTTP lookup, ignoring check: %v", err)
</s> add log.Printf("Parental: failed: %v", err) </s> remove // check safeSearch if no match
</s> add </s> remove log.Printf("Failed to safesearch HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeSearch: failed: %v", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
log.Info("SafeBrowsing: failed: %v", err) | <mask> // check safebrowsing if no match
<mask> if setts.SafeBrowsingEnabled {
<mask> result, err = d.checkSafeBrowsing(host)
<mask> if err != nil {
<mask> // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
<mask> log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
<mask> return Result{}, nil
<mask> }
<mask> if result.Reason.Matched() {
<mask> return result, nil
<mask> }
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // check safebrowsing if no match
</s> add </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do parental HTTP lookup, ignoring check: %v", err)
</s> add log.Printf("Parental: failed: %v", err) </s> remove // check parental if no match
</s> add </s> remove log.Printf("Failed to safesearch HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeSearch: failed: %v", err) </s> remove // check safeSearch if no match
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
<mask> return result, nil
<mask> }
<mask> }
<mask>
<mask> // check parental if no match
<mask> if setts.ParentalEnabled {
<mask> result, err = d.checkParental(host)
<mask> if err != nil {
<mask> // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
<mask> log.Printf("Failed to do parental HTTP lookup, ignoring check: %v", err)
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do parental HTTP lookup, ignoring check: %v", err)
</s> add log.Printf("Parental: failed: %v", err) </s> remove // check safebrowsing if no match
</s> add </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeBrowsing: failed: %v", err) </s> remove // check safeSearch if no match
</s> add </s> remove log.Printf("Failed to safesearch HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeSearch: failed: %v", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
log.Printf("Parental: failed: %v", err) | <mask> // check parental if no match
<mask> if setts.ParentalEnabled {
<mask> result, err = d.checkParental(host)
<mask> if err != nil {
<mask> // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
<mask> log.Printf("Failed to do parental HTTP lookup, ignoring check: %v", err)
<mask> return Result{}, nil
<mask> }
<mask> if result.Reason.Matched() {
<mask> return result, nil
<mask> }
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // check parental if no match
</s> add </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeBrowsing: failed: %v", err) </s> remove // check safebrowsing if no match
</s> add </s> remove log.Printf("Failed to safesearch HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeSearch: failed: %v", err) </s> remove // check safeSearch if no match
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
<mask> return result, nil
<mask> }
<mask> }
<mask>
<mask> // nothing matched, return nothing
<mask> return Result{}, nil
<mask> }
<mask>
<mask> // Process rewrites table
<mask> // . Find CNAME for a domain name
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // check safeSearch if no match
</s> add </s> remove /*
expire byte[4]
res Result
*/
func (d *Dnsfilter) setCacheResult(cache cache.Cache, host string, res Result) {
var buf bytes.Buffer
expire := uint(time.Now().Unix()) + d.Config.CacheTime*60
var exp []byte
exp = make([]byte, 4)
binary.BigEndian.PutUint32(exp, uint32(expire))
_, _ = buf.Write(exp)
enc := gob.NewEncoder(&buf)
err := enc.Encode(res)
if err != nil {
log.Error("gob.Encode(): %s", err)
return
}
_ = cache.Set([]byte(host), buf.Bytes())
log.Debug("Stored in cache %p: %s", cache, host)
}
func getCachedResult(cache cache.Cache, host string) (Result, bool) {
data := cache.Get([]byte(host))
if data == nil {
return Result{}, false
}
exp := int(binary.BigEndian.Uint32(data[:4]))
if exp <= int(time.Now().Unix()) {
cache.Del([]byte(host))
return Result{}, false
}
var buf bytes.Buffer
buf.Write(data[4:])
dec := gob.NewDecoder(&buf)
r := Result{}
err := dec.Decode(&r)
if err != nil {
log.Debug("gob.Decode(): %s", err)
return Result{}, false
}
return r, true
}
// for each dot, hash it and add it to string
func hostnameToHashParam(host string, addslash bool) (string, map[string]bool) {
var hashparam bytes.Buffer
hashes := map[string]bool{}
tld, icann := publicsuffix.PublicSuffix(host)
if !icann {
// private suffixes like cloudfront.net
tld = ""
}
curhost := host
for {
if curhost == "" {
// we've reached end of string
break
}
if tld != "" && curhost == tld {
// we've reached the TLD, don't hash it
break
}
tohash := []byte(curhost)
if addslash {
tohash = append(tohash, '/')
}
sum := sha256.Sum256(tohash)
hexhash := fmt.Sprintf("%X", sum)
hashes[hexhash] = true
hashparam.WriteString(fmt.Sprintf("%02X%02X%02X%02X/", sum[0], sum[1], sum[2], sum[3]))
pos := strings.IndexByte(curhost, byte('.'))
if pos < 0 {
break
}
curhost = curhost[pos+1:]
}
return hashparam.String(), hashes
}
func (d *Dnsfilter) checkSafeSearch(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeSearch HTTP lookup for %s", host)
}
// Check cache. Return cached result if it was found
cachedValue, isFound := getCachedResult(gctx.safeSearchCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safesearch.CacheHits, 1)
log.Tracef("%s: found in SafeSearch cache", host)
return cachedValue, nil
}
safeHost, ok := d.SafeSearchDomain(host)
if !ok {
return Result{}, nil
}
res := Result{IsFiltered: true, Reason: FilteredSafeSearch}
if ip := net.ParseIP(safeHost); ip != nil {
res.IP = ip
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
// TODO this address should be resolved with upstream that was configured in dnsforward
addrs, err := net.LookupIP(safeHost)
if err != nil {
log.Tracef("SafeSearchDomain for %s was found but failed to lookup for %s cause %s", host, safeHost, err)
return Result{}, err
}
for _, i := range addrs {
if ipv4 := i.To4(); ipv4 != nil {
res.IP = ipv4
break
}
}
if len(res.IP) == 0 {
return Result{}, fmt.Errorf("no ipv4 addresses in safe search response for %s", safeHost)
}
// Cache result
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
func (d *Dnsfilter) checkSafeBrowsing(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeBrowsing HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
url := fmt.Sprintf(defaultSafebrowsingURL, schema, d.safeBrowsingServer, hashparam)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
result := Result{}
scanner := bufio.NewScanner(strings.NewReader(string(body)))
for scanner.Scan() {
line := scanner.Text()
splitted := strings.Split(line, ":")
if len(splitted) < 3 {
continue
}
hash := splitted[2]
if _, ok := hashes[hash]; ok {
// it's in the hash
result.IsFiltered = true
result.Reason = FilteredSafeBrowsing
result.Rule = splitted[0]
break
}
}
if err := scanner.Err(); err != nil {
// error, don't save cache
return Result{}, err
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.safebrowsingCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safebrowsing.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.safebrowsingCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Safebrowsing, true, format, handleBody)
if err == nil {
d.setCacheResult(gctx.safebrowsingCache, host, result)
}
return result, err
}
func (d *Dnsfilter) checkParental(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("Parental HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
sensitivity := d.ParentalSensitivity
if sensitivity == 0 {
sensitivity = defaultParentalSensitivity
}
url := fmt.Sprintf(defaultParentalURL, schema, d.parentalServer, hashparam, sensitivity)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
// parse json
var m []struct {
Blocked bool `json:"blocked"`
ClientTTL int `json:"clientTtl"`
Reason string `json:"reason"`
Hash string `json:"hash"`
}
err := json.Unmarshal(body, &m)
if err != nil {
// error, don't save cache
log.Printf("Couldn't parse json '%s': %s", body, err)
return Result{}, err
}
result := Result{}
for i := range m {
if !hashes[m[i].Hash] {
continue
}
if m[i].Blocked {
result.IsFiltered = true
result.Reason = FilteredParental
result.Rule = fmt.Sprintf("parental %s", m[i].Reason)
break
}
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.parentalCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Parental.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.parentalCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Parental, false, format, handleBody)
if err == nil {
d.setCacheResult(gctx.parentalCache, host, result)
}
return result, err
}
type formatHandler func(hashparam string) string
type bodyHandler func(body []byte, hashes map[string]bool) (Result, error)
// real implementation of lookup/check
func (d *Dnsfilter) lookupCommon(host string, lookupstats *LookupStats, hashparamNeedSlash bool, format formatHandler, handleBody bodyHandler) (Result, error) {
// convert hostname to hash parameters
hashparam, hashes := hostnameToHashParam(host, hashparamNeedSlash)
// format URL with our hashes
url := format(hashparam)
// do HTTP request
atomic.AddUint64(&lookupstats.Requests, 1)
atomic.AddInt64(&lookupstats.Pending, 1)
updateMax(&lookupstats.Pending, &lookupstats.PendingMax)
resp, err := d.client.Get(url)
atomic.AddInt64(&lookupstats.Pending, -1)
if resp != nil && resp.Body != nil {
defer resp.Body.Close()
}
if err != nil {
// error, don't save cache
return Result{}, err
}
// get body text
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
// error, don't save cache
return Result{}, err
}
// handle status code
switch {
case resp.StatusCode == 204:
// empty result, save cache
return Result{}, nil
case resp.StatusCode != 200:
return Result{}, fmt.Errorf("HTTP status code: %d", resp.StatusCode)
}
result, err := handleBody(body, hashes)
if err != nil {
return Result{}, err
}
return result, nil
}
</s> add </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add </s> remove log.Printf("Failed to safesearch HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeSearch: failed: %v", err) </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeBrowsing: failed: %v", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
<mask> }
<mask> return res
<mask> }
<mask>
<mask> /*
<mask> expire byte[4]
<mask> res Result
<mask> */
<mask> func (d *Dnsfilter) setCacheResult(cache cache.Cache, host string, res Result) {
<mask> var buf bytes.Buffer
<mask>
<mask> expire := uint(time.Now().Unix()) + d.Config.CacheTime*60
<mask> var exp []byte
<mask> exp = make([]byte, 4)
<mask> binary.BigEndian.PutUint32(exp, uint32(expire))
<mask> _, _ = buf.Write(exp)
<mask>
<mask> enc := gob.NewEncoder(&buf)
<mask> err := enc.Encode(res)
<mask> if err != nil {
<mask> log.Error("gob.Encode(): %s", err)
<mask> return
<mask> }
<mask> _ = cache.Set([]byte(host), buf.Bytes())
<mask> log.Debug("Stored in cache %p: %s", cache, host)
<mask> }
<mask>
<mask> func getCachedResult(cache cache.Cache, host string) (Result, bool) {
<mask> data := cache.Get([]byte(host))
<mask> if data == nil {
<mask> return Result{}, false
<mask> }
<mask>
<mask> exp := int(binary.BigEndian.Uint32(data[:4]))
<mask> if exp <= int(time.Now().Unix()) {
<mask> cache.Del([]byte(host))
<mask> return Result{}, false
<mask> }
<mask>
<mask> var buf bytes.Buffer
<mask> buf.Write(data[4:])
<mask> dec := gob.NewDecoder(&buf)
<mask> r := Result{}
<mask> err := dec.Decode(&r)
<mask> if err != nil {
<mask> log.Debug("gob.Decode(): %s", err)
<mask> return Result{}, false
<mask> }
<mask>
<mask> return r, true
<mask> }
<mask>
<mask> // for each dot, hash it and add it to string
<mask> func hostnameToHashParam(host string, addslash bool) (string, map[string]bool) {
<mask> var hashparam bytes.Buffer
<mask> hashes := map[string]bool{}
<mask> tld, icann := publicsuffix.PublicSuffix(host)
<mask> if !icann {
<mask> // private suffixes like cloudfront.net
<mask> tld = ""
<mask> }
<mask> curhost := host
<mask> for {
<mask> if curhost == "" {
<mask> // we've reached end of string
<mask> break
<mask> }
<mask> if tld != "" && curhost == tld {
<mask> // we've reached the TLD, don't hash it
<mask> break
<mask> }
<mask> tohash := []byte(curhost)
<mask> if addslash {
<mask> tohash = append(tohash, '/')
<mask> }
<mask> sum := sha256.Sum256(tohash)
<mask> hexhash := fmt.Sprintf("%X", sum)
<mask> hashes[hexhash] = true
<mask> hashparam.WriteString(fmt.Sprintf("%02X%02X%02X%02X/", sum[0], sum[1], sum[2], sum[3]))
<mask> pos := strings.IndexByte(curhost, byte('.'))
<mask> if pos < 0 {
<mask> break
<mask> }
<mask> curhost = curhost[pos+1:]
<mask> }
<mask> return hashparam.String(), hashes
<mask> }
<mask>
<mask> func (d *Dnsfilter) checkSafeSearch(host string) (Result, error) {
<mask> if log.GetLevel() >= log.DEBUG {
<mask> timer := log.StartTimer()
<mask> defer timer.LogElapsed("SafeSearch HTTP lookup for %s", host)
<mask> }
<mask>
<mask> // Check cache. Return cached result if it was found
<mask> cachedValue, isFound := getCachedResult(gctx.safeSearchCache, host)
<mask> if isFound {
<mask> atomic.AddUint64(&gctx.stats.Safesearch.CacheHits, 1)
<mask> log.Tracef("%s: found in SafeSearch cache", host)
<mask> return cachedValue, nil
<mask> }
<mask>
<mask> safeHost, ok := d.SafeSearchDomain(host)
<mask> if !ok {
<mask> return Result{}, nil
<mask> }
<mask>
<mask> res := Result{IsFiltered: true, Reason: FilteredSafeSearch}
<mask> if ip := net.ParseIP(safeHost); ip != nil {
<mask> res.IP = ip
<mask> d.setCacheResult(gctx.safeSearchCache, host, res)
<mask> return res, nil
<mask> }
<mask>
<mask> // TODO this address should be resolved with upstream that was configured in dnsforward
<mask> addrs, err := net.LookupIP(safeHost)
<mask> if err != nil {
<mask> log.Tracef("SafeSearchDomain for %s was found but failed to lookup for %s cause %s", host, safeHost, err)
<mask> return Result{}, err
<mask> }
<mask>
<mask> for _, i := range addrs {
<mask> if ipv4 := i.To4(); ipv4 != nil {
<mask> res.IP = ipv4
<mask> break
<mask> }
<mask> }
<mask>
<mask> if len(res.IP) == 0 {
<mask> return Result{}, fmt.Errorf("no ipv4 addresses in safe search response for %s", safeHost)
<mask> }
<mask>
<mask> // Cache result
<mask> d.setCacheResult(gctx.safeSearchCache, host, res)
<mask> return res, nil
<mask> }
<mask>
<mask> func (d *Dnsfilter) checkSafeBrowsing(host string) (Result, error) {
<mask> if log.GetLevel() >= log.DEBUG {
<mask> timer := log.StartTimer()
<mask> defer timer.LogElapsed("SafeBrowsing HTTP lookup for %s", host)
<mask> }
<mask>
<mask> format := func(hashparam string) string {
<mask> schema := "https"
<mask> if d.UsePlainHTTP {
<mask> schema = "http"
<mask> }
<mask> url := fmt.Sprintf(defaultSafebrowsingURL, schema, d.safeBrowsingServer, hashparam)
<mask> return url
<mask> }
<mask> handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
<mask> result := Result{}
<mask> scanner := bufio.NewScanner(strings.NewReader(string(body)))
<mask> for scanner.Scan() {
<mask> line := scanner.Text()
<mask> splitted := strings.Split(line, ":")
<mask> if len(splitted) < 3 {
<mask> continue
<mask> }
<mask> hash := splitted[2]
<mask> if _, ok := hashes[hash]; ok {
<mask> // it's in the hash
<mask> result.IsFiltered = true
<mask> result.Reason = FilteredSafeBrowsing
<mask> result.Rule = splitted[0]
<mask> break
<mask> }
<mask> }
<mask>
<mask> if err := scanner.Err(); err != nil {
<mask> // error, don't save cache
<mask> return Result{}, err
<mask> }
<mask> return result, nil
<mask> }
<mask>
<mask> // check cache
<mask> cachedValue, isFound := getCachedResult(gctx.safebrowsingCache, host)
<mask> if isFound {
<mask> atomic.AddUint64(&gctx.stats.Safebrowsing.CacheHits, 1)
<mask> log.Tracef("%s: found in the lookup cache %p", host, gctx.safebrowsingCache)
<mask> return cachedValue, nil
<mask> }
<mask>
<mask> result, err := d.lookupCommon(host, &gctx.stats.Safebrowsing, true, format, handleBody)
<mask>
<mask> if err == nil {
<mask> d.setCacheResult(gctx.safebrowsingCache, host, result)
<mask> }
<mask>
<mask> return result, err
<mask> }
<mask>
<mask> func (d *Dnsfilter) checkParental(host string) (Result, error) {
<mask> if log.GetLevel() >= log.DEBUG {
<mask> timer := log.StartTimer()
<mask> defer timer.LogElapsed("Parental HTTP lookup for %s", host)
<mask> }
<mask>
<mask> format := func(hashparam string) string {
<mask> schema := "https"
<mask> if d.UsePlainHTTP {
<mask> schema = "http"
<mask> }
<mask> sensitivity := d.ParentalSensitivity
<mask> if sensitivity == 0 {
<mask> sensitivity = defaultParentalSensitivity
<mask> }
<mask> url := fmt.Sprintf(defaultParentalURL, schema, d.parentalServer, hashparam, sensitivity)
<mask> return url
<mask> }
<mask> handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
<mask> // parse json
<mask> var m []struct {
<mask> Blocked bool `json:"blocked"`
<mask> ClientTTL int `json:"clientTtl"`
<mask> Reason string `json:"reason"`
<mask> Hash string `json:"hash"`
<mask> }
<mask> err := json.Unmarshal(body, &m)
<mask> if err != nil {
<mask> // error, don't save cache
<mask> log.Printf("Couldn't parse json '%s': %s", body, err)
<mask> return Result{}, err
<mask> }
<mask>
<mask> result := Result{}
<mask>
<mask> for i := range m {
<mask> if !hashes[m[i].Hash] {
<mask> continue
<mask> }
<mask> if m[i].Blocked {
<mask> result.IsFiltered = true
<mask> result.Reason = FilteredParental
<mask> result.Rule = fmt.Sprintf("parental %s", m[i].Reason)
<mask> break
<mask> }
<mask> }
<mask> return result, nil
<mask> }
<mask>
<mask> // check cache
<mask> cachedValue, isFound := getCachedResult(gctx.parentalCache, host)
<mask> if isFound {
<mask> atomic.AddUint64(&gctx.stats.Parental.CacheHits, 1)
<mask> log.Tracef("%s: found in the lookup cache %p", host, gctx.parentalCache)
<mask> return cachedValue, nil
<mask> }
<mask>
<mask> result, err := d.lookupCommon(host, &gctx.stats.Parental, false, format, handleBody)
<mask>
<mask> if err == nil {
<mask> d.setCacheResult(gctx.parentalCache, host, result)
<mask> }
<mask>
<mask> return result, err
<mask> }
<mask>
<mask> type formatHandler func(hashparam string) string
<mask> type bodyHandler func(body []byte, hashes map[string]bool) (Result, error)
<mask>
<mask> // real implementation of lookup/check
<mask> func (d *Dnsfilter) lookupCommon(host string, lookupstats *LookupStats, hashparamNeedSlash bool, format formatHandler, handleBody bodyHandler) (Result, error) {
<mask> // convert hostname to hash parameters
<mask> hashparam, hashes := hostnameToHashParam(host, hashparamNeedSlash)
<mask>
<mask> // format URL with our hashes
<mask> url := format(hashparam)
<mask>
<mask> // do HTTP request
<mask> atomic.AddUint64(&lookupstats.Requests, 1)
<mask> atomic.AddInt64(&lookupstats.Pending, 1)
<mask> updateMax(&lookupstats.Pending, &lookupstats.PendingMax)
<mask> resp, err := d.client.Get(url)
<mask> atomic.AddInt64(&lookupstats.Pending, -1)
<mask> if resp != nil && resp.Body != nil {
<mask> defer resp.Body.Close()
<mask> }
<mask> if err != nil {
<mask> // error, don't save cache
<mask> return Result{}, err
<mask> }
<mask>
<mask> // get body text
<mask> body, err := ioutil.ReadAll(resp.Body)
<mask> if err != nil {
<mask> // error, don't save cache
<mask> return Result{}, err
<mask> }
<mask>
<mask> // handle status code
<mask> switch {
<mask> case resp.StatusCode == 204:
<mask> // empty result, save cache
<mask> return Result{}, nil
<mask> case resp.StatusCode != 200:
<mask> return Result{}, fmt.Errorf("HTTP status code: %d", resp.StatusCode)
<mask> }
<mask>
<mask> result, err := handleBody(body, hashes)
<mask> if err != nil {
<mask> return Result{}, err
<mask> }
<mask>
<mask> return result, nil
<mask> }
<mask>
<mask> //
<mask> // Adding rule and matching against the rules
<mask> //
<mask>
<mask> // Return TRUE if file exists
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add </s> remove //
// config manipulation helpers
//
// SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
if len(host) == 0 {
d.safeBrowsingServer = defaultSafebrowsingServer
} else {
d.safeBrowsingServer = host
}
}
// SetHTTPTimeout lets you optionally change timeout during lookups
func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
d.client.Timeout = t
}
// ResetHTTPTimeout resets lookup timeouts
func (d *Dnsfilter) ResetHTTPTimeout() {
d.client.Timeout = defaultHTTPTimeout
}
// SafeSearchDomain returns replacement address for search engine
func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
if d.SafeSearchEnabled {
val, ok := safeSearchDomains[host]
return val, ok
}
return "", false
}
</s> add </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeBrowsing: failed: %v", err) </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do parental HTTP lookup, ignoring check: %v", err)
</s> add log.Printf("Parental: failed: %v", err) </s> remove // Customize the Transport to have larger connection pool,
// We are not (re)using http.DefaultTransport because of race conditions found by tests
d.transport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
MaxIdleConns: defaultHTTPMaxIdleConnections, // default 100
MaxIdleConnsPerHost: defaultHTTPMaxIdleConnections, // default 2
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
if c != nil && len(c.ResolverAddress) != 0 {
d.transport.DialContext = d.createCustomDialContext(c.ResolverAddress)
}
d.client = http.Client{
Transport: d.transport,
Timeout: defaultHTTPTimeout,
</s> add err := d.initSecurityServices()
if err != nil {
log.Error("dnsfilter: initialize services: %s", err)
return nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
<mask>
<mask> return Result{}, nil
<mask> }
<mask>
<mask> //
<mask> // lifecycle helper functions
<mask> //
<mask>
<mask> // Return TRUE if this host's IP should be cached
<mask> func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
<mask> return host == d.safeBrowsingServer ||
<mask> host == d.parentalServer
<mask> }
<mask>
<mask> // Search for an IP address by host name
<mask> func searchInDialCache(host string) string {
<mask> rawValue, err := gctx.dialCache.Get(host)
<mask> if err != nil {
<mask> return ""
<mask> }
<mask>
<mask> ip, _ := rawValue.(string)
<mask> log.Debug("Found in cache: %s -> %s", host, ip)
<mask> return ip
<mask> }
<mask>
<mask> // Add "hostname" -> "IP address" entry to cache
<mask> func addToDialCache(host, ip string) {
<mask> err := gctx.dialCache.Set(host, ip)
<mask> if err != nil {
<mask> log.Debug("dialCache.Set: %s", err)
<mask> }
<mask> log.Debug("Added to cache: %s -> %s", host, ip)
<mask> }
<mask>
<mask> type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
<mask>
<mask> // Connect to a remote server resolving hostname using our own DNS server
<mask> func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
<mask> return func(ctx context.Context, network, addr string) (net.Conn, error) {
<mask> log.Tracef("network:%v addr:%v", network, addr)
<mask>
<mask> host, port, err := net.SplitHostPort(addr)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> dialer := &net.Dialer{
<mask> Timeout: time.Minute * 5,
<mask> }
<mask>
<mask> if net.ParseIP(host) != nil {
<mask> con, err := dialer.DialContext(ctx, network, addr)
<mask> return con, err
<mask> }
<mask>
<mask> cache := d.shouldBeInDialCache(host)
<mask> if cache {
<mask> ip := searchInDialCache(host)
<mask> if len(ip) != 0 {
<mask> addr = fmt.Sprintf("%s:%s", ip, port)
<mask> return dialer.DialContext(ctx, network, addr)
<mask> }
<mask> }
<mask>
<mask> r := upstream.NewResolver(resolverAddr, 30*time.Second)
<mask> addrs, e := r.LookupIPAddr(ctx, host)
<mask> log.Tracef("LookupIPAddr: %s: %v", host, addrs)
<mask> if e != nil {
<mask> return nil, e
<mask> }
<mask>
<mask> if len(addrs) == 0 {
<mask> return nil, fmt.Errorf("couldn't lookup host: %s", host)
<mask> }
<mask>
<mask> var dialErrs []error
<mask> for _, a := range addrs {
<mask> addr = fmt.Sprintf("%s:%s", a.String(), port)
<mask> con, err := dialer.DialContext(ctx, network, addr)
<mask> if err != nil {
<mask> dialErrs = append(dialErrs, err)
<mask> continue
<mask> }
<mask>
<mask> if cache {
<mask> addToDialCache(host, a.String())
<mask> }
<mask>
<mask> return con, err
<mask> }
<mask> return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
<mask> }
<mask> }
<mask>
<mask> // New creates properly initialized DNS Filter that is ready to be used
<mask> func New(c *Config, filters map[int]string) *Dnsfilter {
<mask>
<mask> if c != nil {
<mask> cacheConf := cache.Config{
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove /*
expire byte[4]
res Result
*/
func (d *Dnsfilter) setCacheResult(cache cache.Cache, host string, res Result) {
var buf bytes.Buffer
expire := uint(time.Now().Unix()) + d.Config.CacheTime*60
var exp []byte
exp = make([]byte, 4)
binary.BigEndian.PutUint32(exp, uint32(expire))
_, _ = buf.Write(exp)
enc := gob.NewEncoder(&buf)
err := enc.Encode(res)
if err != nil {
log.Error("gob.Encode(): %s", err)
return
}
_ = cache.Set([]byte(host), buf.Bytes())
log.Debug("Stored in cache %p: %s", cache, host)
}
func getCachedResult(cache cache.Cache, host string) (Result, bool) {
data := cache.Get([]byte(host))
if data == nil {
return Result{}, false
}
exp := int(binary.BigEndian.Uint32(data[:4]))
if exp <= int(time.Now().Unix()) {
cache.Del([]byte(host))
return Result{}, false
}
var buf bytes.Buffer
buf.Write(data[4:])
dec := gob.NewDecoder(&buf)
r := Result{}
err := dec.Decode(&r)
if err != nil {
log.Debug("gob.Decode(): %s", err)
return Result{}, false
}
return r, true
}
// for each dot, hash it and add it to string
func hostnameToHashParam(host string, addslash bool) (string, map[string]bool) {
var hashparam bytes.Buffer
hashes := map[string]bool{}
tld, icann := publicsuffix.PublicSuffix(host)
if !icann {
// private suffixes like cloudfront.net
tld = ""
}
curhost := host
for {
if curhost == "" {
// we've reached end of string
break
}
if tld != "" && curhost == tld {
// we've reached the TLD, don't hash it
break
}
tohash := []byte(curhost)
if addslash {
tohash = append(tohash, '/')
}
sum := sha256.Sum256(tohash)
hexhash := fmt.Sprintf("%X", sum)
hashes[hexhash] = true
hashparam.WriteString(fmt.Sprintf("%02X%02X%02X%02X/", sum[0], sum[1], sum[2], sum[3]))
pos := strings.IndexByte(curhost, byte('.'))
if pos < 0 {
break
}
curhost = curhost[pos+1:]
}
return hashparam.String(), hashes
}
func (d *Dnsfilter) checkSafeSearch(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeSearch HTTP lookup for %s", host)
}
// Check cache. Return cached result if it was found
cachedValue, isFound := getCachedResult(gctx.safeSearchCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safesearch.CacheHits, 1)
log.Tracef("%s: found in SafeSearch cache", host)
return cachedValue, nil
}
safeHost, ok := d.SafeSearchDomain(host)
if !ok {
return Result{}, nil
}
res := Result{IsFiltered: true, Reason: FilteredSafeSearch}
if ip := net.ParseIP(safeHost); ip != nil {
res.IP = ip
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
// TODO this address should be resolved with upstream that was configured in dnsforward
addrs, err := net.LookupIP(safeHost)
if err != nil {
log.Tracef("SafeSearchDomain for %s was found but failed to lookup for %s cause %s", host, safeHost, err)
return Result{}, err
}
for _, i := range addrs {
if ipv4 := i.To4(); ipv4 != nil {
res.IP = ipv4
break
}
}
if len(res.IP) == 0 {
return Result{}, fmt.Errorf("no ipv4 addresses in safe search response for %s", safeHost)
}
// Cache result
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
func (d *Dnsfilter) checkSafeBrowsing(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeBrowsing HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
url := fmt.Sprintf(defaultSafebrowsingURL, schema, d.safeBrowsingServer, hashparam)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
result := Result{}
scanner := bufio.NewScanner(strings.NewReader(string(body)))
for scanner.Scan() {
line := scanner.Text()
splitted := strings.Split(line, ":")
if len(splitted) < 3 {
continue
}
hash := splitted[2]
if _, ok := hashes[hash]; ok {
// it's in the hash
result.IsFiltered = true
result.Reason = FilteredSafeBrowsing
result.Rule = splitted[0]
break
}
}
if err := scanner.Err(); err != nil {
// error, don't save cache
return Result{}, err
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.safebrowsingCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safebrowsing.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.safebrowsingCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Safebrowsing, true, format, handleBody)
if err == nil {
d.setCacheResult(gctx.safebrowsingCache, host, result)
}
return result, err
}
func (d *Dnsfilter) checkParental(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("Parental HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
sensitivity := d.ParentalSensitivity
if sensitivity == 0 {
sensitivity = defaultParentalSensitivity
}
url := fmt.Sprintf(defaultParentalURL, schema, d.parentalServer, hashparam, sensitivity)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
// parse json
var m []struct {
Blocked bool `json:"blocked"`
ClientTTL int `json:"clientTtl"`
Reason string `json:"reason"`
Hash string `json:"hash"`
}
err := json.Unmarshal(body, &m)
if err != nil {
// error, don't save cache
log.Printf("Couldn't parse json '%s': %s", body, err)
return Result{}, err
}
result := Result{}
for i := range m {
if !hashes[m[i].Hash] {
continue
}
if m[i].Blocked {
result.IsFiltered = true
result.Reason = FilteredParental
result.Rule = fmt.Sprintf("parental %s", m[i].Reason)
break
}
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.parentalCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Parental.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.parentalCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Parental, false, format, handleBody)
if err == nil {
d.setCacheResult(gctx.parentalCache, host, result)
}
return result, err
}
type formatHandler func(hashparam string) string
type bodyHandler func(body []byte, hashes map[string]bool) (Result, error)
// real implementation of lookup/check
func (d *Dnsfilter) lookupCommon(host string, lookupstats *LookupStats, hashparamNeedSlash bool, format formatHandler, handleBody bodyHandler) (Result, error) {
// convert hostname to hash parameters
hashparam, hashes := hostnameToHashParam(host, hashparamNeedSlash)
// format URL with our hashes
url := format(hashparam)
// do HTTP request
atomic.AddUint64(&lookupstats.Requests, 1)
atomic.AddInt64(&lookupstats.Pending, 1)
updateMax(&lookupstats.Pending, &lookupstats.PendingMax)
resp, err := d.client.Get(url)
atomic.AddInt64(&lookupstats.Pending, -1)
if resp != nil && resp.Body != nil {
defer resp.Body.Close()
}
if err != nil {
// error, don't save cache
return Result{}, err
}
// get body text
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
// error, don't save cache
return Result{}, err
}
// handle status code
switch {
case resp.StatusCode == 204:
// empty result, save cache
return Result{}, nil
case resp.StatusCode != 200:
return Result{}, fmt.Errorf("HTTP status code: %d", resp.StatusCode)
}
result, err := handleBody(body, hashes)
if err != nil {
return Result{}, err
}
return result, nil
}
</s> add </s> remove //
// config manipulation helpers
//
// SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
if len(host) == 0 {
d.safeBrowsingServer = defaultSafebrowsingServer
} else {
d.safeBrowsingServer = host
}
}
// SetHTTPTimeout lets you optionally change timeout during lookups
func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
d.client.Timeout = t
}
// ResetHTTPTimeout resets lookup timeouts
func (d *Dnsfilter) ResetHTTPTimeout() {
d.client.Timeout = defaultHTTPTimeout
}
// SafeSearchDomain returns replacement address for search engine
func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
if d.SafeSearchEnabled {
val, ok := safeSearchDomains[host]
return val, ok
}
return "", false
}
</s> add </s> remove // Customize the Transport to have larger connection pool,
// We are not (re)using http.DefaultTransport because of race conditions found by tests
d.transport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
MaxIdleConns: defaultHTTPMaxIdleConnections, // default 100
MaxIdleConnsPerHost: defaultHTTPMaxIdleConnections, // default 2
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
if c != nil && len(c.ResolverAddress) != 0 {
d.transport.DialContext = d.createCustomDialContext(c.ResolverAddress)
}
d.client = http.Client{
Transport: d.transport,
Timeout: defaultHTTPTimeout,
</s> add err := d.initSecurityServices()
if err != nil {
log.Error("dnsfilter: initialize services: %s", err)
return nil </s> remove // check safeSearch if no match
</s> add </s> remove // failed to do HTTP lookup -- treat it as if we got empty response, but don't save cache
log.Printf("Failed to do safebrowsing HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeBrowsing: failed: %v", err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
<mask> if gctx.parentalCache == nil {
<mask> cacheConf.MaxSize = c.ParentalCacheSize
<mask> gctx.parentalCache = cache.New(cacheConf)
<mask> }
<mask>
<mask> if len(c.ResolverAddress) != 0 && gctx.dialCache == nil {
<mask> dur := time.Duration(c.CacheTime) * time.Minute
<mask> gctx.dialCache = gcache.New(maxDialCacheSize).LRU().Expiration(dur).Build()
<mask> }
<mask> }
<mask>
<mask> d := new(Dnsfilter)
<mask>
<mask> // Customize the Transport to have larger connection pool,
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // Customize the Transport to have larger connection pool,
// We are not (re)using http.DefaultTransport because of race conditions found by tests
d.transport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
MaxIdleConns: defaultHTTPMaxIdleConnections, // default 100
MaxIdleConnsPerHost: defaultHTTPMaxIdleConnections, // default 2
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
if c != nil && len(c.ResolverAddress) != 0 {
d.transport.DialContext = d.createCustomDialContext(c.ResolverAddress)
}
d.client = http.Client{
Transport: d.transport,
Timeout: defaultHTTPTimeout,
</s> add err := d.initSecurityServices()
if err != nil {
log.Error("dnsfilter: initialize services: %s", err)
return nil </s> remove
func TestDnsfilterDialCache(t *testing.T) {
d := Dnsfilter{}
gctx.dialCache = gcache.New(1).LRU().Expiration(30 * time.Minute).Build()
d.shouldBeInDialCache("hostname")
if searchInDialCache("hostname") != "" {
t.Errorf("searchInDialCache")
}
addToDialCache("hostname", "1.1.1.1")
if searchInDialCache("hostname") != "1.1.1.1" {
t.Errorf("searchInDialCache")
}
}
</s> add </s> remove /*
expire byte[4]
res Result
*/
func (d *Dnsfilter) setCacheResult(cache cache.Cache, host string, res Result) {
var buf bytes.Buffer
expire := uint(time.Now().Unix()) + d.Config.CacheTime*60
var exp []byte
exp = make([]byte, 4)
binary.BigEndian.PutUint32(exp, uint32(expire))
_, _ = buf.Write(exp)
enc := gob.NewEncoder(&buf)
err := enc.Encode(res)
if err != nil {
log.Error("gob.Encode(): %s", err)
return
}
_ = cache.Set([]byte(host), buf.Bytes())
log.Debug("Stored in cache %p: %s", cache, host)
}
func getCachedResult(cache cache.Cache, host string) (Result, bool) {
data := cache.Get([]byte(host))
if data == nil {
return Result{}, false
}
exp := int(binary.BigEndian.Uint32(data[:4]))
if exp <= int(time.Now().Unix()) {
cache.Del([]byte(host))
return Result{}, false
}
var buf bytes.Buffer
buf.Write(data[4:])
dec := gob.NewDecoder(&buf)
r := Result{}
err := dec.Decode(&r)
if err != nil {
log.Debug("gob.Decode(): %s", err)
return Result{}, false
}
return r, true
}
// for each dot, hash it and add it to string
func hostnameToHashParam(host string, addslash bool) (string, map[string]bool) {
var hashparam bytes.Buffer
hashes := map[string]bool{}
tld, icann := publicsuffix.PublicSuffix(host)
if !icann {
// private suffixes like cloudfront.net
tld = ""
}
curhost := host
for {
if curhost == "" {
// we've reached end of string
break
}
if tld != "" && curhost == tld {
// we've reached the TLD, don't hash it
break
}
tohash := []byte(curhost)
if addslash {
tohash = append(tohash, '/')
}
sum := sha256.Sum256(tohash)
hexhash := fmt.Sprintf("%X", sum)
hashes[hexhash] = true
hashparam.WriteString(fmt.Sprintf("%02X%02X%02X%02X/", sum[0], sum[1], sum[2], sum[3]))
pos := strings.IndexByte(curhost, byte('.'))
if pos < 0 {
break
}
curhost = curhost[pos+1:]
}
return hashparam.String(), hashes
}
func (d *Dnsfilter) checkSafeSearch(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeSearch HTTP lookup for %s", host)
}
// Check cache. Return cached result if it was found
cachedValue, isFound := getCachedResult(gctx.safeSearchCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safesearch.CacheHits, 1)
log.Tracef("%s: found in SafeSearch cache", host)
return cachedValue, nil
}
safeHost, ok := d.SafeSearchDomain(host)
if !ok {
return Result{}, nil
}
res := Result{IsFiltered: true, Reason: FilteredSafeSearch}
if ip := net.ParseIP(safeHost); ip != nil {
res.IP = ip
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
// TODO this address should be resolved with upstream that was configured in dnsforward
addrs, err := net.LookupIP(safeHost)
if err != nil {
log.Tracef("SafeSearchDomain for %s was found but failed to lookup for %s cause %s", host, safeHost, err)
return Result{}, err
}
for _, i := range addrs {
if ipv4 := i.To4(); ipv4 != nil {
res.IP = ipv4
break
}
}
if len(res.IP) == 0 {
return Result{}, fmt.Errorf("no ipv4 addresses in safe search response for %s", safeHost)
}
// Cache result
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
func (d *Dnsfilter) checkSafeBrowsing(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeBrowsing HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
url := fmt.Sprintf(defaultSafebrowsingURL, schema, d.safeBrowsingServer, hashparam)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
result := Result{}
scanner := bufio.NewScanner(strings.NewReader(string(body)))
for scanner.Scan() {
line := scanner.Text()
splitted := strings.Split(line, ":")
if len(splitted) < 3 {
continue
}
hash := splitted[2]
if _, ok := hashes[hash]; ok {
// it's in the hash
result.IsFiltered = true
result.Reason = FilteredSafeBrowsing
result.Rule = splitted[0]
break
}
}
if err := scanner.Err(); err != nil {
// error, don't save cache
return Result{}, err
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.safebrowsingCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safebrowsing.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.safebrowsingCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Safebrowsing, true, format, handleBody)
if err == nil {
d.setCacheResult(gctx.safebrowsingCache, host, result)
}
return result, err
}
func (d *Dnsfilter) checkParental(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("Parental HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
sensitivity := d.ParentalSensitivity
if sensitivity == 0 {
sensitivity = defaultParentalSensitivity
}
url := fmt.Sprintf(defaultParentalURL, schema, d.parentalServer, hashparam, sensitivity)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
// parse json
var m []struct {
Blocked bool `json:"blocked"`
ClientTTL int `json:"clientTtl"`
Reason string `json:"reason"`
Hash string `json:"hash"`
}
err := json.Unmarshal(body, &m)
if err != nil {
// error, don't save cache
log.Printf("Couldn't parse json '%s': %s", body, err)
return Result{}, err
}
result := Result{}
for i := range m {
if !hashes[m[i].Hash] {
continue
}
if m[i].Blocked {
result.IsFiltered = true
result.Reason = FilteredParental
result.Rule = fmt.Sprintf("parental %s", m[i].Reason)
break
}
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.parentalCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Parental.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.parentalCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Parental, false, format, handleBody)
if err == nil {
d.setCacheResult(gctx.parentalCache, host, result)
}
return result, err
}
type formatHandler func(hashparam string) string
type bodyHandler func(body []byte, hashes map[string]bool) (Result, error)
// real implementation of lookup/check
func (d *Dnsfilter) lookupCommon(host string, lookupstats *LookupStats, hashparamNeedSlash bool, format formatHandler, handleBody bodyHandler) (Result, error) {
// convert hostname to hash parameters
hashparam, hashes := hostnameToHashParam(host, hashparamNeedSlash)
// format URL with our hashes
url := format(hashparam)
// do HTTP request
atomic.AddUint64(&lookupstats.Requests, 1)
atomic.AddInt64(&lookupstats.Pending, 1)
updateMax(&lookupstats.Pending, &lookupstats.PendingMax)
resp, err := d.client.Get(url)
atomic.AddInt64(&lookupstats.Pending, -1)
if resp != nil && resp.Body != nil {
defer resp.Body.Close()
}
if err != nil {
// error, don't save cache
return Result{}, err
}
// get body text
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
// error, don't save cache
return Result{}, err
}
// handle status code
switch {
case resp.StatusCode == 204:
// empty result, save cache
return Result{}, nil
case resp.StatusCode != 200:
return Result{}, fmt.Errorf("HTTP status code: %d", resp.StatusCode)
}
result, err := handleBody(body, hashes)
if err != nil {
return Result{}, err
}
return result, nil
}
</s> add </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add </s> remove if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
err := d.initSecurityServices()
if err != nil {
log.Error("dnsfilter: initialize services: %s", err)
return nil | <mask> }
<mask>
<mask> d := new(Dnsfilter)
<mask>
<mask> // Customize the Transport to have larger connection pool,
<mask> // We are not (re)using http.DefaultTransport because of race conditions found by tests
<mask> d.transport = &http.Transport{
<mask> Proxy: http.ProxyFromEnvironment,
<mask> MaxIdleConns: defaultHTTPMaxIdleConnections, // default 100
<mask> MaxIdleConnsPerHost: defaultHTTPMaxIdleConnections, // default 2
<mask> IdleConnTimeout: 90 * time.Second,
<mask> TLSHandshakeTimeout: 10 * time.Second,
<mask> ExpectContinueTimeout: 1 * time.Second,
<mask> }
<mask> if c != nil && len(c.ResolverAddress) != 0 {
<mask> d.transport.DialContext = d.createCustomDialContext(c.ResolverAddress)
<mask> }
<mask> d.client = http.Client{
<mask> Transport: d.transport,
<mask> Timeout: defaultHTTPTimeout,
<mask> }
<mask> d.safeBrowsingServer = defaultSafebrowsingServer
<mask> d.parentalServer = defaultParentalServer
<mask> if c != nil {
<mask> d.Config = *c
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove d.safeBrowsingServer = defaultSafebrowsingServer
d.parentalServer = defaultParentalServer
</s> add </s> remove
if len(c.ResolverAddress) != 0 && gctx.dialCache == nil {
dur := time.Duration(c.CacheTime) * time.Minute
gctx.dialCache = gcache.New(maxDialCacheSize).LRU().Expiration(dur).Build()
}
</s> add </s> remove const defaultHTTPTimeout = 5 * time.Minute
const defaultHTTPMaxIdleConnections = 100
const defaultSafebrowsingServer = "sb.adtidy.org"
const defaultSafebrowsingURL = "%s://%s/safebrowsing-lookup-hash.html?prefixes=%s"
const defaultParentalServer = "pctrl.adguard.com"
const defaultParentalURL = "%s://%s/check-parental-control-hash?prefixes=%s&sensitivity=%d"
const defaultParentalSensitivity = 13 // use "TEEN" by default
const maxDialCacheSize = 2 // the number of host names for safebrowsing and parental control
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
<mask> d.client = http.Client{
<mask> Transport: d.transport,
<mask> Timeout: defaultHTTPTimeout,
<mask> }
<mask> d.safeBrowsingServer = defaultSafebrowsingServer
<mask> d.parentalServer = defaultParentalServer
<mask> if c != nil {
<mask> d.Config = *c
<mask> }
<mask>
<mask> if filters != nil {
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // Customize the Transport to have larger connection pool,
// We are not (re)using http.DefaultTransport because of race conditions found by tests
d.transport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
MaxIdleConns: defaultHTTPMaxIdleConnections, // default 100
MaxIdleConnsPerHost: defaultHTTPMaxIdleConnections, // default 2
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
if c != nil && len(c.ResolverAddress) != 0 {
d.transport.DialContext = d.createCustomDialContext(c.ResolverAddress)
}
d.client = http.Client{
Transport: d.transport,
Timeout: defaultHTTPTimeout,
</s> add err := d.initSecurityServices()
if err != nil {
log.Error("dnsfilter: initialize services: %s", err)
return nil </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add </s> remove
if len(c.ResolverAddress) != 0 && gctx.dialCache == nil {
dur := time.Duration(c.CacheTime) * time.Minute
gctx.dialCache = gcache.New(maxDialCacheSize).LRU().Expiration(dur).Build()
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
<mask> }
<mask> return d
<mask> }
<mask>
<mask> //
<mask> // config manipulation helpers
<mask> //
<mask>
<mask> // SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
<mask> func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
<mask> if len(host) == 0 {
<mask> d.safeBrowsingServer = defaultSafebrowsingServer
<mask> } else {
<mask> d.safeBrowsingServer = host
<mask> }
<mask> }
<mask>
<mask> // SetHTTPTimeout lets you optionally change timeout during lookups
<mask> func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
<mask> d.client.Timeout = t
<mask> }
<mask>
<mask> // ResetHTTPTimeout resets lookup timeouts
<mask> func (d *Dnsfilter) ResetHTTPTimeout() {
<mask> d.client.Timeout = defaultHTTPTimeout
<mask> }
<mask>
<mask> // SafeSearchDomain returns replacement address for search engine
<mask> func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
<mask> if d.SafeSearchEnabled {
<mask> val, ok := safeSearchDomains[host]
<mask> return val, ok
<mask> }
<mask> return "", false
<mask> }
<mask>
<mask> //
<mask> // stats
<mask> //
<mask>
<mask> // GetStats return dns filtering stats since startup
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add </s> remove /*
expire byte[4]
res Result
*/
func (d *Dnsfilter) setCacheResult(cache cache.Cache, host string, res Result) {
var buf bytes.Buffer
expire := uint(time.Now().Unix()) + d.Config.CacheTime*60
var exp []byte
exp = make([]byte, 4)
binary.BigEndian.PutUint32(exp, uint32(expire))
_, _ = buf.Write(exp)
enc := gob.NewEncoder(&buf)
err := enc.Encode(res)
if err != nil {
log.Error("gob.Encode(): %s", err)
return
}
_ = cache.Set([]byte(host), buf.Bytes())
log.Debug("Stored in cache %p: %s", cache, host)
}
func getCachedResult(cache cache.Cache, host string) (Result, bool) {
data := cache.Get([]byte(host))
if data == nil {
return Result{}, false
}
exp := int(binary.BigEndian.Uint32(data[:4]))
if exp <= int(time.Now().Unix()) {
cache.Del([]byte(host))
return Result{}, false
}
var buf bytes.Buffer
buf.Write(data[4:])
dec := gob.NewDecoder(&buf)
r := Result{}
err := dec.Decode(&r)
if err != nil {
log.Debug("gob.Decode(): %s", err)
return Result{}, false
}
return r, true
}
// for each dot, hash it and add it to string
func hostnameToHashParam(host string, addslash bool) (string, map[string]bool) {
var hashparam bytes.Buffer
hashes := map[string]bool{}
tld, icann := publicsuffix.PublicSuffix(host)
if !icann {
// private suffixes like cloudfront.net
tld = ""
}
curhost := host
for {
if curhost == "" {
// we've reached end of string
break
}
if tld != "" && curhost == tld {
// we've reached the TLD, don't hash it
break
}
tohash := []byte(curhost)
if addslash {
tohash = append(tohash, '/')
}
sum := sha256.Sum256(tohash)
hexhash := fmt.Sprintf("%X", sum)
hashes[hexhash] = true
hashparam.WriteString(fmt.Sprintf("%02X%02X%02X%02X/", sum[0], sum[1], sum[2], sum[3]))
pos := strings.IndexByte(curhost, byte('.'))
if pos < 0 {
break
}
curhost = curhost[pos+1:]
}
return hashparam.String(), hashes
}
func (d *Dnsfilter) checkSafeSearch(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeSearch HTTP lookup for %s", host)
}
// Check cache. Return cached result if it was found
cachedValue, isFound := getCachedResult(gctx.safeSearchCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safesearch.CacheHits, 1)
log.Tracef("%s: found in SafeSearch cache", host)
return cachedValue, nil
}
safeHost, ok := d.SafeSearchDomain(host)
if !ok {
return Result{}, nil
}
res := Result{IsFiltered: true, Reason: FilteredSafeSearch}
if ip := net.ParseIP(safeHost); ip != nil {
res.IP = ip
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
// TODO this address should be resolved with upstream that was configured in dnsforward
addrs, err := net.LookupIP(safeHost)
if err != nil {
log.Tracef("SafeSearchDomain for %s was found but failed to lookup for %s cause %s", host, safeHost, err)
return Result{}, err
}
for _, i := range addrs {
if ipv4 := i.To4(); ipv4 != nil {
res.IP = ipv4
break
}
}
if len(res.IP) == 0 {
return Result{}, fmt.Errorf("no ipv4 addresses in safe search response for %s", safeHost)
}
// Cache result
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
func (d *Dnsfilter) checkSafeBrowsing(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeBrowsing HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
url := fmt.Sprintf(defaultSafebrowsingURL, schema, d.safeBrowsingServer, hashparam)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
result := Result{}
scanner := bufio.NewScanner(strings.NewReader(string(body)))
for scanner.Scan() {
line := scanner.Text()
splitted := strings.Split(line, ":")
if len(splitted) < 3 {
continue
}
hash := splitted[2]
if _, ok := hashes[hash]; ok {
// it's in the hash
result.IsFiltered = true
result.Reason = FilteredSafeBrowsing
result.Rule = splitted[0]
break
}
}
if err := scanner.Err(); err != nil {
// error, don't save cache
return Result{}, err
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.safebrowsingCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safebrowsing.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.safebrowsingCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Safebrowsing, true, format, handleBody)
if err == nil {
d.setCacheResult(gctx.safebrowsingCache, host, result)
}
return result, err
}
func (d *Dnsfilter) checkParental(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("Parental HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
sensitivity := d.ParentalSensitivity
if sensitivity == 0 {
sensitivity = defaultParentalSensitivity
}
url := fmt.Sprintf(defaultParentalURL, schema, d.parentalServer, hashparam, sensitivity)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
// parse json
var m []struct {
Blocked bool `json:"blocked"`
ClientTTL int `json:"clientTtl"`
Reason string `json:"reason"`
Hash string `json:"hash"`
}
err := json.Unmarshal(body, &m)
if err != nil {
// error, don't save cache
log.Printf("Couldn't parse json '%s': %s", body, err)
return Result{}, err
}
result := Result{}
for i := range m {
if !hashes[m[i].Hash] {
continue
}
if m[i].Blocked {
result.IsFiltered = true
result.Reason = FilteredParental
result.Rule = fmt.Sprintf("parental %s", m[i].Reason)
break
}
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.parentalCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Parental.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.parentalCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Parental, false, format, handleBody)
if err == nil {
d.setCacheResult(gctx.parentalCache, host, result)
}
return result, err
}
type formatHandler func(hashparam string) string
type bodyHandler func(body []byte, hashes map[string]bool) (Result, error)
// real implementation of lookup/check
func (d *Dnsfilter) lookupCommon(host string, lookupstats *LookupStats, hashparamNeedSlash bool, format formatHandler, handleBody bodyHandler) (Result, error) {
// convert hostname to hash parameters
hashparam, hashes := hostnameToHashParam(host, hashparamNeedSlash)
// format URL with our hashes
url := format(hashparam)
// do HTTP request
atomic.AddUint64(&lookupstats.Requests, 1)
atomic.AddInt64(&lookupstats.Pending, 1)
updateMax(&lookupstats.Pending, &lookupstats.PendingMax)
resp, err := d.client.Get(url)
atomic.AddInt64(&lookupstats.Pending, -1)
if resp != nil && resp.Body != nil {
defer resp.Body.Close()
}
if err != nil {
// error, don't save cache
return Result{}, err
}
// get body text
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
// error, don't save cache
return Result{}, err
}
// handle status code
switch {
case resp.StatusCode == 204:
// empty result, save cache
return Result{}, nil
case resp.StatusCode != 200:
return Result{}, fmt.Errorf("HTTP status code: %d", resp.StatusCode)
}
result, err := handleBody(body, hashes)
if err != nil {
return Result{}, err
}
return result, nil
}
</s> add </s> remove if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
</s> add </s> remove d := NewForTest(nil, nil)
defer d.Close()
_, ok := d.SafeSearchDomain("www.google.com")
if ok {
t.Errorf("Expected safesearch to error when disabled")
}
d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
</s> add d := NewForTest(&Config{SafeSearchEnabled: true}, nil) </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter.go |
|
<mask>
<mask> import (
<mask> "fmt"
<mask> "net"
<mask> "net/http"
<mask> "net/http/httptest"
<mask> "path"
<mask> "runtime"
<mask> "testing"
<mask> "time"
<mask>
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "time"
</s> add </s> remove "context"
"crypto/sha256"
"encoding/binary"
"encoding/gob"
"encoding/json"
</s> add </s> remove "bufio"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
<mask> "net/http/httptest"
<mask> "path"
<mask> "runtime"
<mask> "testing"
<mask> "time"
<mask>
<mask> "github.com/AdguardTeam/urlfilter"
<mask> "github.com/bluele/gcache"
<mask> "github.com/miekg/dns"
<mask> "github.com/stretchr/testify/assert"
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "github.com/bluele/gcache"
</s> add </s> remove "net/http"
"net/http/httptest"
</s> add </s> remove "sync/atomic"
"time"
"github.com/joomcode/errorx"
</s> add </s> remove "github.com/bluele/gcache"
</s> add </s> remove "golang.org/x/net/publicsuffix"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
<mask> "testing"
<mask> "time"
<mask>
<mask> "github.com/AdguardTeam/urlfilter"
<mask> "github.com/bluele/gcache"
<mask> "github.com/miekg/dns"
<mask> "github.com/stretchr/testify/assert"
<mask> )
<mask>
<mask> var setts RequestFilteringSettings
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "time"
</s> add </s> remove "github.com/bluele/gcache"
</s> add </s> remove "golang.org/x/net/publicsuffix"
</s> add </s> remove "net/http"
"net/http/httptest"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
<mask> // SAFE BROWSING
<mask> // SAFE SEARCH
<mask> // PARENTAL
<mask> // FILTERING
<mask> // CLIENTS SETTINGS
<mask> // BENCHMARKS
<mask>
<mask> // HELPERS
<mask>
<mask> func purgeCaches() {
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove d := NewForTest(nil, nil)
defer d.Close()
_, ok := d.SafeSearchDomain("www.google.com")
if ok {
t.Errorf("Expected safesearch to error when disabled")
}
d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
</s> add d := NewForTest(&Config{SafeSearchEnabled: true}, nil) </s> remove //
// config manipulation helpers
//
// SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
if len(host) == 0 {
d.safeBrowsingServer = defaultSafebrowsingServer
} else {
d.safeBrowsingServer = host
}
}
// SetHTTPTimeout lets you optionally change timeout during lookups
func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
d.client.Timeout = t
}
// ResetHTTPTimeout resets lookup timeouts
func (d *Dnsfilter) ResetHTTPTimeout() {
d.client.Timeout = defaultHTTPTimeout
}
// SafeSearchDomain returns replacement address for search engine
func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
if d.SafeSearchEnabled {
val, ok := safeSearchDomains[host]
return val, ok
}
return "", false
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer | <mask>
<mask> // SAFE BROWSING
<mask>
<mask> func TestSafeBrowsing(t *testing.T) {
<mask> testCases := []string{
<mask> "",
<mask> "sb.adtidy.org",
<mask> }
<mask> for _, tc := range testCases {
<mask> t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Close()
<mask> gctx.stats.Safebrowsing.Requests = 0
<mask> d.checkMatch(t, "wmconvirus.narod.ru")
<mask> d.checkMatch(t, "wmconvirus.narod.ru")
<mask> if gctx.stats.Safebrowsing.Requests != 1 {
<mask> t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
<mask> }
<mask> d.checkMatch(t, "WMconvirus.narod.ru")
<mask> if gctx.stats.Safebrowsing.Requests != 1 {
<mask> t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
<mask> }
<mask> d.checkMatch(t, "test.wmconvirus.narod.ru")
<mask> d.checkMatchEmpty(t, "yandex.ru")
<mask> d.checkMatchEmpty(t, "pornhub.com")
<mask> l := gctx.stats.Safebrowsing.Requests
<mask> d.checkMatchEmpty(t, "pornhub.com")
<mask> if gctx.stats.Safebrowsing.Requests != l {
<mask> t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
<mask> }
<mask> })
<mask> }
<mask> }
<mask>
<mask> func TestParallelSB(t *testing.T) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Close()
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove d.checkMatch(t, "pornhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
d.checkMatch(t, "PORNhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
</s> add </s> remove l := gctx.stats.Parental.Requests
d.checkMatchEmpty(t, "yandex.ru")
if gctx.stats.Parental.Requests != l {
t.Errorf("Parental lookup negative cache is not working")
}
</s> add </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove d := NewForTest(nil, nil)
defer d.Close()
_, ok := d.SafeSearchDomain("www.google.com")
if ok {
t.Errorf("Expected safesearch to error when disabled")
}
d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
</s> add d := NewForTest(&Config{SafeSearchEnabled: true}, nil) </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
<mask> }
<mask> })
<mask> }
<mask>
<mask> // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
<mask> func TestSafeBrowsingCustomServerFail(t *testing.T) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Close()
<mask> ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
<mask> // w.Write("Hello, client")
<mask> fmt.Fprintln(w, "Hello, client")
<mask> }))
<mask> defer ts.Close()
<mask> address := ts.Listener.Addr().String()
<mask>
<mask> d.SetHTTPTimeout(time.Second * 5)
<mask> d.SetSafeBrowsingServer(address) // this will ensure that test fails
<mask> d.checkMatchEmpty(t, "wmconvirus.narod.ru")
<mask> }
<mask>
<mask> // SAFE SEARCH
<mask>
<mask> func TestSafeSearch(t *testing.T) {
<mask> d := NewForTest(nil, nil)
<mask> defer d.Close()
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove d := NewForTest(nil, nil)
defer d.Close()
_, ok := d.SafeSearchDomain("www.google.com")
if ok {
t.Errorf("Expected safesearch to error when disabled")
}
d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
</s> add d := NewForTest(&Config{SafeSearchEnabled: true}, nil) </s> remove d.checkMatch(t, "pornhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
d.checkMatch(t, "PORNhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
</s> add </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add </s> remove
func TestDnsfilterDialCache(t *testing.T) {
d := Dnsfilter{}
gctx.dialCache = gcache.New(1).LRU().Expiration(30 * time.Minute).Build()
d.shouldBeInDialCache("hostname")
if searchInDialCache("hostname") != "" {
t.Errorf("searchInDialCache")
}
addToDialCache("hostname", "1.1.1.1")
if searchInDialCache("hostname") != "1.1.1.1" {
t.Errorf("searchInDialCache")
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
d := NewForTest(&Config{SafeSearchEnabled: true}, nil) | <mask>
<mask> // SAFE SEARCH
<mask>
<mask> func TestSafeSearch(t *testing.T) {
<mask> d := NewForTest(nil, nil)
<mask> defer d.Close()
<mask> _, ok := d.SafeSearchDomain("www.google.com")
<mask> if ok {
<mask> t.Errorf("Expected safesearch to error when disabled")
<mask> }
<mask>
<mask> d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Close()
<mask> val, ok := d.SafeSearchDomain("www.google.com")
<mask> if !ok {
<mask> t.Errorf("Expected safesearch to find result for www.google.com")
<mask> }
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove //
// config manipulation helpers
//
// SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
if len(host) == 0 {
d.safeBrowsingServer = defaultSafebrowsingServer
} else {
d.safeBrowsingServer = host
}
}
// SetHTTPTimeout lets you optionally change timeout during lookups
func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
d.client.Timeout = t
}
// ResetHTTPTimeout resets lookup timeouts
func (d *Dnsfilter) ResetHTTPTimeout() {
d.client.Timeout = defaultHTTPTimeout
}
// SafeSearchDomain returns replacement address for search engine
func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
if d.SafeSearchEnabled {
val, ok := safeSearchDomains[host]
return val, ok
}
return "", false
}
</s> add </s> remove d.checkMatch(t, "pornhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
d.checkMatch(t, "PORNhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
</s> add </s> remove /*
expire byte[4]
res Result
*/
func (d *Dnsfilter) setCacheResult(cache cache.Cache, host string, res Result) {
var buf bytes.Buffer
expire := uint(time.Now().Unix()) + d.Config.CacheTime*60
var exp []byte
exp = make([]byte, 4)
binary.BigEndian.PutUint32(exp, uint32(expire))
_, _ = buf.Write(exp)
enc := gob.NewEncoder(&buf)
err := enc.Encode(res)
if err != nil {
log.Error("gob.Encode(): %s", err)
return
}
_ = cache.Set([]byte(host), buf.Bytes())
log.Debug("Stored in cache %p: %s", cache, host)
}
func getCachedResult(cache cache.Cache, host string) (Result, bool) {
data := cache.Get([]byte(host))
if data == nil {
return Result{}, false
}
exp := int(binary.BigEndian.Uint32(data[:4]))
if exp <= int(time.Now().Unix()) {
cache.Del([]byte(host))
return Result{}, false
}
var buf bytes.Buffer
buf.Write(data[4:])
dec := gob.NewDecoder(&buf)
r := Result{}
err := dec.Decode(&r)
if err != nil {
log.Debug("gob.Decode(): %s", err)
return Result{}, false
}
return r, true
}
// for each dot, hash it and add it to string
func hostnameToHashParam(host string, addslash bool) (string, map[string]bool) {
var hashparam bytes.Buffer
hashes := map[string]bool{}
tld, icann := publicsuffix.PublicSuffix(host)
if !icann {
// private suffixes like cloudfront.net
tld = ""
}
curhost := host
for {
if curhost == "" {
// we've reached end of string
break
}
if tld != "" && curhost == tld {
// we've reached the TLD, don't hash it
break
}
tohash := []byte(curhost)
if addslash {
tohash = append(tohash, '/')
}
sum := sha256.Sum256(tohash)
hexhash := fmt.Sprintf("%X", sum)
hashes[hexhash] = true
hashparam.WriteString(fmt.Sprintf("%02X%02X%02X%02X/", sum[0], sum[1], sum[2], sum[3]))
pos := strings.IndexByte(curhost, byte('.'))
if pos < 0 {
break
}
curhost = curhost[pos+1:]
}
return hashparam.String(), hashes
}
func (d *Dnsfilter) checkSafeSearch(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeSearch HTTP lookup for %s", host)
}
// Check cache. Return cached result if it was found
cachedValue, isFound := getCachedResult(gctx.safeSearchCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safesearch.CacheHits, 1)
log.Tracef("%s: found in SafeSearch cache", host)
return cachedValue, nil
}
safeHost, ok := d.SafeSearchDomain(host)
if !ok {
return Result{}, nil
}
res := Result{IsFiltered: true, Reason: FilteredSafeSearch}
if ip := net.ParseIP(safeHost); ip != nil {
res.IP = ip
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
// TODO this address should be resolved with upstream that was configured in dnsforward
addrs, err := net.LookupIP(safeHost)
if err != nil {
log.Tracef("SafeSearchDomain for %s was found but failed to lookup for %s cause %s", host, safeHost, err)
return Result{}, err
}
for _, i := range addrs {
if ipv4 := i.To4(); ipv4 != nil {
res.IP = ipv4
break
}
}
if len(res.IP) == 0 {
return Result{}, fmt.Errorf("no ipv4 addresses in safe search response for %s", safeHost)
}
// Cache result
d.setCacheResult(gctx.safeSearchCache, host, res)
return res, nil
}
func (d *Dnsfilter) checkSafeBrowsing(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("SafeBrowsing HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
url := fmt.Sprintf(defaultSafebrowsingURL, schema, d.safeBrowsingServer, hashparam)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
result := Result{}
scanner := bufio.NewScanner(strings.NewReader(string(body)))
for scanner.Scan() {
line := scanner.Text()
splitted := strings.Split(line, ":")
if len(splitted) < 3 {
continue
}
hash := splitted[2]
if _, ok := hashes[hash]; ok {
// it's in the hash
result.IsFiltered = true
result.Reason = FilteredSafeBrowsing
result.Rule = splitted[0]
break
}
}
if err := scanner.Err(); err != nil {
// error, don't save cache
return Result{}, err
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.safebrowsingCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Safebrowsing.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.safebrowsingCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Safebrowsing, true, format, handleBody)
if err == nil {
d.setCacheResult(gctx.safebrowsingCache, host, result)
}
return result, err
}
func (d *Dnsfilter) checkParental(host string) (Result, error) {
if log.GetLevel() >= log.DEBUG {
timer := log.StartTimer()
defer timer.LogElapsed("Parental HTTP lookup for %s", host)
}
format := func(hashparam string) string {
schema := "https"
if d.UsePlainHTTP {
schema = "http"
}
sensitivity := d.ParentalSensitivity
if sensitivity == 0 {
sensitivity = defaultParentalSensitivity
}
url := fmt.Sprintf(defaultParentalURL, schema, d.parentalServer, hashparam, sensitivity)
return url
}
handleBody := func(body []byte, hashes map[string]bool) (Result, error) {
// parse json
var m []struct {
Blocked bool `json:"blocked"`
ClientTTL int `json:"clientTtl"`
Reason string `json:"reason"`
Hash string `json:"hash"`
}
err := json.Unmarshal(body, &m)
if err != nil {
// error, don't save cache
log.Printf("Couldn't parse json '%s': %s", body, err)
return Result{}, err
}
result := Result{}
for i := range m {
if !hashes[m[i].Hash] {
continue
}
if m[i].Blocked {
result.IsFiltered = true
result.Reason = FilteredParental
result.Rule = fmt.Sprintf("parental %s", m[i].Reason)
break
}
}
return result, nil
}
// check cache
cachedValue, isFound := getCachedResult(gctx.parentalCache, host)
if isFound {
atomic.AddUint64(&gctx.stats.Parental.CacheHits, 1)
log.Tracef("%s: found in the lookup cache %p", host, gctx.parentalCache)
return cachedValue, nil
}
result, err := d.lookupCommon(host, &gctx.stats.Parental, false, format, handleBody)
if err == nil {
d.setCacheResult(gctx.parentalCache, host, result)
}
return result, err
}
type formatHandler func(hashparam string) string
type bodyHandler func(body []byte, hashes map[string]bool) (Result, error)
// real implementation of lookup/check
func (d *Dnsfilter) lookupCommon(host string, lookupstats *LookupStats, hashparamNeedSlash bool, format formatHandler, handleBody bodyHandler) (Result, error) {
// convert hostname to hash parameters
hashparam, hashes := hostnameToHashParam(host, hashparamNeedSlash)
// format URL with our hashes
url := format(hashparam)
// do HTTP request
atomic.AddUint64(&lookupstats.Requests, 1)
atomic.AddInt64(&lookupstats.Pending, 1)
updateMax(&lookupstats.Pending, &lookupstats.PendingMax)
resp, err := d.client.Get(url)
atomic.AddInt64(&lookupstats.Pending, -1)
if resp != nil && resp.Body != nil {
defer resp.Body.Close()
}
if err != nil {
// error, don't save cache
return Result{}, err
}
// get body text
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
// error, don't save cache
return Result{}, err
}
// handle status code
switch {
case resp.StatusCode == 204:
// empty result, save cache
return Result{}, nil
case resp.StatusCode != 200:
return Result{}, fmt.Errorf("HTTP status code: %d", resp.StatusCode)
}
result, err := handleBody(body, hashes)
if err != nil {
return Result{}, err
}
return result, nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
<mask> d := NewForTest(&Config{ParentalEnabled: true}, nil)
<mask> defer d.Close()
<mask> d.ParentalSensitivity = 3
<mask> d.checkMatch(t, "pornhub.com")
<mask> d.checkMatch(t, "pornhub.com")
<mask> if gctx.stats.Parental.Requests != 1 {
<mask> t.Errorf("Parental lookup positive cache is not working")
<mask> }
<mask> d.checkMatch(t, "PORNhub.com")
<mask> if gctx.stats.Parental.Requests != 1 {
<mask> t.Errorf("Parental lookup positive cache is not working")
<mask> }
<mask> d.checkMatch(t, "www.pornhub.com")
<mask> d.checkMatchEmpty(t, "www.yandex.ru")
<mask> d.checkMatchEmpty(t, "yandex.ru")
<mask> l := gctx.stats.Parental.Requests
<mask> d.checkMatchEmpty(t, "yandex.ru")
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove l := gctx.stats.Parental.Requests
d.checkMatchEmpty(t, "yandex.ru")
if gctx.stats.Parental.Requests != l {
t.Errorf("Parental lookup negative cache is not working")
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove d := NewForTest(nil, nil)
defer d.Close()
_, ok := d.SafeSearchDomain("www.google.com")
if ok {
t.Errorf("Expected safesearch to error when disabled")
}
d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
</s> add d := NewForTest(&Config{SafeSearchEnabled: true}, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
<mask> }
<mask> d.checkMatch(t, "www.pornhub.com")
<mask> d.checkMatchEmpty(t, "www.yandex.ru")
<mask> d.checkMatchEmpty(t, "yandex.ru")
<mask> l := gctx.stats.Parental.Requests
<mask> d.checkMatchEmpty(t, "yandex.ru")
<mask> if gctx.stats.Parental.Requests != l {
<mask> t.Errorf("Parental lookup negative cache is not working")
<mask> }
<mask>
<mask> d.checkMatchEmpty(t, "api.jquery.com")
<mask> }
<mask>
<mask> // FILTERING
<mask>
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove d.checkMatch(t, "pornhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
d.checkMatch(t, "PORNhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
// test cached result
d.parentalServer = "127.0.0.1"
d.checkMatch(t, "pornhub.com")
d.checkMatchEmpty(t, "yandex.ru")
d.parentalServer = defaultParentalServer | <mask> d.checkMatchEmpty(t, "yandex.ru")
<mask> d.checkMatchEmpty(t, "api.jquery.com")
<mask> }
<mask>
<mask> // FILTERING
<mask>
<mask> var blockingRules = "||example.org^\n"
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove l := gctx.stats.Parental.Requests
d.checkMatchEmpty(t, "yandex.ru")
if gctx.stats.Parental.Requests != l {
t.Errorf("Parental lookup negative cache is not working")
}
</s> add </s> remove d.checkMatch(t, "pornhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
d.checkMatch(t, "PORNhub.com")
if gctx.stats.Parental.Requests != 1 {
t.Errorf("Parental lookup positive cache is not working")
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove // CLIENTS SETTINGS
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
<mask> }
<mask> }
<mask> })
<mask> }
<mask>
<mask> func TestDnsfilterDialCache(t *testing.T) {
<mask> d := Dnsfilter{}
<mask> gctx.dialCache = gcache.New(1).LRU().Expiration(30 * time.Minute).Build()
<mask>
<mask> d.shouldBeInDialCache("hostname")
<mask> if searchInDialCache("hostname") != "" {
<mask> t.Errorf("searchInDialCache")
<mask> }
<mask> addToDialCache("hostname", "1.1.1.1")
<mask> if searchInDialCache("hostname") != "1.1.1.1" {
<mask> t.Errorf("searchInDialCache")
<mask> }
<mask> }
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove
if len(c.ResolverAddress) != 0 && gctx.dialCache == nil {
dur := time.Duration(c.CacheTime) * time.Minute
gctx.dialCache = gcache.New(maxDialCacheSize).LRU().Expiration(dur).Build()
}
</s> add </s> remove testCases := []string{
"",
"sb.adtidy.org",
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "wmconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "WMconvirus.narod.ru")
if gctx.stats.Safebrowsing.Requests != 1 {
t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
l := gctx.stats.Safebrowsing.Requests
d.checkMatchEmpty(t, "pornhub.com")
if gctx.stats.Safebrowsing.Requests != l {
t.Errorf("Safebrowsing lookup negative cache is not working: %v", gctx.stats.Safebrowsing.Requests)
}
})
}
</s> add d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
gctx.stats.Safebrowsing.Requests = 0
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatch(t, "test.wmconvirus.narod.ru")
d.checkMatchEmpty(t, "yandex.ru")
d.checkMatchEmpty(t, "pornhub.com")
// test cached result
d.safeBrowsingServer = "127.0.0.1"
d.checkMatch(t, "wmconvirus.narod.ru")
d.checkMatchEmpty(t, "pornhub.com")
d.safeBrowsingServer = defaultSafebrowsingServer </s> remove // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
func TestSafeBrowsingCustomServerFail(t *testing.T) {
d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
defer d.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// w.Write("Hello, client")
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
address := ts.Listener.Addr().String()
d.SetHTTPTimeout(time.Second * 5)
d.SetSafeBrowsingServer(address) // this will ensure that test fails
d.checkMatchEmpty(t, "wmconvirus.narod.ru")
}
</s> add </s> remove d := NewForTest(nil, nil)
defer d.Close()
_, ok := d.SafeSearchDomain("www.google.com")
if ok {
t.Errorf("Expected safesearch to error when disabled")
}
d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
</s> add d := NewForTest(&Config{SafeSearchEnabled: true}, nil) </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/dnsfilter_test.go |
|
"bytes"
"crypto/sha256"
"encoding/binary"
"encoding/gob"
"encoding/hex" | <mask> package dnsfilter
<mask>
<mask> import (
<mask> "bufio"
<mask> "encoding/json"
<mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net"
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "context"
"crypto/sha256"
"encoding/binary"
"encoding/gob"
"encoding/json"
</s> add </s> remove "bufio"
</s> add </s> remove "net/http"
"net/http/httptest"
</s> add </s> remove // check safeSearch if no match
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/security.go |
"net" | <mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net/http"
<mask> "strconv"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/AdguardTeam/dnsproxy/upstream"
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "net/http"
"net/http/httptest"
</s> add </s> remove "sync/atomic"
"time"
"github.com/joomcode/errorx"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/security.go |
"time" | <mask> "strconv"
<mask> "strings"
<mask>
<mask> "github.com/AdguardTeam/dnsproxy/upstream"
<mask> "github.com/AdguardTeam/golibs/cache"
<mask> "github.com/AdguardTeam/golibs/log"
<mask> "github.com/miekg/dns"
<mask> "golang.org/x/net/publicsuffix"
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "github.com/bluele/gcache"
</s> add </s> remove "sync/atomic"
"time"
"github.com/joomcode/errorx"
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/security.go |
"github.com/AdguardTeam/dnsproxy/upstream"
"github.com/AdguardTeam/golibs/cache" | <mask> "strconv"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/AdguardTeam/golibs/log"
<mask> "github.com/miekg/dns"
<mask> "golang.org/x/net/publicsuffix"
<mask> )
<mask>
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "github.com/bluele/gcache"
</s> add </s> remove "golang.org/x/net/publicsuffix"
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/security.go |
"github.com/miekg/dns"
"golang.org/x/net/publicsuffix" | <mask> "github.com/AdguardTeam/dnsproxy/upstream"
<mask> "github.com/AdguardTeam/golibs/cache"
<mask> "github.com/AdguardTeam/golibs/log"
<mask> )
<mask>
<mask> const dnsTimeout = 3 * time.Second
<mask> const defaultSafebrowsingServer = "https://dns-family.adguard.com/dns-query"
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove "github.com/bluele/gcache"
</s> add </s> remove "golang.org/x/net/publicsuffix"
</s> add </s> remove const defaultHTTPTimeout = 5 * time.Minute
const defaultHTTPMaxIdleConnections = 100
const defaultSafebrowsingServer = "sb.adtidy.org"
const defaultSafebrowsingURL = "%s://%s/safebrowsing-lookup-hash.html?prefixes=%s"
const defaultParentalServer = "pctrl.adguard.com"
const defaultParentalURL = "%s://%s/check-parental-control-hash?prefixes=%s&sensitivity=%d"
const defaultParentalSensitivity = 13 // use "TEEN" by default
const maxDialCacheSize = 2 // the number of host names for safebrowsing and parental control
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | dnsfilter/security.go |
<mask> github.com/AdguardTeam/dnsproxy v0.19.6
<mask> github.com/AdguardTeam/golibs v0.2.4
<mask> github.com/AdguardTeam/urlfilter v0.6.1
<mask> github.com/NYTimes/gziphandler v1.1.1
<mask> github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833
<mask> github.com/etcd-io/bbolt v1.3.3
<mask> github.com/go-test/deep v1.0.4
<mask> github.com/gobuffalo/packr v1.19.0
<mask> github.com/joomcode/errorx v1.0.0
<mask> github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 // indirect
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove github.com/go-test/deep v1.0.4
</s> add github.com/go-test/deep v1.0.4 // indirect </s> remove github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833 h1:yCfXxYaelOyqnia8F/Yng47qhmfC9nKTRIbYRrRueq4=
github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833/go.mod h1:8c4/i2VlovMO2gBnHGQPN5EJw+H0lx1u/5p+cgsXtCk=
</s> add </s> remove // CLIENTS SETTINGS
</s> add </s> remove // HTTP lookups for safebrowsing and parental
client http.Client // handle for http client -- single instance as recommended by docs
transport *http.Transport // handle for http transport used by http client
parentalServer string // access via methods
safeBrowsingServer string // access via methods
</s> add parentalServer string // access via methods
safeBrowsingServer string // access via methods
parentalUpstream upstream.Upstream
safeBrowsingUpstream upstream.Upstream </s> remove //
// config manipulation helpers
//
// SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
if len(host) == 0 {
d.safeBrowsingServer = defaultSafebrowsingServer
} else {
d.safeBrowsingServer = host
}
}
// SetHTTPTimeout lets you optionally change timeout during lookups
func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
d.client.Timeout = t
}
// ResetHTTPTimeout resets lookup timeouts
func (d *Dnsfilter) ResetHTTPTimeout() {
d.client.Timeout = defaultHTTPTimeout
}
// SafeSearchDomain returns replacement address for search engine
func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
if d.SafeSearchEnabled {
val, ok := safeSearchDomains[host]
return val, ok
}
return "", false
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | go.mod |
|
github.com/go-test/deep v1.0.4 // indirect | <mask> github.com/AdguardTeam/urlfilter v0.6.1
<mask> github.com/NYTimes/gziphandler v1.1.1
<mask> github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833
<mask> github.com/etcd-io/bbolt v1.3.3
<mask> github.com/go-test/deep v1.0.4
<mask> github.com/gobuffalo/packr v1.19.0
<mask> github.com/joomcode/errorx v1.0.0
<mask> github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 // indirect
<mask> github.com/kardianos/service v0.0.0-20181115005516-4c239ee84e7b
<mask> github.com/krolaw/dhcp4 v0.0.0-20180925202202-7cead472c414
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833
</s> add </s> remove github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833 h1:yCfXxYaelOyqnia8F/Yng47qhmfC9nKTRIbYRrRueq4=
github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833/go.mod h1:8c4/i2VlovMO2gBnHGQPN5EJw+H0lx1u/5p+cgsXtCk=
</s> add </s> remove // CLIENTS SETTINGS
</s> add </s> remove // HTTP lookups for safebrowsing and parental
client http.Client // handle for http client -- single instance as recommended by docs
transport *http.Transport // handle for http transport used by http client
parentalServer string // access via methods
safeBrowsingServer string // access via methods
</s> add parentalServer string // access via methods
safeBrowsingServer string // access via methods
parentalUpstream upstream.Upstream
safeBrowsingUpstream upstream.Upstream </s> remove //
// config manipulation helpers
//
// SetSafeBrowsingServer lets you optionally change hostname of safesearch lookup
func (d *Dnsfilter) SetSafeBrowsingServer(host string) {
if len(host) == 0 {
d.safeBrowsingServer = defaultSafebrowsingServer
} else {
d.safeBrowsingServer = host
}
}
// SetHTTPTimeout lets you optionally change timeout during lookups
func (d *Dnsfilter) SetHTTPTimeout(t time.Duration) {
d.client.Timeout = t
}
// ResetHTTPTimeout resets lookup timeouts
func (d *Dnsfilter) ResetHTTPTimeout() {
d.client.Timeout = defaultHTTPTimeout
}
// SafeSearchDomain returns replacement address for search engine
func (d *Dnsfilter) SafeSearchDomain(host string) (string, bool) {
if d.SafeSearchEnabled {
val, ok := safeSearchDomains[host]
return val, ok
}
return "", false
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | go.mod |
<mask> github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a h1:idn718Q4B6AGu/h5Sxe66HYVdqdGu2l9Iebqhi/AEoA=
<mask> github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
<mask> github.com/beefsack/go-rate v0.0.0-20180408011153-efa7637bb9b6 h1:KXlsf+qt/X5ttPGEjR0tPH1xaWWoKBEg9Q1THAj2h3I=
<mask> github.com/beefsack/go-rate v0.0.0-20180408011153-efa7637bb9b6/go.mod h1:6YNgTHLutezwnBvyneBbwvB8C82y3dcoOj5EQJIdGXA=
<mask> github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833 h1:yCfXxYaelOyqnia8F/Yng47qhmfC9nKTRIbYRrRueq4=
<mask> github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833/go.mod h1:8c4/i2VlovMO2gBnHGQPN5EJw+H0lx1u/5p+cgsXtCk=
<mask> github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
<mask> github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
<mask> github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
<mask> github.com/etcd-io/bbolt v1.3.3 h1:gSJmxrs37LgTqR/oyJBWok6k6SvXEUerFTbltIhXkBM=
<mask> github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
</s> + dnsfilter: use AG DNS server for SB/PC services
* move SS/SB/PC services to security.go
* remove old useless code (HTTP client) </s> remove github.com/bluele/gcache v0.0.0-20190518031135-bc40bd653833
</s> add </s> remove github.com/go-test/deep v1.0.4
</s> add github.com/go-test/deep v1.0.4 // indirect </s> remove "context"
"crypto/sha256"
"encoding/binary"
"encoding/gob"
"encoding/json"
</s> add </s> remove log.Printf("Failed to safesearch HTTP lookup, ignoring check: %v", err)
</s> add log.Info("SafeSearch: failed: %v", err) </s> remove //
// lifecycle helper functions
//
// Return TRUE if this host's IP should be cached
func (d *Dnsfilter) shouldBeInDialCache(host string) bool {
return host == d.safeBrowsingServer ||
host == d.parentalServer
}
// Search for an IP address by host name
func searchInDialCache(host string) string {
rawValue, err := gctx.dialCache.Get(host)
if err != nil {
return ""
}
ip, _ := rawValue.(string)
log.Debug("Found in cache: %s -> %s", host, ip)
return ip
}
// Add "hostname" -> "IP address" entry to cache
func addToDialCache(host, ip string) {
err := gctx.dialCache.Set(host, ip)
if err != nil {
log.Debug("dialCache.Set: %s", err)
}
log.Debug("Added to cache: %s -> %s", host, ip)
}
type dialFunctionType func(ctx context.Context, network, addr string) (net.Conn, error)
// Connect to a remote server resolving hostname using our own DNS server
func (d *Dnsfilter) createCustomDialContext(resolverAddr string) dialFunctionType {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
log.Tracef("network:%v addr:%v", network, addr)
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
dialer := &net.Dialer{
Timeout: time.Minute * 5,
}
if net.ParseIP(host) != nil {
con, err := dialer.DialContext(ctx, network, addr)
return con, err
}
cache := d.shouldBeInDialCache(host)
if cache {
ip := searchInDialCache(host)
if len(ip) != 0 {
addr = fmt.Sprintf("%s:%s", ip, port)
return dialer.DialContext(ctx, network, addr)
}
}
r := upstream.NewResolver(resolverAddr, 30*time.Second)
addrs, e := r.LookupIPAddr(ctx, host)
log.Tracef("LookupIPAddr: %s: %v", host, addrs)
if e != nil {
return nil, e
}
if len(addrs) == 0 {
return nil, fmt.Errorf("couldn't lookup host: %s", host)
}
var dialErrs []error
for _, a := range addrs {
addr = fmt.Sprintf("%s:%s", a.String(), port)
con, err := dialer.DialContext(ctx, network, addr)
if err != nil {
dialErrs = append(dialErrs, err)
continue
}
if cache {
addToDialCache(host, a.String())
}
return con, err
}
return nil, errorx.DecorateMany(fmt.Sprintf("couldn't dial to %s", addr), dialErrs...)
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7f69848084a68cdf1e227a555454991295fc5866 | go.sum |
|
<mask> if ip == nil {
<mask> return 0, nil
<mask> }
<mask> val = ip
<mask> if ip.To4() != nil {
<mask> val = ip.To4()
<mask> }
<mask>
<mask> default:
<mask> return 0, nil
<mask> }
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (s *statsCtx) getClientIP(clientIP string) string {
if s.conf.AnonymizeClientIP {
ip := net.ParseIP(clientIP)
if ip != nil {
ip4 := ip.To4()
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip4 != nil {
clientIP = ip4.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)).String()
} else {
clientIP = ip.Mask(net.CIDRMask(AnonymizeClientIP6Mask, 128)).String()
}
</s> add func (s *statsCtx) getClientIP(ip net.IP) (clientIP net.IP) {
if s.conf.AnonymizeClientIP && ip != nil {
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip.To4() != nil {
return ip.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)) </s> remove func (l *queryLog) getClientIP(clientIP string) string {
if l.conf.AnonymizeClientIP {
ip := net.ParseIP(clientIP)
if ip != nil {
ip4 := ip.To4()
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip4 != nil {
clientIP = ip4.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)).String()
} else {
clientIP = ip.Mask(net.CIDRMask(AnonymizeClientIP6Mask, 128)).String()
}
</s> add func (l *queryLog) getClientIP(ip net.IP) (clientIP net.IP) {
if l.conf.AnonymizeClientIP && ip != nil {
const AnonymizeClientIPv4Mask = 16
const AnonymizeClientIPv6Mask = 112
if ip.To4() != nil {
return ip.Mask(net.CIDRMask(AnonymizeClientIPv4Mask, 32)) </s> remove ip := dnsforward.IPStringFromAddr(d.Addr)
if ip == "" {
</s> add ip := dnsforward.IPFromAddr(d.Addr)
if ip == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/dhcpd.go |
|
assert.True(t, net.IP{192, 168, 10, 101}.Equal(ll[0].IP)) | <mask>
<mask> ll := s.srv4.GetLeases(LeasesAll)
<mask>
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:bb", ll[0].HWAddr.String())
<mask> assert.Equal(t, "192.168.10.101", ll[0].IP.String())
<mask> assert.EqualValues(t, leaseExpireStatic, ll[0].Expiry.Unix())
<mask>
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", ll[1].HWAddr.String())
<mask> assert.Equal(t, "192.168.10.100", ll[1].IP.String())
<mask> assert.Equal(t, exp1.Unix(), ll[1].Expiry.Unix())
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.100", ll[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(ll[1].IP)) </s> remove assert.Equal(t, "192.168.10.152", ls[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 152}.Equal(ls[1].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/dhcpd_test.go |
assert.True(t, net.IP{192, 168, 10, 100}.Equal(ll[1].IP)) | <mask> assert.Equal(t, "192.168.10.101", ll[0].IP.String())
<mask> assert.EqualValues(t, leaseExpireStatic, ll[0].Expiry.Unix())
<mask>
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", ll[1].HWAddr.String())
<mask> assert.Equal(t, "192.168.10.100", ll[1].IP.String())
<mask> assert.Equal(t, exp1.Unix(), ll[1].Expiry.Unix())
<mask>
<mask> _ = os.Remove("leases.db")
<mask> }
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.101", ll[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 101}.Equal(ll[0].IP)) </s> remove assert.Equal(t, "192.168.10.152", ls[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 152}.Equal(ls[1].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/dhcpd_test.go |
assert.True(t, net.IP{1, 2, 3, 4}.Equal(net.IP(val))) | <mask> assert.EqualValues(t, 0, code)
<mask>
<mask> code, val = parseOptionString("123 ip 1.2.3.4")
<mask> assert.EqualValues(t, 123, code)
<mask> assert.Equal(t, "1.2.3.4", net.IP(string(val)).String())
<mask>
<mask> code, _ = parseOptionString("256 ip 1.1.1.1")
<mask> assert.EqualValues(t, 0, code)
<mask> code, _ = parseOptionString("-1 ip 1.1.1.1")
<mask> assert.EqualValues(t, 0, code)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "127.0.0.1", topClients[0])
</s> add assert.True(t, net.IP{127, 0, 0, 1}.Equal(topClients[0])) </s> remove if ip.To4() != nil {
val = ip.To4()
}
</s> add </s> remove assert.Equal(t, "192.168.10.100", ll[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(ll[1].IP)) </s> remove assert.Equal(t, "192.168.10.152", ls[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 152}.Equal(ls[1].IP)) </s> remove assert.Equal(t, "192.168.10.101", ll[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 101}.Equal(ll[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/dhcpd_test.go |
RangeStart net.IP `json:"range_start"` | <mask> }
<mask> }
<mask>
<mask> type v6ServerConfJSON struct {
<mask> RangeStart string `json:"range_start"`
<mask> LeaseDuration uint32 `json:"lease_duration"`
<mask> }
<mask>
<mask> func v6JSONToServerConf(j v6ServerConfJSON) V6ServerConf {
<mask> return V6ServerConf{
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove IP string `json:"ip"`
</s> add IP net.IP `json:"ip"` </s> remove IP string `json:"ip"`
</s> add IP net.IP `json:"ip"` </s> remove BindHost string `yaml:"bind_host"`
</s> add BindHost net.IP `yaml:"bind_host"` </s> remove Addresses []string `json:"ip_addresses"`
</s> add Addresses []net.IP `json:"ip_addresses"` </s> remove RangeStart string `yaml:"range_start" json:"range_start"`
</s> add RangeStart net.IP `yaml:"range_start"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/dhcphttp.go |
result.V4.StaticIP.IP = util.GetSubnet(interfaceName).String() | <mask> result.V4.StaticIP.Static = "error"
<mask> result.V4.StaticIP.Error = err.Error()
<mask> } else if !isStaticIP {
<mask> result.V4.StaticIP.Static = "no"
<mask> result.V4.StaticIP.IP = util.GetSubnet(interfaceName)
<mask> }
<mask>
<mask> if found4 {
<mask> result.V4.OtherServer.Found = "yes"
<mask> } else if err4 != nil {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove } else if reqData.DNS.IP != "0.0.0.0" {
</s> add } else if !reqData.DNS.IP.IsUnspecified() { </s> remove resp.IP = util.GetSubnet(interfaceName)
</s> add resp.IP = util.GetSubnet(interfaceName).String() </s> remove } else if config.BindHost == "0.0.0.0" {
</s> add } else if config.BindHost.IsUnspecified() { </s> remove func (s *statsCtx) getClientIP(clientIP string) string {
if s.conf.AnonymizeClientIP {
ip := net.ParseIP(clientIP)
if ip != nil {
ip4 := ip.To4()
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip4 != nil {
clientIP = ip4.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)).String()
} else {
clientIP = ip.Mask(net.CIDRMask(AnonymizeClientIP6Mask, 128)).String()
}
</s> add func (s *statsCtx) getClientIP(ip net.IP) (clientIP net.IP) {
if s.conf.AnonymizeClientIP && ip != nil {
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip.To4() != nil {
return ip.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)) </s> remove log.Printf("Go to %s://%s", proto, net.JoinHostPort(config.BindHost, port))
</s> add hostStr = config.BindHost.String()
log.Printf("Go to %s://%s", proto, net.JoinHostPort(hostStr, port)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/dhcphttp.go |
RangeStart net.IP `yaml:"range_start"` | <mask> InterfaceName string `yaml:"-" json:"-"`
<mask>
<mask> // The first IP address for dynamic leases
<mask> // The last allowed IP address ends with 0xff byte
<mask> RangeStart string `yaml:"range_start" json:"range_start"`
<mask>
<mask> LeaseDuration uint32 `yaml:"lease_duration" json:"lease_duration"` // in seconds
<mask>
<mask> RaSlaacOnly bool `yaml:"ra_slaac_only" json:"-"` // send ICMPv6.RA packets without MO flags
<mask> RaAllowSlaac bool `yaml:"ra_allow_slaac" json:"-"` // send ICMPv6.RA packets with MO flags
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove Name string // Network interface name
MTU int // MTU
HardwareAddr string // Hardware address
Addresses []string // Array with the network interface addresses
Subnets []string // Array with CIDR addresses of this network interface
Flags string // Network interface flags (up, broadcast, etc)
</s> add Name string // Network interface name
MTU int // MTU
HardwareAddr string // Hardware address
Addresses []net.IP // Array with the network interface addresses
Subnets []*net.IPNet // Array with CIDR addresses of this network interface
Flags string // Network interface flags (up, broadcast, etc) </s> remove RangeStart string `json:"range_start"`
</s> add RangeStart net.IP `json:"range_start"` </s> remove bindHost string // host address to bind HTTP server on
</s> add bindHost net.IP // host address to bind HTTP server on </s> remove ClientIP string
</s> add ClientIP net.IP </s> remove IP string `json:"ip"`
</s> add IP net.IP `json:"ip"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/server.go |
assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | <mask>
<mask> // check
<mask> ls = s.GetLeases(LeasesStatic)
<mask> assert.Len(t, ls, 1)
<mask> assert.Equal(t, "192.168.10.150", ls[0].IP.String())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", ls[0].HWAddr.String())
<mask> assert.EqualValues(t, leaseExpireStatic, ls[0].Expiry.Unix())
<mask>
<mask> // try to remove static lease - fail
<mask> l.IP = net.IP{192, 168, 10, 110}
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.100", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.152", ls[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 152}.Equal(ls[1].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | <mask> // check
<mask> ls := s.GetLeases(LeasesStatic)
<mask> assert.Len(t, ls, 2)
<mask>
<mask> assert.Equal(t, "192.168.10.150", ls[0].IP.String())
<mask> assert.Equal(t, "33:aa:aa:aa:aa:aa", ls[0].HWAddr.String())
<mask> assert.EqualValues(t, leaseExpireStatic, ls[0].Expiry.Unix())
<mask>
<mask> assert.Equal(t, "192.168.10.152", ls[1].IP.String())
<mask> assert.Equal(t, "22:aa:aa:aa:aa:aa", ls[1].HWAddr.String())
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.152", ls[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 152}.Equal(ls[1].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 152}.Equal(ls[1].IP)) | <mask> assert.Equal(t, "192.168.10.150", ls[0].IP.String())
<mask> assert.Equal(t, "33:aa:aa:aa:aa:aa", ls[0].HWAddr.String())
<mask> assert.EqualValues(t, leaseExpireStatic, ls[0].Expiry.Unix())
<mask>
<mask> assert.Equal(t, "192.168.10.152", ls[1].IP.String())
<mask> assert.Equal(t, "22:aa:aa:aa:aa:aa", ls[1].HWAddr.String())
<mask> assert.EqualValues(t, leaseExpireStatic, ls[1].Expiry.Unix())
<mask> }
<mask>
<mask> func TestV4StaticLeaseGet(t *testing.T) {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.100", ll[1].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(ll[1].IP)) </s> remove assert.Equal(t, "192.168.10.101", ll[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 101}.Equal(ll[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) | <mask>
<mask> // check "Offer"
<mask> assert.Equal(t, dhcpv4.MessageTypeOffer, resp.MessageType())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", resp.ClientHWAddr.String())
<mask> assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
<mask> assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
<mask> assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
<mask> assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
<mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask>
<mask> // "Request"
<mask> req, _ = dhcpv4.NewRequestFromOffer(resp)
<mask> resp, _ = dhcpv4.NewReplyFromRequest(req)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "1.2.3.4", net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]).String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) | <mask>
<mask> // check "Ack"
<mask> assert.Equal(t, dhcpv4.MessageTypeAck, resp.MessageType())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", resp.ClientHWAddr.String())
<mask> assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
<mask> assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
<mask> assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
<mask> assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
<mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask>
<mask> dnsAddrs := resp.DNS()
<mask> assert.Len(t, dnsAddrs, 1)
<mask> assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | <mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask>
<mask> dnsAddrs := resp.DNS()
<mask> assert.Len(t, dnsAddrs, 1)
<mask> assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
<mask>
<mask> // check lease
<mask> ls := s.GetLeases(LeasesStatic)
<mask> assert.Len(t, ls, 1)
<mask> assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | <mask>
<mask> // check lease
<mask> ls := s.GetLeases(LeasesStatic)
<mask> assert.Len(t, ls, 1)
<mask> assert.Equal(t, "192.168.10.150", ls[0].IP.String())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", ls[0].HWAddr.String())
<mask> }
<mask>
<mask> func TestV4DynamicLeaseGet(t *testing.T) {
<mask> conf := V4ServerConf{
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.100", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) | <mask>
<mask> // check "Offer"
<mask> assert.Equal(t, dhcpv4.MessageTypeOffer, resp.MessageType())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", resp.ClientHWAddr.String())
<mask> assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
<mask> assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
<mask> assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
<mask> assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
<mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask> assert.Equal(t, []byte("012"), resp.Options[uint8(dhcpv4.OptionFQDN)])
<mask> assert.Equal(t, "1.2.3.4", net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]).String())
<mask>
<mask> // "Request"
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "1.2.3.4", net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]).String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{1, 2, 3, 4}.Equal(net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]))) | <mask> assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
<mask> assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
<mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask> assert.Equal(t, []byte("012"), resp.Options[uint8(dhcpv4.OptionFQDN)])
<mask> assert.Equal(t, "1.2.3.4", net.IP(resp.Options[uint8(dhcpv4.OptionRelayAgentInformation)]).String())
<mask>
<mask> // "Request"
<mask> req, _ = dhcpv4.NewRequestFromOffer(resp)
<mask> resp, _ = dhcpv4.NewReplyFromRequest(req)
<mask> assert.Equal(t, 1, s.process(req, resp))
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) | <mask>
<mask> // check "Ack"
<mask> assert.Equal(t, dhcpv4.MessageTypeAck, resp.MessageType())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", resp.ClientHWAddr.String())
<mask> assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
<mask> assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
<mask> assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
<mask> assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
<mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask>
<mask> dnsAddrs := resp.DNS()
<mask> assert.Len(t, dnsAddrs, 1)
<mask> assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) | <mask> assert.Equal(t, s.conf.leaseTime.Seconds(), resp.IPAddressLeaseTime(-1).Seconds())
<mask>
<mask> dnsAddrs := resp.DNS()
<mask> assert.Len(t, dnsAddrs, 1)
<mask> assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
<mask>
<mask> // check lease
<mask> ls := s.GetLeases(LeasesDynamic)
<mask> assert.Len(t, ls, 1)
<mask> assert.Equal(t, "192.168.10.100", ls[0].IP.String())
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.100", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.150", resp.YourIPAddr.String())
assert.Equal(t, "192.168.10.1", resp.Router()[0].String())
assert.Equal(t, "192.168.10.1", resp.ServerIdentifier().String())
assert.Equal(t, "255.255.255.0", net.IP(resp.SubnetMask()).String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(resp.YourIPAddr))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.Router()[0]))
assert.True(t, net.IP{192, 168, 10, 1}.Equal(resp.ServerIdentifier()))
assert.True(t, net.IP{255, 255, 255, 0}.Equal(net.IP(resp.SubnetMask()))) </s> remove assert.Equal(t, "192.168.10.100", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 100}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
assert.True(t, net.IP{192, 168, 10, 100}.Equal(ls[0].IP)) | <mask>
<mask> // check lease
<mask> ls := s.GetLeases(LeasesDynamic)
<mask> assert.Len(t, ls, 1)
<mask> assert.Equal(t, "192.168.10.100", ls[0].IP.String())
<mask> assert.Equal(t, "aa:aa:aa:aa:aa:aa", ls[0].HWAddr.String())
<mask>
<mask> start := net.IP{192, 168, 10, 100}
<mask> stop := net.IP{192, 168, 10, 200}
<mask> assert.False(t, ip4InRange(start, stop, net.IP{192, 168, 10, 99}))
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) </s> remove assert.Equal(t, "192.168.10.1", dnsAddrs[0].String())
</s> add assert.True(t, net.IP{192, 168, 10, 1}.Equal(dnsAddrs[0])) </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v4_test.go |
s.conf.ipStart = conf.RangeStart | <mask> if !conf.Enabled {
<mask> return s, nil
<mask> }
<mask>
<mask> s.conf.ipStart = net.ParseIP(conf.RangeStart)
<mask> if s.conf.ipStart == nil || s.conf.ipStart.To16() == nil {
<mask> return s, fmt.Errorf("dhcpv6: invalid range-start IP: %s", conf.RangeStart)
<mask> }
<mask>
<mask> if conf.LeaseDuration == 0 {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove if len(ent.IP) == 0 {
ent.IP = v
</s> add if ent.IP == nil {
ent.IP = net.ParseIP(v) </s> remove ip := util.GetSubnet(ifaceName)
if len(ip) == 0 {
</s> add ipNet := util.GetSubnet(ifaceName)
if ipNet.IP == nil { </s> remove return clientIP
</s> add return ip </s> remove if ip.To4() != nil {
val = ip.To4()
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v6.go |
RangeStart: net.ParseIP("2001::1"), | <mask>
<mask> func TestV6StaticLeaseAddRemove(t *testing.T) {
<mask> conf := V6ServerConf{
<mask> Enabled: true,
<mask> RangeStart: "2001::1",
<mask> notify: notify6,
<mask> }
<mask> s, err := v6Create(conf)
<mask> assert.Nil(t, err)
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::2",
</s> add RangeStart: net.ParseIP("2001::2"), </s> remove s.conf.FilterHandler = func(_ string, settings *dnsfilter.RequestFilteringSettings) {
</s> add s.conf.FilterHandler = func(_ net.IP, settings *dnsfilter.RequestFilteringSettings) { </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v6_test.go |
RangeStart: net.ParseIP("2001::1"), | <mask>
<mask> func TestV6StaticLeaseAddReplaceDynamic(t *testing.T) {
<mask> conf := V6ServerConf{
<mask> Enabled: true,
<mask> RangeStart: "2001::1",
<mask> notify: notify6,
<mask> }
<mask> sIface, err := v6Create(conf)
<mask> s := sIface.(*v6Server)
<mask> assert.Nil(t, err)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::2",
</s> add RangeStart: net.ParseIP("2001::2"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove s.conf.FilterHandler = func(_ string, settings *dnsfilter.RequestFilteringSettings) {
</s> add s.conf.FilterHandler = func(_ net.IP, settings *dnsfilter.RequestFilteringSettings) { </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v6_test.go |
RangeStart: net.ParseIP("2001::1"), | <mask>
<mask> func TestV6GetLease(t *testing.T) {
<mask> conf := V6ServerConf{
<mask> Enabled: true,
<mask> RangeStart: "2001::1",
<mask> notify: notify6,
<mask> }
<mask> sIface, err := v6Create(conf)
<mask> s := sIface.(*v6Server)
<mask> assert.Nil(t, err)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::2",
</s> add RangeStart: net.ParseIP("2001::2"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove s.conf.FilterHandler = func(_ string, settings *dnsfilter.RequestFilteringSettings) {
</s> add s.conf.FilterHandler = func(_ net.IP, settings *dnsfilter.RequestFilteringSettings) { </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v6_test.go |
RangeStart: net.ParseIP("2001::2"), | <mask>
<mask> func TestV6GetDynamicLease(t *testing.T) {
<mask> conf := V6ServerConf{
<mask> Enabled: true,
<mask> RangeStart: "2001::2",
<mask> notify: notify6,
<mask> }
<mask> sIface, err := v6Create(conf)
<mask> s := sIface.(*v6Server)
<mask> assert.Nil(t, err)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove s.conf.FilterHandler = func(_ string, settings *dnsfilter.RequestFilteringSettings) {
</s> add s.conf.FilterHandler = func(_ net.IP, settings *dnsfilter.RequestFilteringSettings) { </s> remove assert.Equal(t, "192.168.10.150", ls[0].IP.String())
</s> add assert.True(t, net.IP{192, 168, 10, 150}.Equal(ls[0].IP)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dhcpd/v6_test.go |
ClientIP net.IP | <mask> SafeBrowsingEnabled bool
<mask> ParentalEnabled bool
<mask>
<mask> ClientName string
<mask> ClientIP string
<mask> ClientTags []string
<mask>
<mask> ServicesRules []ServiceEntry
<mask> }
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove IP string `json:"ip"`
</s> add IP net.IP `json:"ip"` </s> remove bindHost string // host address to bind HTTP server on
</s> add bindHost net.IP // host address to bind HTTP server on </s> remove RangeStart string `yaml:"range_start" json:"range_start"`
</s> add RangeStart net.IP `yaml:"range_start"` </s> remove BindHost string
</s> add BindHost net.IP </s> remove Addresses []string `json:"ip_addresses"`
</s> add Addresses []net.IP `json:"ip_addresses"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/dnsfilter.go |
// TODO(e.burkov): Wait for urlfilter update to pass net.IP.
ClientIP: setts.ClientIP.String(),
ClientName: setts.ClientName,
DNSType: qtype, | <mask>
<mask> ureq := urlfilter.DNSRequest{
<mask> Hostname: host,
<mask> SortedClientTags: setts.ClientTags,
<mask> ClientIP: setts.ClientIP,
<mask> ClientName: setts.ClientName,
<mask> DNSType: qtype,
<mask> }
<mask>
<mask> if d.filteringEngineAllow != nil {
<mask> dnsres, ok := d.filteringEngineAllow.MatchRequest(ureq)
<mask> if ok {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove _, ok := a.disallowedClients[ip]
</s> add _, ok := a.disallowedClients[ipStr] </s> remove _, ok := a.allowedClients[ip]
</s> add _, ok := a.allowedClients[ipStr] </s> remove c, ok := clients.idIndex[ip]
</s> add c, ok := clients.idIndex[ip.String()] </s> remove return true, ip
</s> add return true, ipStr </s> remove c, ok := clients.findByIP(ip)
</s> add c, ok := clients.findByIP(net.ParseIP(ip)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/dnsfilter.go |
assert.True(t, net.IP{1, 1, 1, 1}.Equal(r.IPList[0])) | <mask> // match exact
<mask> r := d.processRewrites("host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
<mask> assert.Equal(t, "1.1.1.1", r.IPList[0].String())
<mask>
<mask> // match L2
<mask> r = d.processRewrites("sub.host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "3.3.3.3", r.IPList[0].String())
</s> add assert.True(t, net.IP{3, 3, 3, 3}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/rewrites_test.go |
assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) | <mask> // match L2
<mask> r = d.processRewrites("sub.host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
<mask> assert.Equal(t, "2.2.2.2", r.IPList[0].String())
<mask>
<mask> // match L3
<mask> r = d.processRewrites("my.sub.host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "1.1.1.1", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 1, 1, 1}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "3.3.3.3", r.IPList[0].String())
</s> add assert.True(t, net.IP{3, 3, 3, 3}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/rewrites_test.go |
assert.True(t, net.IP{3, 3, 3, 3}.Equal(r.IPList[0])) | <mask> // match L3
<mask> r = d.processRewrites("my.sub.host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
<mask> assert.Equal(t, "3.3.3.3", r.IPList[0].String())
<mask> }
<mask>
<mask> func TestRewritesExceptionCNAME(t *testing.T) {
<mask> d := DNSFilter{}
<mask> // wildcard; exception for a sub-domain
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.1.1.1", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 1, 1, 1}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/rewrites_test.go |
assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) | <mask> // match sub-domain
<mask> r := d.processRewrites("my.host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
<mask> assert.Equal(t, "2.2.2.2", r.IPList[0].String())
<mask>
<mask> // match sub-domain, but handle exception
<mask> r = d.processRewrites("sub.host.com", dns.TypeA)
<mask> assert.Equal(t, NotFilteredNotFound, r.Reason)
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.1.1.1", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 1, 1, 1}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "3.3.3.3", r.IPList[0].String())
</s> add assert.True(t, net.IP{3, 3, 3, 3}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/rewrites_test.go |
assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) | <mask> // match sub-domain
<mask> r := d.processRewrites("my.host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
<mask> assert.Equal(t, "2.2.2.2", r.IPList[0].String())
<mask>
<mask> // match sub-domain, but handle exception
<mask> r = d.processRewrites("my.sub.host.com", dns.TypeA)
<mask> assert.Equal(t, NotFilteredNotFound, r.Reason)
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "1.1.1.1", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 1, 1, 1}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "3.3.3.3", r.IPList[0].String())
</s> add assert.True(t, net.IP{3, 3, 3, 3}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/rewrites_test.go |
assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) | <mask> // match domain
<mask> r := d.processRewrites("host.com", dns.TypeA)
<mask> assert.Equal(t, Rewritten, r.Reason)
<mask> assert.Len(t, r.IPList, 1)
<mask> assert.Equal(t, "1.2.3.4", r.IPList[0].String())
<mask>
<mask> // match exception
<mask> r = d.processRewrites("host.com", dns.TypeAAAA)
<mask> assert.Equal(t, NotFilteredNotFound, r.Reason)
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "1.1.1.1", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 1, 1, 1}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "2.2.2.2", r.IPList[0].String())
</s> add assert.True(t, net.IP{2, 2, 2, 2}.Equal(r.IPList[0])) </s> remove assert.Equal(t, "3.3.3.3", r.IPList[0].String())
</s> add assert.True(t, net.IP{3, 3, 3, 3}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsfilter/rewrites_test.go |
func (a *accessCtx) IsBlockedIP(ip net.IP) (bool, string) {
ipStr := ip.String()
| <mask> // IsBlockedIP - return TRUE if this client should be blocked
<mask> // Returns the item from the "disallowedClients" list that lead to blocking IP.
<mask> // If it returns TRUE and an empty string, it means that the "allowedClients" is not empty,
<mask> // but the ip does not belong to it.
<mask> func (a *accessCtx) IsBlockedIP(ip string) (bool, string) {
<mask> a.lock.Lock()
<mask> defer a.lock.Unlock()
<mask>
<mask> if len(a.allowedClients) != 0 || len(a.allowedClientsIPNet) != 0 {
<mask> _, ok := a.allowedClients[ip]
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (s *Server) IsBlockedIP(ip string) (bool, string) {
</s> add func (s *Server) IsBlockedIP(ip net.IP) (bool, string) { </s> remove _, ok := a.allowedClients[ip]
</s> add _, ok := a.allowedClients[ipStr] </s> remove // GetSubnet - Get IP address with netmask for the specified interface
// Returns an empty string if it fails to find it
func GetSubnet(ifaceName string) string {
</s> add // GetSubnet returns pointer to net.IPNet for the specified interface or nil if
// the search fails.
func GetSubnet(ifaceName string) *net.IPNet { </s> remove func (clients *clientsContainer) findTemporary(ip string) (cj clientJSON, found bool) {
</s> add func (clients *clientsContainer) findTemporary(ip net.IP) (cj clientJSON, found bool) {
ipStr := ip.String() </s> remove ipChannel chan string // pass data from DNS request handling thread to rDNS thread
</s> add ipChannel chan net.IP // pass data from DNS request handling thread to rDNS thread | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
_, ok := a.allowedClients[ipStr] | <mask> a.lock.Lock()
<mask> defer a.lock.Unlock()
<mask>
<mask> if len(a.allowedClients) != 0 || len(a.allowedClientsIPNet) != 0 {
<mask> _, ok := a.allowedClients[ip]
<mask> if ok {
<mask> return false, ""
<mask> }
<mask>
<mask> if len(a.allowedClientsIPNet) != 0 {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove func (a *accessCtx) IsBlockedIP(ip string) (bool, string) {
</s> add func (a *accessCtx) IsBlockedIP(ip net.IP) (bool, string) {
ipStr := ip.String()
</s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove _, ok := a.disallowedClients[ip]
</s> add _, ok := a.disallowedClients[ipStr] </s> remove return true, ip
</s> add return true, ipStr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
<mask> return false, ""
<mask> }
<mask>
<mask> if len(a.allowedClientsIPNet) != 0 {
<mask> ipAddr := net.ParseIP(ip)
<mask> for _, ipnet := range a.allowedClientsIPNet {
<mask> if ipnet.Contains(ipAddr) {
<mask> return false, ""
<mask> }
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove _, ok := a.allowedClients[ip]
</s> add _, ok := a.allowedClients[ipStr] </s> remove return true, ip
</s> add return true, ipStr | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
|
if ipnet.Contains(ip) { | <mask>
<mask> if len(a.allowedClientsIPNet) != 0 {
<mask> ipAddr := net.ParseIP(ip)
<mask> for _, ipnet := range a.allowedClientsIPNet {
<mask> if ipnet.Contains(ipAddr) {
<mask> return false, ""
<mask> }
<mask> }
<mask> }
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove return true, ip
</s> add return true, ipStr </s> remove _, ok := a.allowedClients[ip]
</s> add _, ok := a.allowedClients[ipStr] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
_, ok := a.disallowedClients[ipStr] | <mask>
<mask> return true, ""
<mask> }
<mask>
<mask> _, ok := a.disallowedClients[ip]
<mask> if ok {
<mask> return true, ip
<mask> }
<mask>
<mask> if len(a.disallowedClientsIPNet) != 0 {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove return true, ip
</s> add return true, ipStr </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove _, ok := a.allowedClients[ip]
</s> add _, ok := a.allowedClients[ipStr] </s> remove ipAddr := net.ParseIP(ip)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
return true, ipStr | <mask> }
<mask>
<mask> _, ok := a.disallowedClients[ip]
<mask> if ok {
<mask> return true, ip
<mask> }
<mask>
<mask> if len(a.disallowedClientsIPNet) != 0 {
<mask> ipAddr := net.ParseIP(ip)
<mask> for _, ipnet := range a.disallowedClientsIPNet {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove _, ok := a.disallowedClients[ip]
</s> add _, ok := a.disallowedClients[ipStr] </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove ipAddr := net.ParseIP(ip)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
<mask> return true, ip
<mask> }
<mask>
<mask> if len(a.disallowedClientsIPNet) != 0 {
<mask> ipAddr := net.ParseIP(ip)
<mask> for _, ipnet := range a.disallowedClientsIPNet {
<mask> if ipnet.Contains(ipAddr) {
<mask> return true, ipnet.String()
<mask> }
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove return true, ip
</s> add return true, ipStr </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove _, ok := a.disallowedClients[ip]
</s> add _, ok := a.disallowedClients[ipStr] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
|
if ipnet.Contains(ip) { | <mask>
<mask> if len(a.disallowedClientsIPNet) != 0 {
<mask> ipAddr := net.ParseIP(ip)
<mask> for _, ipnet := range a.disallowedClientsIPNet {
<mask> if ipnet.Contains(ipAddr) {
<mask> return true, ipnet.String()
<mask> }
<mask> }
<mask> }
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove return true, ip
</s> add return true, ipStr </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove ipAddr := net.ParseIP(ip)
</s> add </s> remove _, ok := a.disallowedClients[ip]
</s> add _, ok := a.disallowedClients[ipStr] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access.go |
"net" | <mask> package dnsforward
<mask>
<mask> import (
<mask> "testing"
<mask>
<mask> "github.com/stretchr/testify/assert"
<mask> )
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule := a.IsBlockedIP(net.IPv4(1, 1, 1, 1)) | <mask> func TestIsBlockedIPAllowed(t *testing.T) {
<mask> a := &accessCtx{}
<mask> assert.Nil(t, a.Init([]string{"1.1.1.1", "2.2.0.0/16"}, nil, nil))
<mask>
<mask> disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
<mask> assert.True(t, disallowed)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
</s> add disallowed, disallowedRule := a.IsBlockedIP(net.IPv4(1, 1, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) | <mask> disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
<mask> assert.True(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
<mask> assert.False(t, disallowed)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
</s> add disallowed, disallowedRule := a.IsBlockedIP(net.IPv4(1, 1, 1, 1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) | <mask> disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
<mask> assert.True(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
<mask> assert.True(t, disallowed)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) | <mask> disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
<mask> assert.True(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask> }
<mask>
<mask> func TestIsBlockedIPDisallowed(t *testing.T) {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule := a.IsBlockedIP(net.IPv4(1, 1, 1, 1)) | <mask> func TestIsBlockedIPDisallowed(t *testing.T) {
<mask> a := &accessCtx{}
<mask> assert.Nil(t, a.Init(nil, []string{"1.1.1.1", "2.2.0.0/16"}, nil))
<mask>
<mask> disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
<mask> assert.True(t, disallowed)
<mask> assert.Equal(t, "1.1.1.1", disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
<mask> assert.False(t, disallowed)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
</s> add disallowed, disallowedRule := a.IsBlockedIP(net.IPv4(1, 1, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) | <mask> disallowed, disallowedRule := a.IsBlockedIP("1.1.1.1")
<mask> assert.True(t, disallowed)
<mask> assert.Equal(t, "1.1.1.1", disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
<mask> assert.True(t, disallowed)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) | <mask> disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
<mask> assert.True(t, disallowed)
<mask> assert.Equal(t, "2.2.0.0/16", disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
<mask> assert.False(t, disallowed)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) | <mask> disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
<mask> assert.True(t, disallowed)
<mask> assert.Equal(t, "2.2.0.0/16", disallowedRule)
<mask>
<mask> disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
<mask> assert.False(t, disallowed)
<mask> assert.Empty(t, disallowedRule)
<mask> }
<mask>
<mask> func TestIsBlockedIPBlockedDomain(t *testing.T) {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.3.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 3, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("2.2.1.1")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(2, 2, 1, 1)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) </s> remove disallowed, disallowedRule = a.IsBlockedIP("1.1.1.2")
</s> add disallowed, disallowedRule = a.IsBlockedIP(net.IPv4(1, 1, 1, 2)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/access_test.go |
FilterHandler func(clientAddr net.IP, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` | <mask> // Callbacks for other modules
<mask> // --
<mask>
<mask> // Filtering callback function
<mask> FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"`
<mask>
<mask> // GetCustomUpstreamByClient - a callback function that returns upstreams configuration
<mask> // based on the client IP address. Returns nil if there are no custom upstreams for the client
<mask> // TODO(e.burkov): replace argument type with net.IP.
<mask> GetCustomUpstreamByClient func(clientAddr string) *proxy.UpstreamConfig `yaml:"-"`
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove // TODO(e.burkov): replace argument type with net.IP.
</s> add // TODO(e.burkov): Replace argument type with net.IP. </s> remove func (a *accessCtx) IsBlockedIP(ip string) (bool, string) {
</s> add func (a *accessCtx) IsBlockedIP(ip net.IP) (bool, string) {
ipStr := ip.String()
</s> remove // GetSubnet - Get IP address with netmask for the specified interface
// Returns an empty string if it fails to find it
func GetSubnet(ifaceName string) string {
</s> add // GetSubnet returns pointer to net.IPNet for the specified interface or nil if
// the search fails.
func GetSubnet(ifaceName string) *net.IPNet { </s> remove // TODO(e.burkov): this should removed with the API v1 when the appropriate
</s> add // TODO(e.burkov): This should removed with the API v1 when the appropriate </s> remove BindHost string `yaml:"bind_host"` // BindHost is the IP address of the HTTP server to bind to
</s> add BindHost net.IP `yaml:"bind_host"` // BindHost is the IP address of the HTTP server to bind to | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/config.go |
// TODO(e.burkov): Replace argument type with net.IP. | <mask> FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"`
<mask>
<mask> // GetCustomUpstreamByClient - a callback function that returns upstreams configuration
<mask> // based on the client IP address. Returns nil if there are no custom upstreams for the client
<mask> // TODO(e.burkov): replace argument type with net.IP.
<mask> GetCustomUpstreamByClient func(clientAddr string) *proxy.UpstreamConfig `yaml:"-"`
<mask>
<mask> // Protection configuration
<mask> // --
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"`
</s> add FilterHandler func(clientAddr net.IP, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove func (a *accessCtx) IsBlockedIP(ip string) (bool, string) {
</s> add func (a *accessCtx) IsBlockedIP(ip net.IP) (bool, string) {
ipStr := ip.String()
</s> remove // GetSubnet - Get IP address with netmask for the specified interface
// Returns an empty string if it fails to find it
func GetSubnet(ifaceName string) string {
</s> add // GetSubnet returns pointer to net.IPNet for the specified interface or nil if
// the search fails.
func GetSubnet(ifaceName string) *net.IPNet { </s> remove GetTopClientsIP(limit uint) []string
</s> add GetTopClientsIP(limit uint) []net.IP </s> remove BindHost string `yaml:"bind_host"` // BindHost is the IP address of the HTTP server to bind to
</s> add BindHost net.IP `yaml:"bind_host"` // BindHost is the IP address of the HTTP server to bind to | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/config.go |
func (s *Server) IsBlockedIP(ip net.IP) (bool, string) { | <mask> }
<mask> }
<mask>
<mask> // IsBlockedIP - return TRUE if this client should be blocked
<mask> func (s *Server) IsBlockedIP(ip string) (bool, string) {
<mask> return s.access.IsBlockedIP(ip)
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (a *accessCtx) IsBlockedIP(ip string) (bool, string) {
</s> add func (a *accessCtx) IsBlockedIP(ip net.IP) (bool, string) {
ipStr := ip.String()
</s> remove ip := IPStringFromAddr(d.Addr)
</s> add ip := IPFromAddr(d.Addr) </s> remove clientAddr := IPStringFromAddr(d.Addr)
s.conf.FilterHandler(clientAddr, &setts)
</s> add s.conf.FilterHandler(IPFromAddr(d.Addr), &setts) </s> remove func (s *statsCtx) GetTopClientsIP(maxCount uint) []string {
</s> add func (s *statsCtx) GetTopClientsIP(maxCount uint) []net.IP { </s> remove func (s *statsCtx) getClientIP(clientIP string) string {
if s.conf.AnonymizeClientIP {
ip := net.ParseIP(clientIP)
if ip != nil {
ip4 := ip.To4()
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip4 != nil {
clientIP = ip4.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)).String()
} else {
clientIP = ip.Mask(net.CIDRMask(AnonymizeClientIP6Mask, 128)).String()
}
</s> add func (s *statsCtx) getClientIP(ip net.IP) (clientIP net.IP) {
if s.conf.AnonymizeClientIP && ip != nil {
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip.To4() != nil {
return ip.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/dnsforward.go |
assert.True(t, net.IP{192, 168, 0, 1}.Equal(reply.Answer[0].(*dns.A).A)) | <mask>
<mask> assert.Nil(t, err)
<mask> assert.Equal(t, dns.RcodeSuccess, reply.Rcode)
<mask> assert.NotNil(t, reply.Answer)
<mask> assert.Equal(t, "192.168.0.1", reply.Answer[0].(*dns.A).A.String())
<mask> assert.Nil(t, s.Stop())
<mask> }
<mask>
<mask> // testUpstream is a mock of real upstream.
<mask> // specify fields with necessary values to simulate real upstream behaviour
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "1.2.3.4", a.A.String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(a.A)) </s> remove assert.Equal(t, "1.2.3.4", reply.Answer[1].(*dns.A).A.String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(reply.Answer[1].(*dns.A).A)) </s> remove assert.Equal(t, answer, ip.String())
</s> add assert.Equal(t, answer, ip) </s> remove ip := proxyutil.GetIPFromDNSRecord(msg.Answer[0])
</s> add ip := proxyutil.GetIPFromDNSRecord(msg.Answer[0]).To16() </s> remove c, b := clients.Find("1.1.1.2")
</s> add c, b := clients.Find(net.IPv4(1, 1, 1, 2)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/dnsforward_test.go |
s.conf.FilterHandler = func(_ net.IP, settings *dnsfilter.RequestFilteringSettings) { | <mask>
<mask> func TestClientRulesForCNAMEMatching(t *testing.T) {
<mask> s := createTestServer(t)
<mask> testUpstm := &testUpstream{testCNAMEs, testIPv4, nil}
<mask> s.conf.FilterHandler = func(_ string, settings *dnsfilter.RequestFilteringSettings) {
<mask> settings.FilteringEnabled = false
<mask> }
<mask> err := s.startWithUpstream(testUpstm)
<mask> assert.Nil(t, err)
<mask> addr := s.dnsProxy.Addr(proxy.ProtoUDP)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove RangeStart: "2001::2",
</s> add RangeStart: net.ParseIP("2001::2"), </s> remove RangeStart: "2001::1",
</s> add RangeStart: net.ParseIP("2001::1"), </s> remove if ip == addr {
</s> add if ip.Equal(addr) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/dnsforward_test.go |
assert.True(t, net.IP{0, 0, 0, 1}.Equal(a.A)) | <mask> assert.Nil(t, err)
<mask> assert.Len(t, reply.Answer, 1)
<mask> a, ok := reply.Answer[0].(*dns.A)
<mask> assert.True(t, ok)
<mask> assert.Equal(t, "0.0.0.1", a.A.String())
<mask>
<mask> req = createTestMessageWithType("null.example.org.", dns.TypeAAAA)
<mask> reply, err = dns.Exchange(req, addr.String())
<mask> assert.Nil(t, err)
<mask> assert.Len(t, reply.Answer, 1)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "1.2.3.4", a.A.String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(a.A)) </s> remove assert.Equal(t, "1.2.3.4", reply.Answer[1].(*dns.A).A.String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(reply.Answer[1].(*dns.A).A)) </s> remove c, b := clients.Find("1.1.1.2")
</s> add c, b := clients.Find(net.IPv4(1, 1, 1, 2)) </s> remove ip := proxyutil.GetIPFromDNSRecord(msg.Answer[0])
</s> add ip := proxyutil.GetIPFromDNSRecord(msg.Answer[0]).To16() </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/dnsforward_test.go |
assert.True(t, net.IP{1, 2, 3, 4}.Equal(a.A)) | <mask> assert.Nil(t, err)
<mask> assert.Len(t, reply.Answer, 1)
<mask> a, ok := reply.Answer[0].(*dns.A)
<mask> assert.True(t, ok)
<mask> assert.Equal(t, "1.2.3.4", a.A.String())
<mask>
<mask> req = createTestMessageWithType("test.com.", dns.TypeAAAA)
<mask> reply, err = dns.Exchange(req, addr.String())
<mask> assert.Nil(t, err)
<mask> assert.Empty(t, reply.Answer)
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "0.0.0.1", a.A.String())
</s> add assert.True(t, net.IP{0, 0, 0, 1}.Equal(a.A)) </s> remove assert.Equal(t, "1.2.3.4", reply.Answer[1].(*dns.A).A.String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(reply.Answer[1].(*dns.A).A)) </s> remove c, b := clients.Find("1.1.1.2")
</s> add c, b := clients.Find(net.IPv4(1, 1, 1, 2)) </s> remove assert.Equal(t, "192.168.0.1", reply.Answer[0].(*dns.A).A.String())
</s> add assert.True(t, net.IP{192, 168, 0, 1}.Equal(reply.Answer[0].(*dns.A).A)) </s> remove assert.Equal(t, "1.2.3.4", r.IPList[0].String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(r.IPList[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/dnsforward_test.go |
assert.True(t, net.IP{1, 2, 3, 4}.Equal(reply.Answer[1].(*dns.A).A)) | <mask> reply, err = dns.Exchange(req, addr.String())
<mask> assert.Nil(t, err)
<mask> assert.Len(t, reply.Answer, 2)
<mask> assert.Equal(t, "test.com.", reply.Answer[0].(*dns.CNAME).Target)
<mask> assert.Equal(t, "1.2.3.4", reply.Answer[1].(*dns.A).A.String())
<mask>
<mask> req = createTestMessageWithType("my.alias.example.org.", dns.TypeA)
<mask> reply, err = dns.Exchange(req, addr.String())
<mask> assert.Nil(t, err)
<mask> assert.Equal(t, "my.alias.example.org.", reply.Question[0].Name) // the original question is restored
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove assert.Equal(t, "1.2.3.4", a.A.String())
</s> add assert.True(t, net.IP{1, 2, 3, 4}.Equal(a.A)) </s> remove assert.Equal(t, "0.0.0.1", a.A.String())
</s> add assert.True(t, net.IP{0, 0, 0, 1}.Equal(a.A)) </s> remove c, b := clients.Find("1.1.1.2")
</s> add c, b := clients.Find(net.IPv4(1, 1, 1, 2)) </s> remove c, b = clients.Find("1.1.1.1")
</s> add c, b = clients.Find(net.IPv4(1, 1, 1, 1)) </s> remove assert.Equal(t, "192.168.0.1", reply.Answer[0].(*dns.A).A.String())
</s> add assert.True(t, net.IP{192, 168, 0, 1}.Equal(reply.Answer[0].(*dns.A).A)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/dnsforward_test.go |
ip := IPFromAddr(d.Addr) | <mask> "github.com/miekg/dns"
<mask> )
<mask>
<mask> func (s *Server) beforeRequestHandler(_ *proxy.Proxy, d *proxy.DNSContext) (bool, error) {
<mask> ip := IPStringFromAddr(d.Addr)
<mask> disallowed, _ := s.access.IsBlockedIP(ip)
<mask> if disallowed {
<mask> log.Tracef("Client IP %s is blocked by settings", ip)
<mask> return false, nil
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (s *Server) IsBlockedIP(ip string) (bool, string) {
</s> add func (s *Server) IsBlockedIP(ip net.IP) (bool, string) { </s> remove clientAddr := IPStringFromAddr(d.Addr)
s.conf.FilterHandler(clientAddr, &setts)
</s> add s.conf.FilterHandler(IPFromAddr(d.Addr), &setts) </s> remove func (s *statsCtx) GetTopClientsIP(maxCount uint) []string {
</s> add func (s *statsCtx) GetTopClientsIP(maxCount uint) []net.IP { </s> remove ip := util.GetSubnet(ifaceName)
if len(ip) == 0 {
</s> add ipNet := util.GetSubnet(ifaceName)
if ipNet.IP == nil { </s> remove ip := dnsforward.IPStringFromAddr(d.Addr)
if ip == "" {
</s> add ip := dnsforward.IPFromAddr(d.Addr)
if ip == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/filter.go |
s.conf.FilterHandler(IPFromAddr(d.Addr), &setts) | <mask> func (s *Server) getClientRequestFilteringSettings(d *proxy.DNSContext) *dnsfilter.RequestFilteringSettings {
<mask> setts := s.dnsFilter.GetConfig()
<mask> setts.FilteringEnabled = true
<mask> if s.conf.FilterHandler != nil {
<mask> clientAddr := IPStringFromAddr(d.Addr)
<mask> s.conf.FilterHandler(clientAddr, &setts)
<mask> }
<mask> return &setts
<mask> }
<mask>
<mask> // filterDNSRequest applies the dnsFilter and sets d.Res if the request
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ip := IPStringFromAddr(d.Addr)
</s> add ip := IPFromAddr(d.Addr) </s> remove if len(clientAddr) == 0 {
</s> add if clientAddr == nil { </s> remove func (s *Server) IsBlockedIP(ip string) (bool, string) {
</s> add func (s *Server) IsBlockedIP(ip net.IP) (bool, string) { </s> remove func (s *statsCtx) GetTopClientsIP(maxCount uint) []string {
</s> add func (s *statsCtx) GetTopClientsIP(maxCount uint) []net.IP { </s> remove ip := dnsforward.IPStringFromAddr(d.Addr)
if ip == "" {
</s> add ip := dnsforward.IPFromAddr(d.Addr)
if ip == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/filter.go |
ClientIP: IPFromAddr(d.Addr), | <mask> Answer: d.Res,
<mask> OrigAnswer: ctx.origResp,
<mask> Result: ctx.result,
<mask> Elapsed: elapsed,
<mask> ClientIP: ipFromAddr(d.Addr),
<mask> }
<mask>
<mask> switch d.Proto {
<mask> case proxy.ProtoHTTPS:
<mask> p.ClientProto = querylog.ClientProtoDOH
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ClientIP: net.ParseIP(client),
</s> add ClientIP: client, </s> remove answer["value"] = v.A.String()
</s> add answer["value"] = v.A </s> remove answer["value"] = v.AAAA.String()
</s> add answer["value"] = v.AAAA </s> remove IP: l.getClientIP(params.ClientIP.String()),
</s> add IP: l.getClientIP(params.ClientIP), </s> remove // ipFromAddr gets IP address from addr.
func ipFromAddr(addr net.Addr) (ip net.IP) {
</s> add // IPFromAddr gets IP address from addr.
func IPFromAddr(addr net.Addr) (ip net.IP) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/stats.go |
// IPFromAddr gets IP address from addr.
func IPFromAddr(addr net.Addr) (ip net.IP) { | <mask>
<mask> "github.com/AdguardTeam/golibs/utils"
<mask> )
<mask>
<mask> // ipFromAddr gets IP address from addr.
<mask> func ipFromAddr(addr net.Addr) (ip net.IP) {
<mask> switch addr := addr.(type) {
<mask> case *net.UDPAddr:
<mask> return addr.IP
<mask> case *net.TCPAddr:
<mask> return addr.IP
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove answer["value"] = v.AAAA.String()
</s> add answer["value"] = v.AAAA </s> remove answer["value"] = v.A.String()
</s> add answer["value"] = v.A </s> remove func IPStringFromAddr(addr net.Addr) (ipstr string) {
if ip := ipFromAddr(addr); ip != nil {
</s> add func IPStringFromAddr(addr net.Addr) (ipStr string) {
if ip := IPFromAddr(addr); ip != nil { </s> remove ClientIP: ipFromAddr(d.Addr),
</s> add ClientIP: IPFromAddr(d.Addr), </s> remove func (r *RDNS) Begin(ip string) {
</s> add func (r *RDNS) Begin(ip net.IP) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/util.go |
func IPStringFromAddr(addr net.Addr) (ipStr string) {
if ip := IPFromAddr(addr); ip != nil { | <mask>
<mask> // IPStringFromAddr extracts IP address from net.Addr.
<mask> // Note: we can't use net.SplitHostPort(a.String()) because of IPv6 zone:
<mask> // https://github.com/AdguardTeam/AdGuardHome/internal/issues/1261
<mask> func IPStringFromAddr(addr net.Addr) (ipstr string) {
<mask> if ip := ipFromAddr(addr); ip != nil {
<mask> return ip.String()
<mask> }
<mask>
<mask> return ""
<mask> }
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ip := dnsforward.IPStringFromAddr(d.Addr)
if ip == "" {
</s> add ip := dnsforward.IPFromAddr(d.Addr)
if ip == nil { </s> remove // ipFromAddr gets IP address from addr.
func ipFromAddr(addr net.Addr) (ip net.IP) {
</s> add // IPFromAddr gets IP address from addr.
func IPFromAddr(addr net.Addr) (ip net.IP) { </s> remove func (s *statsCtx) getClientIP(clientIP string) string {
if s.conf.AnonymizeClientIP {
ip := net.ParseIP(clientIP)
if ip != nil {
ip4 := ip.To4()
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip4 != nil {
clientIP = ip4.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)).String()
} else {
clientIP = ip.Mask(net.CIDRMask(AnonymizeClientIP6Mask, 128)).String()
}
</s> add func (s *statsCtx) getClientIP(ip net.IP) (clientIP net.IP) {
if s.conf.AnonymizeClientIP && ip != nil {
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip.To4() != nil {
return ip.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)) </s> remove func (l *queryLog) getClientIP(clientIP string) string {
if l.conf.AnonymizeClientIP {
ip := net.ParseIP(clientIP)
if ip != nil {
ip4 := ip.To4()
const AnonymizeClientIP4Mask = 16
const AnonymizeClientIP6Mask = 112
if ip4 != nil {
clientIP = ip4.Mask(net.CIDRMask(AnonymizeClientIP4Mask, 32)).String()
} else {
clientIP = ip.Mask(net.CIDRMask(AnonymizeClientIP6Mask, 128)).String()
}
</s> add func (l *queryLog) getClientIP(ip net.IP) (clientIP net.IP) {
if l.conf.AnonymizeClientIP && ip != nil {
const AnonymizeClientIPv4Mask = 16
const AnonymizeClientIPv6Mask = 112
if ip.To4() != nil {
return ip.Mask(net.CIDRMask(AnonymizeClientIPv4Mask, 32)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/dnsforward/util.go |
list map[string]*Client // name -> client
idIndex map[string]*Client // IP -> client
// TODO(e.burkov): Think of a way to not require string conversion for
// IP addresses.
ipHost map[string]*ClientHost // IP -> Hostname
lock sync.Mutex | <mask> WhoisInfo [][]string // [[key,value], ...]
<mask> }
<mask>
<mask> type clientsContainer struct {
<mask> list map[string]*Client // name -> client
<mask> idIndex map[string]*Client // IP -> client
<mask> ipHost map[string]*ClientHost // IP -> Hostname
<mask> lock sync.Mutex
<mask>
<mask> allTags map[string]bool
<mask>
<mask> // dhcpServer is used for looking up clients IP addresses by MAC addresses
<mask> dhcpServer *dhcpd.Server
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ipChan chan string
</s> add ipChan chan net.IP </s> remove clients.ipHost[ip] = ch
</s> add clients.ipHost[ipStr] = ch </s> remove ipChannel chan string // pass data from DNS request handling thread to rDNS thread
</s> add ipChannel chan net.IP // pass data from DNS request handling thread to rDNS thread </s> remove IP string `json:"ip"`
</s> add IP net.IP `json:"ip"` </s> remove IP string `json:"ip"`
</s> add IP net.IP `json:"ip"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
func (clients *clientsContainer) Exists(ip net.IP, source clientSource) bool { | <mask> clients.addFromHostsFile()
<mask> }
<mask>
<mask> // Exists checks if client with this IP already exists
<mask> func (clients *clientsContainer) Exists(ip string, source clientSource) bool {
<mask> clients.lock.Lock()
<mask> defer clients.lock.Unlock()
<mask>
<mask> _, ok := clients.findByIP(ip)
<mask> if ok {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (clients *clientsContainer) SetWhoisInfo(ip string, info [][]string) {
</s> add func (clients *clientsContainer) SetWhoisInfo(ip net.IP, info [][]string) { </s> remove func (clients *clientsContainer) Find(ip string) (Client, bool) {
</s> add func (clients *clientsContainer) Find(ip net.IP) (Client, bool) { </s> remove c, ok := clients.findByIP(ip)
</s> add c, ok := clients.findByIP(net.ParseIP(ip)) </s> remove ch, ok := clients.ipHost[ip]
</s> add ch, ok := clients.ipHost[ip.String()] </s> remove func (clients *clientsContainer) FindAutoClient(ip string) (ClientHost, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) FindAutoClient(ip net.IP) (ClientHost, bool) {
if ip == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
ch, ok := clients.ipHost[ip.String()] | <mask> if ok {
<mask> return true
<mask> }
<mask>
<mask> ch, ok := clients.ipHost[ip]
<mask> if !ok {
<mask> return false
<mask> }
<mask> if source > ch.Source {
<mask> return false // we're going to overwrite this client's info with a stronger source
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove ch, ok := clients.ipHost[ip]
</s> add ch, ok := clients.ipHost[ip.String()] </s> remove ch, ok := clients.ipHost[ip]
</s> add ipStr := ip.String()
ch, ok := clients.ipHost[ipStr] </s> remove c, ok := clients.idIndex[ip]
</s> add c, ok := clients.idIndex[ip.String()] </s> remove func (clients *clientsContainer) Exists(ip string, source clientSource) bool {
</s> add func (clients *clientsContainer) Exists(ip net.IP, source clientSource) bool { </s> remove func (clients *clientsContainer) SetWhoisInfo(ip string, info [][]string) {
</s> add func (clients *clientsContainer) SetWhoisInfo(ip net.IP, info [][]string) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
func (clients *clientsContainer) Find(ip net.IP) (Client, bool) { | <mask> return a2
<mask> }
<mask>
<mask> // Find searches for a client by IP
<mask> func (clients *clientsContainer) Find(ip string) (Client, bool) {
<mask> clients.lock.Lock()
<mask> defer clients.lock.Unlock()
<mask>
<mask> c, ok := clients.findByIP(ip)
<mask> if !ok {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (clients *clientsContainer) findByIP(ip string) (Client, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) findByIP(ip net.IP) (Client, bool) {
if ip == nil { </s> remove c, ok := clients.findByIP(ip)
</s> add c, ok := clients.findByIP(net.ParseIP(ip)) </s> remove func (clients *clientsContainer) SetWhoisInfo(ip string, info [][]string) {
</s> add func (clients *clientsContainer) SetWhoisInfo(ip net.IP, info [][]string) { </s> remove func (clients *clientsContainer) FindAutoClient(ip string) (ClientHost, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) FindAutoClient(ip net.IP) (ClientHost, bool) {
if ip == nil { </s> remove func (clients *clientsContainer) Exists(ip string, source clientSource) bool {
</s> add func (clients *clientsContainer) Exists(ip net.IP, source clientSource) bool { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
c, ok := clients.findByIP(net.ParseIP(ip)) | <mask> func (clients *clientsContainer) FindUpstreams(ip string) *proxy.UpstreamConfig {
<mask> clients.lock.Lock()
<mask> defer clients.lock.Unlock()
<mask>
<mask> c, ok := clients.findByIP(ip)
<mask> if !ok {
<mask> return nil
<mask> }
<mask>
<mask> if len(c.Upstreams) == 0 {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (clients *clientsContainer) Find(ip string) (Client, bool) {
</s> add func (clients *clientsContainer) Find(ip net.IP) (Client, bool) { </s> remove func (clients *clientsContainer) SetWhoisInfo(ip string, info [][]string) {
</s> add func (clients *clientsContainer) SetWhoisInfo(ip net.IP, info [][]string) { </s> remove func (clients *clientsContainer) Exists(ip string, source clientSource) bool {
</s> add func (clients *clientsContainer) Exists(ip net.IP, source clientSource) bool { </s> remove func (clients *clientsContainer) FindAutoClient(ip string) (ClientHost, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) FindAutoClient(ip net.IP) (ClientHost, bool) {
if ip == nil { </s> remove func (clients *clientsContainer) findByIP(ip string) (Client, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) findByIP(ip net.IP) (Client, bool) {
if ip == nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
func (clients *clientsContainer) findByIP(ip net.IP) (Client, bool) {
if ip == nil { | <mask> return c.upstreamConfig
<mask> }
<mask>
<mask> // Find searches for a client by IP (and does not lock anything)
<mask> func (clients *clientsContainer) findByIP(ip string) (Client, bool) {
<mask> ipAddr := net.ParseIP(ip)
<mask> if ipAddr == nil {
<mask> return Client{}, false
<mask> }
<mask>
<mask> c, ok := clients.idIndex[ip]
<mask> if ok {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove func (clients *clientsContainer) Find(ip string) (Client, bool) {
</s> add func (clients *clientsContainer) Find(ip net.IP) (Client, bool) { </s> remove func (clients *clientsContainer) FindAutoClient(ip string) (ClientHost, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) FindAutoClient(ip net.IP) (ClientHost, bool) {
if ip == nil { </s> remove c, ok := clients.idIndex[ip]
</s> add c, ok := clients.idIndex[ip.String()] </s> remove c, ok := clients.findByIP(ip)
</s> add c, ok := clients.findByIP(net.ParseIP(ip)) </s> remove func (clients *clientsContainer) SetWhoisInfo(ip string, info [][]string) {
</s> add func (clients *clientsContainer) SetWhoisInfo(ip net.IP, info [][]string) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
c, ok := clients.idIndex[ip.String()] | <mask> if ipAddr == nil {
<mask> return Client{}, false
<mask> }
<mask>
<mask> c, ok := clients.idIndex[ip]
<mask> if ok {
<mask> return *c, true
<mask> }
<mask>
<mask> for _, c = range clients.list {
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove macFound := clients.dhcpServer.FindMACbyIP(ipAddr)
</s> add macFound := clients.dhcpServer.FindMACbyIP(ip) </s> remove func (clients *clientsContainer) findByIP(ip string) (Client, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) findByIP(ip net.IP) (Client, bool) {
if ip == nil { </s> remove return true, ip
</s> add return true, ipStr </s> remove func (clients *clientsContainer) FindAutoClient(ip string) (ClientHost, bool) {
ipAddr := net.ParseIP(ip)
if ipAddr == nil {
</s> add func (clients *clientsContainer) FindAutoClient(ip net.IP) (ClientHost, bool) {
if ip == nil { </s> remove ch, ok := clients.ipHost[ip]
</s> add ch, ok := clients.ipHost[ip.String()] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
if ipnet.Contains(ip) { | <mask> _, ipnet, err := net.ParseCIDR(id)
<mask> if err != nil {
<mask> continue
<mask> }
<mask> if ipnet.Contains(ipAddr) {
<mask> return *c, true
<mask> }
<mask> }
<mask> }
<mask>
</s> Pull request: 2508 ip conversion vol.2
Merge in DNS/adguard-home from 2508-ip-conversion-vol2 to master
Closes #2508.
Squashed commit of the following:
commit 5b9d33f9cd352756831f63e34c4aea48674628c1
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:15:17 2021 +0300
util: replace net.IPNet with pointer
commit 680126de7d59464077f9edf1bbaa925dd3fcee19
Merge: d3ba6a6c 5a50efad
Author: Eugene Burkov <[email protected]>
Date: Wed Jan 20 17:02:41 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit d3ba6a6cdd01c0aa736418fdb86ed40120169fe9
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 18:29:54 2021 +0300
all: remove last conversion
commit 88b63f11a6c3f8705d7fa0c448c50dd646cc9214
Author: Eugene Burkov <[email protected]>
Date: Tue Jan 19 14:12:45 2021 +0300
all: improve code quality
commit 71af60c70a0dbaf55e2221023d6d2e4993c9e9a7
Merge: 98af3784 9f75725d
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 17:13:27 2021 +0300
Merge branch 'master' into 2508-ip-conversion-vol2
commit 98af3784ce44d0993d171653c13d6e83bb8d1e6a
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:32:53 2021 +0300
all: log changes
commit e99595a172bae1e844019d344544be84ddd65e4e
Author: Eugene Burkov <[email protected]>
Date: Mon Jan 18 16:06:49 2021 +0300
all: fix or remove remaining net.IP <-> string conversions
commit 7fd0634ce945f7e4c9b856684c5199f8a84a543e
Author: Eugene Burkov <[email protected]>
Date: Fri Jan 15 15:36:17 2021 +0300
all: remove redundant net.IP <-> string converions
commit 5df8af030421237d41b67ed659f83526cc258199
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:35:25 2021 +0300
stats: remove redundant net.IP <-> string conversion
commit fbe4e3fc015e6898063543a90c04401d76dbb18f
Author: Eugene Burkov <[email protected]>
Date: Thu Jan 14 16:20:35 2021 +0300
querylog: remove redundant net.IP <-> string conversion </s> remove c, ok := clients.idIndex[ip]
</s> add c, ok := clients.idIndex[ip.String()] </s> remove ip4, _, err := net.ParseCIDR(ip)
if err != nil {
return err
}
</s> add </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove if ipnet.Contains(ipAddr) {
</s> add if ipnet.Contains(ip) { </s> remove ipAddr := net.ParseIP(ip)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/7fab31beaeb8c7d1c9892746bbf37e99d4f9dc01 | internal/home/clients.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.