108 lines
2.7 KiB
Go
108 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/miekg/dns"
|
|
)
|
|
|
|
type ResolvError struct {
|
|
qname, net string
|
|
nameservers []string
|
|
}
|
|
|
|
func (e ResolvError) Error() string {
|
|
errmsg := fmt.Sprintf("%s resolv failed on %s (%s)", e.qname, strings.Join(e.nameservers, "; "), e.net)
|
|
return errmsg
|
|
}
|
|
|
|
type Resolver struct {
|
|
config *dns.ClientConfig
|
|
}
|
|
|
|
// Lookup will ask each nameserver in top-to-bottom fashion, starting a new request
|
|
// in every second, and return as early as possbile (have an answer).
|
|
// It returns an error if no request has succeeded.
|
|
func (r *Resolver) Lookup(net string, req *dns.Msg) (message *dns.Msg, err error) {
|
|
c := &dns.Client{
|
|
Net: net,
|
|
ReadTimeout: r.Timeout(),
|
|
WriteTimeout: r.Timeout(),
|
|
}
|
|
|
|
qname := req.Question[0].Name
|
|
|
|
res := make(chan *dns.Msg, 1)
|
|
var wg sync.WaitGroup
|
|
L := func(nameserver string) {
|
|
defer wg.Done()
|
|
r, rtt, err := c.Exchange(req, nameserver)
|
|
if err != nil {
|
|
logger.Warn("%s socket error on %s", qname, nameserver)
|
|
logger.Warn("error:%s", err.Error())
|
|
return
|
|
}
|
|
// If SERVFAIL happen, should return immediately and try another upstream resolver.
|
|
// However, other Error code like NXDOMAIN is an clear response stating
|
|
// that it has been verified no such domain existas and ask other resolvers
|
|
// would make no sense. See more about #20
|
|
if r != nil && r.Rcode != dns.RcodeSuccess {
|
|
logger.Warn("%s failed to get an valid answer on %s", qname, nameserver)
|
|
if r.Rcode == dns.RcodeServerFailure {
|
|
return
|
|
}
|
|
} else {
|
|
logger.Debug("%s resolv on %s (%s) ttl: %d", UnFqdn(qname), nameserver, net, rtt)
|
|
}
|
|
select {
|
|
case res <- r:
|
|
default:
|
|
}
|
|
}
|
|
|
|
ticker := time.NewTicker(time.Duration(settings.ResolvConfig.Interval) * time.Millisecond)
|
|
defer ticker.Stop()
|
|
// Start lookup on each nameserver top-down, in every second
|
|
for _, nameserver := range r.Nameservers() {
|
|
wg.Add(1)
|
|
go L(nameserver)
|
|
// but exit early, if we have an answer
|
|
select {
|
|
case r := <-res:
|
|
return r, nil
|
|
case <-ticker.C:
|
|
continue
|
|
}
|
|
}
|
|
// wait for all the namservers to finish
|
|
wg.Wait()
|
|
select {
|
|
case r := <-res:
|
|
return r, nil
|
|
default:
|
|
return nil, ResolvError{qname, net, r.Nameservers()}
|
|
}
|
|
|
|
}
|
|
|
|
// Namservers return the array of nameservers, with port number appended.
|
|
// '#' in the name is treated as port separator, as with dnsmasq.
|
|
func (r *Resolver) Nameservers() (ns []string) {
|
|
for _, server := range r.config.Servers {
|
|
if i := strings.IndexByte(server, '#'); i > 0 {
|
|
server = server[:i] + ":" + server[i+1:]
|
|
} else {
|
|
server = server + ":" + r.config.Port
|
|
}
|
|
ns = append(ns, server)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (r *Resolver) Timeout() time.Duration {
|
|
return time.Duration(r.config.Timeout) * time.Second
|
|
}
|