feat: ndots and search list support

pkg/resolvers/classic.go

@@ -1,7 +1,6 @@
 package resolvers
 
 import (
-	"fmt"
 	"net"
 
 	"github.com/miekg/dns"
@@ -47,6 +46,7 @@ func NewClassicResolver(servers []string, opts ClassicResolverOpts) (Resolver, e
 			nameservers = append(nameservers, srv)
 		}
 	}
+
 	client.Net = "udp"
 	if opts.UseIPv4 {
 		client.Net = "udp4"
@@ -66,35 +66,6 @@ func NewClassicResolver(servers []string, opts ClassicResolverOpts) (Resolver, e
 	}, nil
 }
 
-// NewResolverFromResolvFile loads the configuration from resolv config file
-// and initialises a DNS resolver.
-func NewResolverFromResolvFile(resolvFilePath string) (Resolver, error) {
-	if resolvFilePath == "" {
-		resolvFilePath = DefaultResolvConfPath
-	}
-	cfg, err := dns.ClientConfigFromFile(resolvFilePath)
-	if err != nil {
-		return nil, err
-	}
-
-	servers := make([]string, 0, len(cfg.Servers))
-	for _, s := range cfg.Servers {
-		ip := net.ParseIP(s)
-		// handle IPv6
-		if ip != nil && ip.To4() != nil {
-			servers = append(servers, fmt.Sprintf("%s:%s", s, cfg.Port))
-		} else {
-			servers = append(servers, fmt.Sprintf("[%s]:%s", s, cfg.Port))
-		}
-	}
-
-	client := &dns.Client{}
-	return &ClassicResolver{
-		client:  client,
-		servers: servers,
-	}, nil
-}
-
 // Lookup prepare a list of DNS messages to be sent to the server.
 // It's possible to send multiple question in one message
 // but some nameservers are not able to

pkg/resolvers/doh.go

@@ -26,7 +26,7 @@ func NewDOHResolver(servers []string) (Resolver, error) {
 	}, nil
 }
 
-func (r *DOHResolver) Lookup(questions []dns.Question) ([]Response, error) {
+func (d *DOHResolver) Lookup(questions []dns.Question) ([]Response, error) {
 	var (
 		messages  = prepareMessages(questions)
 		responses []Response
@@ -38,10 +38,10 @@ func (r *DOHResolver) Lookup(questions []dns.Question) ([]Response, error) {
 		if err != nil {
 			return nil, err
 		}
-		for _, srv := range r.servers {
+		for _, srv := range d.servers {
 			now := time.Now()
 			// Make an HTTP POST request to the DNS server with the DNS message as wire format bytes in the body.
-			resp, err := r.client.Post(srv, "application/dns-message", bytes.NewBuffer(b))
+			resp, err := d.client.Post(srv, "application/dns-message", bytes.NewBuffer(b))
 			if err != nil {
 				return nil, err
 			}

pkg/resolvers/system.go

@@ -0,0 +1,84 @@
+package resolvers
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/miekg/dns"
+)
+
+// SystemResolver represents the config options based on the
+// resolvconf file.
+type SystemResolver struct {
+	client  *dns.Client
+	config  *dns.ClientConfig
+	servers []string
+}
+
+// NewSystemResolver loads the configuration from resolv config file
+// and initialises a DNS resolver.
+func NewSystemResolver(resolvFilePath string) (Resolver, error) {
+	if resolvFilePath == "" {
+		resolvFilePath = DefaultResolvConfPath
+	}
+	cfg, err := dns.ClientConfigFromFile(resolvFilePath)
+	if err != nil {
+		return nil, err
+	}
+
+	servers := make([]string, 0, len(cfg.Servers))
+	for _, s := range cfg.Servers {
+		ip := net.ParseIP(s)
+		// handle IPv6
+		if ip != nil && ip.To4() != nil {
+			servers = append(servers, fmt.Sprintf("%s:%s", s, cfg.Port))
+		} else {
+			servers = append(servers, fmt.Sprintf("[%s]:%s", s, cfg.Port))
+		}
+	}
+
+	client := &dns.Client{}
+	return &SystemResolver{
+		client:  client,
+		servers: servers,
+		config:  cfg,
+	}, nil
+}
+
+// Lookup prepare a list of DNS messages to be sent to the server.
+// It's possible to send multiple question in one message
+// but some nameservers are not able to
+func (s *SystemResolver) Lookup(questions []dns.Question) ([]Response, error) {
+	for _, q := range questions {
+		domains := s.config.NameList(q.Name)
+		for _, d := range domains {
+			ques := dns.Question{
+				Name:   d,
+				Qtype:  q.Qtype,
+				Qclass: q.Qclass,
+			}
+			questions = append(questions, ques)
+		}
+	}
+	var (
+		messages  = prepareMessages(questions)
+		responses []Response
+	)
+
+	for _, msg := range messages {
+		for _, srv := range s.servers {
+			in, rtt, err := s.client.Exchange(&msg, srv)
+			if err != nil {
+				return nil, err
+			}
+			msg.Answer = in.Answer
+			rsp := Response{
+				Message:    msg,
+				RTT:        rtt,
+				Nameserver: srv,
+			}
+			responses = append(responses, rsp)
+		}
+	}
+	return responses, nil
+}