feat: Refactor output format

pkg/resolvers/utils.go

@@ -1,20 +1,156 @@
 package resolvers
 
 import (
+	"fmt"
+	"strconv"
+	"time"
+
 	"github.com/miekg/dns"
 )
 
-// prepareMessages takes a slice fo `dns.Question`
-// and initialises `dns.Messages` for each question
-func prepareMessages(questions []dns.Question) []dns.Msg {
-	var messages = make([]dns.Msg, 0, len(questions))
-	for _, q := range questions {
+// prepareMessages takes a  DNS Question and returns the
+// corresponding DNS messages for the same.
+func prepareMessages(q dns.Question, ndots int, searchList []string) []dns.Msg {
+	var (
+		possibleQNames = constructPossibleQuestions(q.Name, ndots, searchList)
+		messages       = make([]dns.Msg, 0, len(possibleQNames))
+	)
+
+	for _, qName := range possibleQNames {
 		msg := dns.Msg{}
+		// generate a random id for the transaction.
 		msg.Id = dns.Id()
 		msg.RecursionDesired = true
 		// It's recommended to only send 1 question for 1 DNS message.
-		msg.Question = []dns.Question{q}
+		msg.Question = []dns.Question{{
+			Name:   qName,
+			Qtype:  q.Qtype,
+			Qclass: q.Qclass,
+		}}
 		messages = append(messages, msg)
 	}
+
 	return messages
 }
+
+// NameList returns all of the names that should be queried based on the
+// config. It is based off of go's net/dns name building, but it does not
+// check the length of the resulting names.
+// NOTE: It is taken from `miekg/dns/clientconfig.go: func (c *ClientConfig) NameList`
+// and slightly modified.
+func constructPossibleQuestions(name string, ndots int, searchList []string) []string {
+	// if this domain is already fully qualified, no append needed.
+	if dns.IsFqdn(name) {
+		return []string{name}
+	}
+
+	// Check to see if the name has more labels than Ndots. Do this before making
+	// the domain fully qualified.
+	hasNdots := dns.CountLabel(name) > ndots
+	// Make the domain fully qualified.
+	name = dns.Fqdn(name)
+
+	// Make a list of names based off search.
+	names := []string{}
+
+	// If name has enough dots, try that first.
+	if hasNdots {
+		names = append(names, name)
+	}
+	for _, s := range searchList {
+		names = append(names, dns.Fqdn(name+s))
+	}
+	// If we didn't have enough dots, try after suffixes.
+	if !hasNdots {
+		names = append(names, name)
+	}
+	return names
+}
+
+// parseMessage takes a `dns.Message` and returns a custom
+// Response data struct.
+func parseMessage(msg *dns.Msg, rtt time.Duration, server string) Response {
+	var resp Response
+	timeTaken := fmt.Sprintf("%dms", rtt.Milliseconds())
+
+	// Parse Authorities section.
+	for _, ns := range msg.Ns {
+		// check for SOA record
+		soa, ok := ns.(*dns.SOA)
+		if !ok {
+			// Currently we only check for SOA in Authority.
+			// If it's not SOA, skip this message.
+			continue
+		}
+		mname := soa.Ns + " " + soa.Mbox +
+			" " + strconv.FormatInt(int64(soa.Serial), 10) +
+			" " + strconv.FormatInt(int64(soa.Refresh), 10) +
+			" " + strconv.FormatInt(int64(soa.Retry), 10) +
+			" " + strconv.FormatInt(int64(soa.Expire), 10) +
+			" " + strconv.FormatInt(int64(soa.Minttl), 10)
+		h := ns.Header()
+		name := h.Name
+		qclass := dns.Class(h.Class).String()
+		ttl := strconv.FormatInt(int64(h.Ttl), 10) + "s"
+		qtype := dns.Type(h.Rrtype).String()
+		auth := Authority{
+			Name:       name,
+			Type:       qtype,
+			TTL:        ttl,
+			Class:      qclass,
+			MName:      mname,
+			Nameserver: server,
+			RTT:        timeTaken,
+			Status:     dns.RcodeToString[msg.Rcode],
+		}
+		resp.Authorities = append(resp.Authorities, auth)
+	}
+	// Parse Answers section.
+	for _, a := range msg.Answer {
+		addr := ""
+		switch t := a.(type) {
+		case *dns.A:
+			addr = t.A.String()
+		case *dns.AAAA:
+			addr = t.AAAA.String()
+		case *dns.CNAME:
+			addr = t.Target
+		case *dns.CAA:
+			addr = t.Tag + " " + t.Value
+		case *dns.HINFO:
+			addr = t.Cpu + " " + t.Os
+		case *dns.PTR:
+			addr = t.Ptr
+		case *dns.SRV:
+			addr = strconv.Itoa(int(t.Priority)) + " " +
+				strconv.Itoa(int(t.Weight)) + " " +
+				t.Target + ":" + strconv.Itoa(int(t.Port))
+		case *dns.TXT:
+			addr = t.String()
+		case *dns.NS:
+			addr = t.Ns
+		case *dns.MX:
+			addr = strconv.Itoa(int(t.Preference)) + " " + t.Mx
+		case *dns.SOA:
+			addr = t.String()
+		case *dns.NAPTR:
+			addr = t.String()
+		}
+		h := a.Header()
+		name := h.Name
+		qclass := dns.Class(h.Class).String()
+		ttl := strconv.FormatInt(int64(h.Ttl), 10) + "s"
+		qtype := dns.Type(h.Rrtype).String()
+		ans := Answer{
+			Name:       name,
+			Type:       qtype,
+			TTL:        ttl,
+			Class:      qclass,
+			Address:    addr,
+			RTT:        timeTaken,
+			Nameserver: server,
+		}
+		resp.Answers = append(resp.Answers, ans)
+	}
+	return resp
+}