Merge pull request #8 from pabateman/feature/resolver-v2

Resolver v2

internal/lookuper/config.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/ghodss/yaml"
 	"github.com/pabateman/dns-lookuper/internal/printer"
-	"github.com/pabateman/dns-lookuper/internal/resolver/v1"
+	"github.com/pabateman/dns-lookuper/internal/resolver/v2"
 	cli "github.com/urfave/cli/v2"
 )
 
@@ -78,7 +78,7 @@ var (
 		},
 		&cli.StringFlag{
 			Name:    argMode,
-			Usage:   fmt.Sprintf("accept one of values: '%s', '%s' or '%s'", resolver.ModeIpv4, resolver.ModeIpv6, resolver.ModeAll),
+			Usage:   fmt.Sprintf("accept one of values: '%s' or '%s'", resolver.ModeIpv4, resolver.ModeIpv6),
 			Aliases: []string{"m"},
 			EnvVars: []string{"DNS_LOOKUPER_MODE"},
 			Value:   modeDefault,
@@ -151,7 +151,6 @@ var (
 	}
 
 	modeEnum = []string{
-		resolver.ModeAll,
 		resolver.ModeIpv4,
 		resolver.ModeIpv6,
 	}

internal/lookuper/lookuper.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/pabateman/dns-lookuper/internal/parser"
 	"github.com/pabateman/dns-lookuper/internal/printer"
-	"github.com/pabateman/dns-lookuper/internal/resolver/v1"
+	"github.com/pabateman/dns-lookuper/internal/resolver/v2"
 
 	log "github.com/sirupsen/logrus"
 	cli "github.com/urfave/cli/v2"
@@ -109,36 +109,32 @@ func performTask(t *task, s *settings) error {
 		return fmt.Errorf("error while parsing lookup timeout: %+v", err)
 	}
 
-	resolver := resolver.NewResolver().
+	r := resolver.NewResolver().
 		WithMode(t.Mode).
 		WithTimeout(lookupTimeout)
 
-	responses, err := resolver.Resolve(domainNames.ParsedNames)
+	responses, err := r.Resolve(domainNames.ParsedNames)
 	if err != nil {
 		return fmt.Errorf("error while resolving domain name: %+v", err)
 	}
 
-	unresolvedErrors := make([]error, 0)
+	responsesNxdomain := resolver.FilterResponsesNxdomain(responses)
 
-	for _, r := range responses {
-		if r.Error != nil {
-			unresolvedErrors = append(unresolvedErrors, r.Error)
-		}
-	}
-
-	if len(unresolvedErrors) > 0 {
+	if len(responsesNxdomain) > 0 {
 		if s.Fail {
-			for _, err := range unresolvedErrors {
-				log.Error(err)
+			for _, response := range responsesNxdomain {
+				log.Errorf("%s: no such host", response.Name)
 			}
 			return fmt.Errorf("encountered errors while resolving domain names")
 		} else {
-			for _, err := range unresolvedErrors {
-				log.Warn(err)
+			for _, response := range responsesNxdomain {
+				log.Warnf("%s: no such host", response.Name)
 			}
 		}
 	}
 
+	responses = resolver.FilterResponsesNoerror(responses)
+
 	var outputFile *os.File
 
 	if t.Output == "-" || t.Output == "/dev/stdout" {

internal/printer/printer.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ghodss/yaml"
 	"github.com/valyala/fasttemplate"
 
-	"github.com/pabateman/dns-lookuper/internal/resolver/v1"
+	"github.com/pabateman/dns-lookuper/internal/resolver/v2"
 )
 
 const (
@@ -123,7 +123,7 @@ func (p *Printer) printTemplate() error {
 			for _, address := range response.Addresses {
 				s := t.ExecuteString(map[string]interface{}{
 					"host":    response.Name,
-					"address": address.String(),
+					"address": address,
 				})
 
 				if _, err := io.WriteString(p.writer, fmt.Sprintln(s)); err != nil {
@@ -145,9 +145,7 @@ func (p *Printer) printList() error {
 	addresses := make([]string, 0)
 
 	for _, response := range p.entries {
-		for _, address := range response.Addresses {
-			addresses = append(addresses, address.String())
-		}
+		addresses = append(addresses, response.Addresses...)
 	}
 
 	slices.Sort(addresses)

internal/printer/printer_test.go

@@ -3,30 +3,29 @@ package printer
 import (
 	"bytes"
 	"fmt"
-	"net"
 	"os"
 	"path"
 	"testing"
 
-	"github.com/pabateman/dns-lookuper/internal/resolver/v1"
+	"github.com/pabateman/dns-lookuper/internal/resolver/v2"
 	"github.com/stretchr/testify/require"
 )
 
 var (
 	entries = []resolver.Response{
 		{
 			Name: "cloudflare.com",
-			Addresses: []net.IP{
-				{8, 8, 8, 8},
-				{1, 1, 1, 1},
+			Addresses: []string{
+				"8.8.8.8",
+				"1.1.1.1",
 			},
 		},
 		{
 			Name: "google.com",
-			Addresses: []net.IP{
-				{10, 10, 10, 10},
-				{123, 123, 123, 123},
-				{8, 8, 8, 8},
+			Addresses: []string{
+				"10.10.10.10",
+				"123.123.123.123",
+				"8.8.8.8",
 			},
 		},
 	}

internal/resolver/v1/resolver_test.go

@@ -98,10 +98,10 @@ func deepCopyResponses(r []Response) []Response {
 func filterResponses(r []Response, f func(net.IP) bool) []Response {
 	for i := range r {
 		for {
-			indexes := slices.IndexFunc(r[i].Addresses, f)
+			index := slices.IndexFunc(r[i].Addresses, f)
 
-			if indexes != -1 {
-				r[i].Addresses = slices.Delete(r[i].Addresses, indexes, indexes+1)
+			if index != -1 {
+				r[i].Addresses = slices.Delete(r[i].Addresses, index, index+1)
 			} else {
 				break
 			}

internal/resolver/v2/resolver.go

@@ -1,7 +1,8 @@
 package resolver
 
 import (
-	"net"
+	"fmt"
+	"strings"
 	"time"
 
 	"github.com/miekg/dns"
@@ -10,8 +11,7 @@ import (
 const (
 	ModeIpv4    = "ipv4"
 	ModeIpv6    = "ipv6"
-	ModeAll     = "all"
-	ModeDefault = ModeAll
+	ModeDefault = ModeIpv4
 )
 
 const (
@@ -20,22 +20,24 @@ const (
 
 type Response struct {
 	Name      string   `json:"name"`
-	Addresses []net.IP `json:"addresses"`
-	Error     error    `json:"-"`
+	Addresses []string `json:"addresses"`
+	rcode     int
 }
 
 type Resolver struct {
 	resolver *dns.Client
 	timeout  time.Duration
-	mode     string
+	mode     uint16
 }
 
 func NewResolver() *Resolver {
 	return &Resolver{
 		resolver: &dns.Client{
-			Timeout: TimeoutDefault,
+			SingleInflight: true,
+			Timeout:        TimeoutDefault,
 		},
 		timeout: TimeoutDefault,
+		mode:    getQueryTypes(ModeDefault),
 	}
 }
 
@@ -44,6 +46,86 @@ func (r *Resolver) WithTimeout(t time.Duration) *Resolver {
 	return r
 }
 
+func (r *Resolver) WithMode(m string) *Resolver {
+	r.mode = getQueryTypes(m)
+	return r
+}
+
 func (r *Resolver) Resolve(dn []string) ([]Response, error) {
-	return nil, nil
+	result := make([]Response, 0)
+	config, err := dns.ClientConfigFromFile("/etc/resolv.conf")
+	if err != nil {
+		return nil, err
+	}
+
+	for _, name := range dn {
+		result = append(result, Response{
+			Name:      name,
+			Addresses: make([]string, 0),
+		},
+		)
+
+		msgQuery := &dns.Msg{
+			MsgHdr: dns.MsgHdr{
+				Id:               dns.Id(),
+				RecursionDesired: true,
+			},
+			Question: []dns.Question{
+				{
+					Name:   dns.Fqdn(name),
+					Qtype:  r.mode,
+					Qclass: dns.ClassINET,
+				},
+			},
+		}
+
+		msqResponse, _, err := r.resolver.Exchange(
+			msgQuery,
+			fmt.Sprintf("%s:%s", config.Servers[0], "53"),
+		)
+
+		if err != nil {
+			return nil, err
+		}
+
+		result[len(result)-1].rcode = msqResponse.MsgHdr.Rcode
+
+		for _, response := range msqResponse.Answer {
+			result[len(result)-1].Addresses = append(result[len(result)-1].Addresses, strings.Split(response.String(), "\t")[4])
+		}
+
+	}
+
+	return result, nil
+}
+
+func FilterResponsesByRcode(rs []Response, rcode int) []Response {
+	result := make([]Response, 0)
+
+	for _, r := range rs {
+		if r.rcode == rcode {
+			result = append(result, r)
+		}
+	}
+
+	return result
+}
+
+func FilterResponsesNoerror(rs []Response) []Response {
+	return FilterResponsesByRcode(rs, dns.StringToRcode["NOERROR"])
+}
+
+func FilterResponsesNxdomain(rs []Response) []Response {
+	return FilterResponsesByRcode(rs, dns.StringToRcode["NXDOMAIN"])
+}
+
+func getQueryTypes(m string) uint16 {
+	switch m {
+	case ModeIpv4:
+		return dns.TypeA
+	case ModeIpv6:
+		return dns.TypeAAAA
+	default:
+		return dns.TypeA
+	}
 }