feat: Refactor output format

cmd/doggo/cli.go

@@ -2,9 +2,12 @@ package main
 
 import (
 	"os"
+	"strings"
 
 	"github.com/knadh/koanf"
 	"github.com/knadh/koanf/providers/posflag"
+	"github.com/miekg/dns"
+	"github.com/mr-karan/doggo/pkg/resolvers"
 	"github.com/sirupsen/logrus"
 	flag "github.com/spf13/pflag"
 )
@@ -87,13 +90,29 @@ func main() {
 		hub.Logger.Exit(2)
 	}
 
+	// Load Questions.
+	for _, n := range hub.QueryFlags.QNames {
+		for _, t := range hub.QueryFlags.QTypes {
+			for _, c := range hub.QueryFlags.QClasses {
+				hub.Questions = append(hub.Questions, dns.Question{
+					Name:   n,
+					Qtype:  dns.StringToType[strings.ToUpper(t)],
+					Qclass: dns.StringToClass[strings.ToUpper(c)],
+				})
+			}
+		}
+	}
+
 	// Load Nameservers.
 	err = hub.loadNameservers()
 	if err != nil {
 		hub.Logger.WithError(err).Error("error loading nameservers")
 		hub.Logger.Exit(2)
 	}
 
+	// Load Resolver Options.
+	hub.loadResolverOptions()
+
 	// Load Resolvers.
 	err = hub.loadResolvers()
 	if err != nil {
@@ -109,12 +128,17 @@ func main() {
 	}
 
 	// Resolve Queries.
-	responses, err := hub.Lookup()
-	if err != nil {
-		hub.Logger.WithError(err).Error("error looking up DNS records")
-		hub.Logger.Exit(2)
+	var responses []resolvers.Response
+	for _, q := range hub.Questions {
+		for _, rslv := range hub.Resolver {
+			resp, err := rslv.Lookup(q)
+			if err != nil {
+				hub.Logger.WithError(err).Error("error looking up DNS records")
+				hub.Logger.Exit(2)
+			}
+			responses = append(responses, resp)
+		}
 	}
-	//Send the output.
 	hub.Output(responses)
 
 	// Quitting.

cmd/doggo/hub.go

@@ -16,6 +16,7 @@ type Hub struct {
 	UnparsedArgs []string
 	Questions    []dns.Question
 	Resolver     []resolvers.Resolver
+	ResolverOpts resolvers.Options
 	Nameservers  []Nameserver
 }
 

cmd/doggo/nameservers.go

@@ -42,29 +42,33 @@ func (hub *Hub) loadNameservers() error {
 	// fallback to system nameserver
 	// in case no nameserver is specified by user.
 	if len(hub.Nameservers) == 0 {
-		ns, ndots, err := getDefaultServers()
+		ns, ndots, search, err := getDefaultServers()
 		if err != nil {
 			return fmt.Errorf("error fetching system default nameserver")
 		}
+		// override if user hasn't specified any value.
 		if hub.QueryFlags.Ndots == 0 {
-			hub.QueryFlags.Ndots = ndots
+			hub.ResolverOpts.Ndots = ndots
+		}
+		if len(search) > 0 && hub.QueryFlags.UseSearchList {
+			hub.ResolverOpts.SearchList = search
 		}
 		hub.Nameservers = append(hub.Nameservers, ns...)
 	}
 	return nil
 }
 
 // getDefaultServers reads the `resolv.conf`
-// file and returns a list of nameservers.
-func getDefaultServers() ([]Nameserver, int, error) {
+// file and returns a list of nameservers with it's config.
+func getDefaultServers() ([]Nameserver, int, []string, error) {
 	if runtime.GOOS == "windows" {
 		// TODO: Add a method for reading system default nameserver in windows.
-		return nil, 0, errors.New(`unable to read default nameservers in this machine`)
+		return nil, 0, 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, 0, err
+		return nil, 0, nil, err
 	}
 	servers := make([]Nameserver, 0, len(cfg.Servers))
 	for _, s := range cfg.Servers {
@@ -75,7 +79,7 @@ func getDefaultServers() ([]Nameserver, int, error) {
 		}
 		servers = append(servers, ns)
 	}
-	return servers, cfg.Ndots, nil
+	return servers, cfg.Ndots, cfg.Search, nil
 }
 
 func initNameserver(n string) (Nameserver, error) {