feat: Add support for multiple resolvers

TODO.md

@@ -11,6 +11,9 @@
 - [x] Add DOT support
 - [x] Add DNS protocol on TCP mode support.
 - [x] Major records supported
+- [x] Support multiple resolvers
+  - [x] Take multiple transport options and initialise resolvers accordingly. 
+- [ ] Add timeout support
 
 ## CLI Features
 - [x] `ndots` support
@@ -37,7 +40,9 @@
 
 - [ ] Don't abuse Hub as global. Refactor methods to be independent of hub.
 - [ ] Add meaningful comments where required.
-
+- [ ] Meaningful error messages
+- [ ] Better debug logs
+- [ ] 
 ## Tests
 - [ ] Add tests for Command Line Usage. 
 
@@ -55,9 +60,15 @@
   - [ ] Homebrew
   - [ ] ARM
   - [ ] Docker
+
+---
 ## Future Release
 
 - [ ] Support obscure protocal tweaks in `dig`
 - [ ] `digfile`
 - [ ] Support more DNS Record Types
 - [ ] Error on NXDomain (Realted upstream [bug](https://github.com/miekg/dns/issues/1198))
+- [ ] Shell completions
+  - [ ] bash
+  - [ ] zsh
+  - [ ] fish

cmd/cli.go

@@ -41,6 +41,7 @@ func main() {
 	f.BoolP("dot", "S", false, "Use the DNS-over-TLS")
 
 	// Resolver Options
+	f.Int("timeout", 5, "Sets the timeout for a query to T seconds. The default timeout is 5 seconds.")
 	f.Bool("search", false, "Use the search list provided in resolv.conf. It sets the `ndots` parameter as well unless overriden by `ndots` flag.")
 	f.Int("ndots", 1, "Specify the ndots paramter. Default value is taken from resolv.conf and fallbacks to 1 if ndots statement is missing in resolv.conf")
 
@@ -72,12 +73,19 @@ func main() {
 	hub.Logger.Debug("Starting doggo 🐶")
 
 	// Parse Query Args
-	hub.loadQueryArgs()
+	err := hub.loadQueryArgs()
-
+	if err != nil {
+		hub.Logger.WithError(err).Error("error parsing flags/arguments")
+		hub.Logger.Exit(2)
+	}
 	// Start App
 	if len(hub.QueryFlags.QNames) == 0 {
 		f.Usage()
+		hub.Logger.Exit(0)
+	}
+	err = hub.Lookup()
+	if err != nil {
+		hub.Logger.WithError(err).Error("error looking up DNS records")
+		hub.Logger.Exit(2)
 	}
-	hub.Lookup()
-
 }

cmd/hub.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"time"
+
 	"github.com/miekg/dns"
 	"github.com/mr-karan/doggo/pkg/resolvers"
 	"github.com/sirupsen/logrus"
@@ -13,26 +15,27 @@ type Hub struct {
 	QueryFlags QueryFlags
 	FreeArgs   []string
 	Questions  []dns.Question
-	Resolver   resolvers.Resolver
+	Resolver   []resolvers.Resolver
 }
 
 // QueryFlags is used store the value of CLI flags.
 type QueryFlags struct {
-	QNames           []string `koanf:"query"`
+	QNames           []string      `koanf:"query"`
-	QTypes           []string `koanf:"type"`
+	QTypes           []string      `koanf:"type"`
-	QClasses         []string `koanf:"class"`
+	QClasses         []string      `koanf:"class"`
-	Nameservers      []string `koanf:"nameserver"`
+	Nameservers      []string      `koanf:"nameserver"`
-	IsDOH            bool     `koanf:"doh"`
+	IsDOH            bool          `koanf:"doh"`
-	IsDOT            bool     `koanf:"dot"`
+	IsDOT            bool          `koanf:"dot"`
-	IsUDP            bool     `koanf:"udp"`
+	IsUDP            bool          `koanf:"udp"`
-	UseTCP           bool     `koanf:"tcp"`
+	IsTCP            bool          `koanf:"tcp"`
-	UseIPv4          bool     `koanf:"ipv4"`
+	UseIPv4          bool          `koanf:"ipv4"`
-	UseIPv6          bool     `koanf:"ipv6"`
+	UseIPv6          bool          `koanf:"ipv6"`
-	DisplayTimeTaken bool     `koanf:"time"`
+	DisplayTimeTaken bool          `koanf:"time"`
-	ShowJSON         bool     `koanf:"json"`
+	ShowJSON         bool          `koanf:"json"`
-	UseSearchList    bool     `koanf:"search"`
+	UseSearchList    bool          `koanf:"search"`
-	Ndots            int      `koanf:"ndots"`
+	Ndots            int           `koanf:"ndots"`
-	Color            bool     `koanf:"color"`
+	Color            bool          `koanf:"color"`
+	Timeout          time.Duration `koanf:"timeout"`
 }
 
 // NewHub initializes an instance of Hub which holds app wide configuration.
@@ -55,7 +58,7 @@ func NewHub(logger *logrus.Logger, buildVersion string) *Hub {
 func initLogger() *logrus.Logger {
 	logger := logrus.New()
 	logger.SetFormatter(&logrus.TextFormatter{
-		DisableTimestamp:       true,
+		FullTimestamp:          true,
 		DisableLevelTruncation: true,
 	})
 	return logger

cmd/lookup.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"strings"
 
 	"github.com/miekg/dns"
@@ -14,9 +15,17 @@ func (hub *Hub) Lookup() error {
 	if err != nil {
 		return err
 	}
-	responses, err := hub.Resolver.Lookup(hub.Questions)
+	// for each type of resolver do a DNS lookup
-	if err != nil {
+	responses := make([][]resolvers.Response, 0, len(hub.Questions))
-		return err
+	for _, r := range hub.Resolver {
+		resp, err := r.Lookup(hub.Questions)
+		if err != nil {
+			return err
+		}
+		responses = append(responses, resp)
+	}
+	if len(responses) == 0 {
+		return errors.New(`no DNS records found`)
 	}
 	hub.Output(responses)
 	return nil

cmd/output.go

@@ -37,9 +37,9 @@ type JSONResponse struct {
 	Response `json:"responses"`
 }
 
-func (hub *Hub) outputJSON(out []Output, msgs []resolvers.Response) {
+func (hub *Hub) outputJSON(out []Output) {
 	// get the questions
-	queries := make([]Query, 0, len(msgs))
+	queries := make([]Query, 0)
 	for _, ques := range hub.Questions {
 		q := Query{
 			Name:  ques.Name,
@@ -122,73 +122,77 @@ func (hub *Hub) outputTerminal(out []Output) {
 
 // Output takes a list of `dns.Answers` and based
 // on the output format specified displays the information.
-func (hub *Hub) Output(responses []resolvers.Response) {
+func (hub *Hub) Output(responses [][]resolvers.Response) {
 	out := collectOutput(responses)
 	if len(out) == 0 {
 		hub.Logger.Info("No records found")
 		hub.Logger.Exit(0)
 	}
 	if hub.QueryFlags.ShowJSON {
-		hub.outputJSON(out, responses)
+		hub.outputJSON(out)
 	} else {
 		hub.outputTerminal(out)
 	}
 }
 
-func collectOutput(responses []resolvers.Response) []Output {
+func collectOutput(responses [][]resolvers.Response) []Output {
 	var out []Output
-	// gather Output from the DNS Messages
+	// for each resolver
-	for _, r := range responses {
+	for _, rslvr := range responses {
-		var addr string
+		// get the response
-		for _, a := range r.Message.Answer {
+		for _, r := range rslvr {
-			switch t := a.(type) {
+			var addr string
-			case *dns.A:
+			for _, a := range r.Message.Answer {
-				addr = t.A.String()
+				switch t := a.(type) {
-			case *dns.AAAA:
+				case *dns.A:
-				addr = t.AAAA.String()
+					addr = t.A.String()
-			case *dns.CNAME:
+				case *dns.AAAA:
-				addr = t.Target
+					addr = t.AAAA.String()
-			case *dns.CAA:
+				case *dns.CNAME:
-				addr = t.Tag + " " + t.Value
+					addr = t.Target
-			case *dns.HINFO:
+				case *dns.CAA:
-				addr = t.Cpu + " " + t.Os
+					addr = t.Tag + " " + t.Value
-			// case *dns.LOC:
+				case *dns.HINFO:
-			// 	addr = t.String()
+					addr = t.Cpu + " " + t.Os
-			case *dns.PTR:
+				// case *dns.LOC:
-				addr = t.Ptr
+				// 	addr = t.String()
-			case *dns.SRV:
+				case *dns.PTR:
-				addr = strconv.Itoa(int(t.Priority)) + " " +
+					addr = t.Ptr
-					strconv.Itoa(int(t.Weight)) + " " +
+				case *dns.SRV:
-					t.Target + ":" + strconv.Itoa(int(t.Port))
+					addr = strconv.Itoa(int(t.Priority)) + " " +
-			case *dns.TXT:
+						strconv.Itoa(int(t.Weight)) + " " +
-				addr = t.String()
+						t.Target + ":" + strconv.Itoa(int(t.Port))
-			case *dns.NS:
+				case *dns.TXT:
-				addr = t.Ns
+					addr = t.String()
-			case *dns.MX:
+				case *dns.NS:
-				addr = strconv.Itoa(int(t.Preference)) + " " + t.Mx
+					addr = t.Ns
-			case *dns.SOA:
+				case *dns.MX:
-				addr = t.String()
+					addr = strconv.Itoa(int(t.Preference)) + " " + t.Mx
-			case *dns.NAPTR:
+				case *dns.SOA:
-				addr = t.String()
+					addr = t.String()
-			}
+				case *dns.NAPTR:
+					addr = t.String()
+				}
 
-			h := a.Header()
+				h := a.Header()
-			name := h.Name
+				name := h.Name
-			qclass := dns.Class(h.Class).String()
+				qclass := dns.Class(h.Class).String()
-			ttl := strconv.FormatInt(int64(h.Ttl), 10) + "s"
+				ttl := strconv.FormatInt(int64(h.Ttl), 10) + "s"
-			qtype := dns.Type(h.Rrtype).String()
+				qtype := dns.Type(h.Rrtype).String()
-			rtt := fmt.Sprintf("%dms", r.RTT.Milliseconds())
+				rtt := fmt.Sprintf("%dms", r.RTT.Milliseconds())
-			o := Output{
+				o := Output{
-				Name:       name,
+					Name:       name,
-				Type:       qtype,
+					Type:       qtype,
-				TTL:        ttl,
+					TTL:        ttl,
-				Class:      qclass,
+					Class:      qclass,
-				Address:    addr,
+					Address:    addr,
-				TimeTaken:  rtt,
+					TimeTaken:  rtt,
-				Nameserver: r.Nameserver,
+					Nameserver: r.Nameserver,
+				}
+				out = append(out, o)
 			}
-			out = append(out, o)
 		}
 	}
+
 	return out
 }

cmd/parse.go

@@ -7,22 +7,20 @@ import (
 )
 
 func (hub *Hub) loadQueryArgs() error {
-
 	err := hub.loadNamedArgs()
-
+	if err != nil {
+		return err
+	}
 	err = hub.loadFreeArgs()
 	if err != nil {
-		hub.Logger.WithError(err).Error("Error parsing arguments")
+		return err
-		hub.Logger.Exit(2)
 	}
 	err = hub.initResolver()
 	if err != nil {
-		hub.Logger.WithError(err).Error("Error parsing nameservers")
+		return err
-		hub.Logger.Exit(2)
 	}
-
 	hub.loadFallbacks()
-	return err
+	return nil
 }
 
 // loadFreeArgs tries to parse all the arguments

cmd/resolver.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"runtime"
+	"time"
 
 	"github.com/mr-karan/doggo/pkg/resolvers"
 )
@@ -11,36 +11,39 @@ import (
 func (hub *Hub) initResolver() error {
 	// check if DOH flag is set.
 	if hub.QueryFlags.IsDOH {
-		rslvr, err := resolvers.NewDOHResolver(hub.QueryFlags.Nameservers)
+		hub.Logger.Debug("initiating DOH resolver")
-		if err != nil {
+		rslvr, err := resolvers.NewDOHResolver(hub.QueryFlags.Nameservers, resolvers.DOHResolverOpts{
-			return err
+			Timeout: hub.QueryFlags.Timeout * time.Second,
-		}
-		hub.Resolver = rslvr
-		return nil
-	}
-	if len(hub.QueryFlags.Nameservers) == 0 {
-		if runtime.GOOS == "windows" {
-			// TODO: Add a method for reading system default nameserver in windows.
-		} else {
-			rslvr, err := resolvers.NewSystemResolver(resolvers.DefaultResolvConfPath)
-			if err != nil {
-				return err
-			}
-			hub.Resolver = rslvr
-			return nil
-		}
-	} else {
-		rslvr, err := resolvers.NewClassicResolver(hub.QueryFlags.Nameservers, resolvers.ClassicResolverOpts{
-			UseIPv4: hub.QueryFlags.UseIPv4,
-			UseIPv6: hub.QueryFlags.UseIPv6,
-			UseTLS:  hub.QueryFlags.IsDOT,
-			UseTCP:  hub.QueryFlags.UseTCP,
 		})
 		if err != nil {
 			return err
 		}
-		hub.Resolver = rslvr
+		hub.Resolver = append(hub.Resolver, rslvr)
-		return nil
+	}
+	if hub.QueryFlags.IsTCP {
+		hub.Logger.Debug("initiating TCP resolver")
+		rslvr, err := resolvers.NewTCPResolver(hub.QueryFlags.Nameservers, resolvers.TCPResolverOpts{
+			IPv4Only: hub.QueryFlags.UseIPv4,
+			IPv6Only: hub.QueryFlags.UseIPv6,
+			Timeout:  hub.QueryFlags.Timeout * time.Second,
+		})
+		if err != nil {
+			return err
+		}
+		hub.Resolver = append(hub.Resolver, rslvr)
+	}
+	// If so far no resolver has been set, then fallback to UDP.
+	if hub.QueryFlags.IsUDP || len(hub.Resolver) == 0 {
+		hub.Logger.Debug("initiating UDP resolver")
+		rslvr, err := resolvers.NewUDPResolver(hub.QueryFlags.Nameservers, resolvers.UDPResolverOpts{
+			IPv4Only: hub.QueryFlags.UseIPv4,
+			IPv6Only: hub.QueryFlags.UseIPv6,
+			Timeout:  hub.QueryFlags.Timeout * time.Second,
+		})
+		if err != nil {
+			return err
+		}
+		hub.Resolver = append(hub.Resolver, rslvr)
 	}
 	return nil
 }

pkg/resolvers/doh.go

@@ -2,8 +2,11 @@ package resolvers
 
 import (
 	"bytes"
+	"errors"
+	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 	"time"
 
 	"github.com/miekg/dns"
@@ -15,10 +18,26 @@ type DOHResolver struct {
 	servers []string
 }
 
+type DOHResolverOpts struct {
+	Timeout time.Duration
+}
+
 // NewDOHResolver accepts a list of nameservers and configures a DOH based resolver.
-func NewDOHResolver(servers []string) (Resolver, error) {
+func NewDOHResolver(servers []string, opts DOHResolverOpts) (Resolver, error) {
+	if len(servers) == 0 {
+		return nil, errors.New(`no DOH server specified`)
+	}
+	for _, s := range servers {
+		u, err := url.ParseRequestURI(s)
+		if err != nil {
+			return nil, fmt.Errorf("%s is not a valid HTTPS nameserver", s)
+		}
+		if u.Scheme != "https" {
+			return nil, fmt.Errorf("missing https in %s", s)
+		}
+	}
 	httpClient := &http.Client{
-		Timeout: 10 * time.Second,
+		Timeout: opts.Timeout,
 	}
 	return &DOHResolver{
 		client:  httpClient,
@@ -46,7 +65,7 @@ func (d *DOHResolver) Lookup(questions []dns.Question) ([]Response, error) {
 				return nil, err
 			}
 			if resp.StatusCode != http.StatusOK {
-				return nil, err
+				return nil, fmt.Errorf("error from nameserver %s", resp.Status)
 			}
 			rtt := time.Since(now)
 			// extract the binary response in DNS Message.

pkg/resolvers/resolver.go

@@ -7,14 +7,14 @@ import (
 )
 
 // Resolver implements the configuration for a DNS
-// Client. Different types of client like (UDP/TCP/DOH/DOT)
+// Client. Different types of providers can load
-// can be initialised.
+// a DNS Resolver satisfying this interface.
 type Resolver interface {
 	Lookup([]dns.Question) ([]Response, error)
 }
 
 // Response represents a custom output format
-// which wraps certain metadata about the DNS query
+// for DNS queries. It wraps metadata about the DNS query
 // and the DNS Answer as well.
 type Response struct {
 	Message    dns.Msg

pkg/resolvers/system.go

@@ -1,73 +0,0 @@
-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) {
-	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
-}

pkg/resolvers/tcp.go

@@ -0,0 +1,93 @@
+package resolvers
+
+import (
+	"net"
+	"time"
+
+	"github.com/miekg/dns"
+)
+
+const (
+	// DefaultTLSPort specifies the default port for a DNS server connecting over TCP over TLS
+	DefaultTLSPort = "853"
+)
+
+// TCPResolver represents the config options for setting up a Resolver.
+type TCPResolver struct {
+	client  *dns.Client
+	servers []string
+}
+
+// TCPResolverOpts represents the config options for setting up a TCPResolver.
+type TCPResolverOpts struct {
+	IPv4Only bool
+	IPv6Only bool
+	Timeout  time.Duration
+}
+
+// NewTCPResolver accepts a list of nameservers and configures a DNS resolver.
+func NewTCPResolver(servers []string, opts TCPResolverOpts) (Resolver, error) {
+	client := &dns.Client{
+		Timeout: opts.Timeout,
+	}
+	var nameservers []string
+
+	// load list of nameservers to the config
+	if len(servers) == 0 {
+		ns, err := getDefaultServers()
+		if err != nil {
+			return nil, err
+		}
+		nameservers = ns
+	} else {
+		// load the list of servers that user specified.
+		for _, srv := range servers {
+			if i := net.ParseIP(srv); i != nil {
+				// if no port specified in nameserver, append defaults.
+				nameservers = append(nameservers, net.JoinHostPort(srv, DefaultTLSPort))
+			} else {
+				// use the port user specified.
+				nameservers = append(nameservers, srv)
+			}
+		}
+	}
+
+	client.Net = "tcp"
+	if opts.IPv4Only {
+		client.Net = "tcp4"
+	}
+	if opts.IPv6Only {
+		client.Net = "tcp6"
+	}
+	return &TCPResolver{
+		client:  client,
+		servers: nameservers,
+	}, 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 (r *TCPResolver) Lookup(questions []dns.Question) ([]Response, error) {
+	var (
+		messages  = prepareMessages(questions)
+		responses []Response
+	)
+
+	for _, msg := range messages {
+		for _, srv := range r.servers {
+			in, rtt, err := r.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
+}

pkg/resolvers/udp.go

@@ -2,6 +2,7 @@ package resolvers
 
 import (
 	"net"
+	"time"
 
 	"github.com/miekg/dns"
 )
@@ -9,58 +10,58 @@ import (
 const (
 	// DefaultUDPPort specifies the default port for a DNS server connecting over UDP
 	DefaultUDPPort = "53"
-	// DefaultTLSPort specifies the default port for a DNS server connecting over TCP over TLS
-	DefaultTLSPort = "853"
 	//DefaultResolvConfPath specifies path to default resolv config file on UNIX.
 	DefaultResolvConfPath = "/etc/resolv.conf"
 )
 
-// ClassicResolver represents the config options for setting up a Resolver.
+// UDPResolver represents the config options for setting up a Resolver.
-type ClassicResolver struct {
+type UDPResolver struct {
 	client  *dns.Client
 	servers []string
 }
 
-// ClassicResolverOpts holds options for setting up a Classic resolver.
+// UDPResolverOpts holds options for setting up a Classic resolver.
-type ClassicResolverOpts struct {
+type UDPResolverOpts struct {
-	UseIPv4 bool
+	IPv4Only bool
-	UseIPv6 bool
+	IPv6Only bool
-	UseTCP  bool
+	Timeout  time.Duration
-	UseTLS  bool
 }
 
-// NewClassicResolver accepts a list of nameservers and configures a DNS resolver.
+// NewUDPResolver accepts a list of nameservers and configures a DNS resolver.
-func NewClassicResolver(servers []string, opts ClassicResolverOpts) (Resolver, error) {
+func NewUDPResolver(servers []string, opts UDPResolverOpts) (Resolver, error) {
-	client := &dns.Client{}
+	client := &dns.Client{
+		Timeout: opts.Timeout,
+	}
 	var nameservers []string
-	for _, srv := range servers {
+
-		if i := net.ParseIP(srv); i != nil {
+	// load list of nameservers to the config
-			// if no port specified in nameserver, append defaults.
+	if len(servers) == 0 {
-			if opts.UseTLS == true {
+		ns, err := getDefaultServers()
-				nameservers = append(nameservers, net.JoinHostPort(srv, DefaultTLSPort))
+		if err != nil {
-			} else {
+			return nil, err
+		}
+		nameservers = ns
+	} else {
+		// load the list of servers that user specified.
+		for _, srv := range servers {
+			if i := net.ParseIP(srv); i != nil {
+				// if no port specified in nameserver, append defaults.
 				nameservers = append(nameservers, net.JoinHostPort(srv, DefaultUDPPort))
+			} else {
+				// use the port user specified.
+				nameservers = append(nameservers, srv)
 			}
-		} else {
-			// use the port user specified.
-			nameservers = append(nameservers, srv)
 		}
 	}
 
 	client.Net = "udp"
-	if opts.UseIPv4 {
+	if opts.IPv4Only {
 		client.Net = "udp4"
 	}
-	if opts.UseIPv6 {
+	if opts.IPv6Only {
 		client.Net = "udp6"
 	}
-	if opts.UseTCP {
+	return &UDPResolver{
-		client.Net = "tcp"
-	}
-	if opts.UseTLS {
-		client.Net = "tcp-tls"
-	}
-	return &ClassicResolver{
 		client:  client,
 		servers: nameservers,
 	}, nil
@@ -69,7 +70,7 @@ func NewClassicResolver(servers []string, opts ClassicResolverOpts) (Resolver, e
 // 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 (c *ClassicResolver) Lookup(questions []dns.Question) ([]Response, error) {
+func (c *UDPResolver) Lookup(questions []dns.Question) ([]Response, error) {
 	var (
 		messages  = prepareMessages(questions)
 		responses []Response

pkg/resolvers/utils.go

@@ -1,6 +1,13 @@
 package resolvers
 
-import "github.com/miekg/dns"
+import (
+	"errors"
+	"fmt"
+	"net"
+	"runtime"
+
+	"github.com/miekg/dns"
+)
 
 // prepareMessages takes a slice fo `dns.Question`
 // and initialises `dns.Messages` for each question
@@ -16,3 +23,26 @@ func prepareMessages(questions []dns.Question) []dns.Msg {
 	}
 	return messages
 }
+
+func getDefaultServers() ([]string, error) {
+	if runtime.GOOS == "windows" {
+		// TODO: Add a method for reading system default nameserver in windows.
+		return nil, errors.New(`unable to read default nameservers in this machine`)
+	}
+	// if no nameserver is provided, take it from `resolv.conf`
+	cfg, err := dns.ClientConfigFromFile(DefaultResolvConfPath)
+	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))
+		}
+	}
+	return servers, nil
+}