package resolver import ( "bufio" "errors" "fmt" log "github.com/sirupsen/logrus" "meow.tf/joker/godns/utils" "net" "os" "strconv" "strings" "sync" "time" "crypto/tls" "github.com/miekg/dns" ) type ResolvError struct { qname, net string nameservers []*Nameserver } func (e ResolvError) Error() string { nameservers := make([]string, len(e.nameservers)) for i, nameserver := range e.nameservers { nameservers[i] = nameserver.address } return fmt.Sprintf("%s resolv failed on %s (%s)", e.qname, strings.Join(nameservers, "; "), e.net) } type RResp struct { msg *dns.Msg nameserver *Nameserver rtt time.Duration } type Resolver struct { servers []*Nameserver domainServer *suffixTreeNode config *Settings clients map[string]*dns.Client clientLock sync.RWMutex } func NewResolver(c Settings) *Resolver { r := &Resolver{ servers: make([]*Nameserver, 0), domainServer: newSuffixTreeRoot(), config: &c, } if len(c.ServerListFile) > 0 { r.ReadServerListFile(c.ServerListFile) } if len(c.ResolvFile) > 0 { clientConfig, err := dns.ClientConfigFromFile(c.ResolvFile) if err != nil { log.Error(":%s is not a valid resolv.conf file\n", c.ResolvFile) log.Error("%s", err) panic(err) } for _, server := range clientConfig.Servers { r.servers = append(r.servers, &Nameserver{net: "udp", address: net.JoinHostPort(server, clientConfig.Port)}) } } return r } func (r *Resolver) parseServerListFile(buf *os.File) { scanner := bufio.NewScanner(buf) var line string var idx int for scanner.Scan() { line = strings.TrimSpace(scanner.Text()) if !strings.HasPrefix(line, "server") { continue } idx = strings.Index(line, "=") if idx == -1 { continue } line = strings.TrimSpace(line[idx+1:]) if strings.HasPrefix(line, "https://") { r.servers = append(r.servers, &Nameserver{net: "https", address: line}) continue } tokens := strings.Split(line, "/") switch len(tokens) { case 3: domain := tokens[1] ip := tokens[2] if !utils.IsDomain(domain) || !utils.IsIP(ip) { continue } r.domainServer.sinsert(strings.Split(domain, "."), ip) case 1: srvPort := strings.Split(line, "#") if len(srvPort) > 2 { continue } ip := "" if ip = srvPort[0]; !utils.IsIP(ip) { continue } port := "53" if len(srvPort) == 2 { if _, err := strconv.Atoi(srvPort[1]); err != nil { continue } port = srvPort[1] } r.servers = append(r.servers, &Nameserver{address: net.JoinHostPort(ip, port)}) } } } func (r *Resolver) ReadServerListFile(files []string) { for _, file := range files { buf, err := os.Open(file) if err != nil { panic("Can't open " + file) } r.parseServerListFile(buf) buf.Close() } } // 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) { if net == "udp" && r.config.SetEDNS0 { req = req.SetEdns0(65535, true) } qname := req.Question[0].Name res := make(chan *RResp, 1) var wg sync.WaitGroup L := func(resolver *Resolver, nameserver *Nameserver) { defer wg.Done() c, err := resolver.resolverFor(net, nameserver) if err != nil { log.Warn("error:%s", err.Error()) return } r, rtt, err := c.Exchange(req, nameserver.address) if err != nil { log.Warn("%s socket error on %s", qname, nameserver) log.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 { log.Warn("%s failed to get an valid answer on %s", qname, nameserver) if r.Rcode == dns.RcodeServerFailure { return } } re := &RResp{r, nameserver, rtt} select { case res <- re: default: } } ticker := time.NewTicker(time.Duration(r.config.Interval) * time.Millisecond) defer ticker.Stop() // Start lookup on each nameserver top-down, in every second nameservers := r.Nameservers(qname) for _, nameserver := range nameservers { wg.Add(1) go L(r, nameserver) // but exit early, if we have an answer select { case re := <-res: log.Debug("%s resolv on %s rtt: %v", utils.UnFqdn(qname), re.nameserver, re.rtt) return re.msg, nil case <-ticker.C: continue } } // wait for all the namservers to finish wg.Wait() select { case re := <-res: log.Debug("%s resolv on %s rtt: %v", utils.UnFqdn(qname), re.nameserver.address, re.rtt) return re.msg, nil default: return nil, ResolvError{qname, net, nameservers} } } func (r *Resolver) resolverFor(network string, n *Nameserver) (*dns.Client, error) { key := network // Use HTTPS if network is https, or TLS to force secure connections if n.net == "https" { key = n.net } else if n.net == "tcp-tls" { key = n.net + ":" + n.address } r.clientLock.RLock() client, exists := r.clients[key] r.clientLock.RUnlock() if exists { return client, nil } if n.net != "tcp" && n.net != "tcp-tls" && n.net != "https" && n.net != "udp" { return nil, errors.New("unknown network type") } timeout := r.Timeout() client = &dns.Client{ Net: n.net, ReadTimeout: timeout, WriteTimeout: timeout, } if n.net == "tcp-tls" { host, _, err := net.SplitHostPort(n.address) if err != nil { host = n.address } client.TLSConfig = &tls.Config{ ServerName: host, } } r.clientLock.Lock() r.clients[key] = client r.clientLock.Lock() return client, nil } // Nameservers return the array of nameservers, with port number appended. // '#' in the name is treated as port separator, as with dnsmasq. func (r *Resolver) Nameservers(qname string) []*Nameserver { queryKeys := strings.Split(qname, ".") queryKeys = queryKeys[:len(queryKeys)-1] // ignore last '.' if v, found := r.domainServer.search(queryKeys); found { log.Debug("%s found in domain server list, upstream: %v", qname, v) //Ensure query the specific upstream nameserver in async Lookup() function. return []*Nameserver{ {net: "udp", address: net.JoinHostPort(v, "53")}, } } return r.servers } func (r *Resolver) Timeout() time.Duration { return time.Duration(r.config.Timeout) * time.Second }