136 lines
3.3 KiB
Go
136 lines
3.3 KiB
Go
package home
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"net"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/dnsforward"
|
|
"github.com/AdguardTeam/golibs/cache"
|
|
"github.com/AdguardTeam/golibs/log"
|
|
)
|
|
|
|
// RDNS resolves clients' addresses to enrich their metadata.
|
|
type RDNS struct {
|
|
exchanger dnsforward.RDNSExchanger
|
|
clients *clientsContainer
|
|
|
|
// usePrivate is used to store the state of current private RDNS resolving
|
|
// settings and to react to it's changes.
|
|
usePrivate uint32
|
|
|
|
// ipCh used to pass client's IP to rDNS workerLoop.
|
|
ipCh chan net.IP
|
|
|
|
// ipCache caches the IP addresses to be resolved by rDNS. The resolved
|
|
// address stays here while it's inside clients. After leaving clients the
|
|
// address will be resolved once again. If the address couldn't be
|
|
// resolved, cache prevents further attempts to resolve it for some time.
|
|
ipCache cache.Cache
|
|
}
|
|
|
|
// Default rDNS values.
|
|
const (
|
|
defaultRDNSCacheSize = 10000
|
|
defaultRDNSCacheTTL = 1 * 60 * 60
|
|
defaultRDNSIPChSize = 256
|
|
)
|
|
|
|
// NewRDNS creates and returns initialized RDNS.
|
|
func NewRDNS(
|
|
exchanger dnsforward.RDNSExchanger,
|
|
clients *clientsContainer,
|
|
usePrivate bool,
|
|
) (rDNS *RDNS) {
|
|
rDNS = &RDNS{
|
|
exchanger: exchanger,
|
|
clients: clients,
|
|
ipCache: cache.New(cache.Config{
|
|
EnableLRU: true,
|
|
MaxCount: defaultRDNSCacheSize,
|
|
}),
|
|
ipCh: make(chan net.IP, defaultRDNSIPChSize),
|
|
}
|
|
if usePrivate {
|
|
rDNS.usePrivate = 1
|
|
}
|
|
|
|
go rDNS.workerLoop()
|
|
|
|
return rDNS
|
|
}
|
|
|
|
// ensurePrivateCache ensures that the state of the RDNS cache is consistent
|
|
// with the current private client RDNS resolving settings.
|
|
//
|
|
// TODO(e.burkov): Clearing cache each time this value changed is not a perfect
|
|
// approach since only unresolved locally-served addresses should be removed.
|
|
// Implement when improving the cache.
|
|
func (r *RDNS) ensurePrivateCache() {
|
|
var usePrivate uint32
|
|
if r.exchanger.ResolvesPrivatePTR() {
|
|
usePrivate = 1
|
|
}
|
|
|
|
if atomic.CompareAndSwapUint32(&r.usePrivate, 1-usePrivate, usePrivate) {
|
|
r.ipCache.Clear()
|
|
}
|
|
}
|
|
|
|
// isCached returns true if ip is already cached and not expired yet. It also
|
|
// caches it otherwise.
|
|
func (r *RDNS) isCached(ip net.IP) (ok bool) {
|
|
now := uint64(time.Now().Unix())
|
|
if expire := r.ipCache.Get(ip); len(expire) != 0 {
|
|
if binary.BigEndian.Uint64(expire) > now {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// The cache entry either expired or doesn't exist.
|
|
ttl := make([]byte, 8)
|
|
binary.BigEndian.PutUint64(ttl, now+defaultRDNSCacheTTL)
|
|
r.ipCache.Set(ip, ttl)
|
|
|
|
return false
|
|
}
|
|
|
|
// Begin adds the ip to the resolving queue if it is not cached or already
|
|
// resolved.
|
|
func (r *RDNS) Begin(ip net.IP) {
|
|
r.ensurePrivateCache()
|
|
|
|
if r.isCached(ip) || r.clients.Exists(ip, ClientSourceRDNS) {
|
|
return
|
|
}
|
|
|
|
select {
|
|
case r.ipCh <- ip:
|
|
log.Tracef("rdns: %q added to queue", ip)
|
|
default:
|
|
log.Tracef("rdns: queue is full")
|
|
}
|
|
}
|
|
|
|
// workerLoop handles incoming IP addresses from ipChan and adds it into
|
|
// clients.
|
|
func (r *RDNS) workerLoop() {
|
|
defer log.OnPanic("rdns")
|
|
|
|
for ip := range r.ipCh {
|
|
host, err := r.exchanger.Exchange(ip)
|
|
if err != nil {
|
|
log.Debug("rdns: resolving %q: %s", ip, err)
|
|
|
|
continue
|
|
} else if host == "" {
|
|
continue
|
|
}
|
|
|
|
// Don't handle any errors since AddHost doesn't return non-nil errors
|
|
// for now.
|
|
_, _ = r.clients.AddHost(ip, host, ClientSourceRDNS)
|
|
}
|
|
}
|