feat: root server DNS behavior

Fixes #11

Author: agaffney

internal/dns/dns.go

@@ -3,6 +3,7 @@ package dns
 import (
 	"fmt"
 	"net"
+	"strings"
 
 	"github.com/blinklabs-io/chnsd/internal/config"
 	"github.com/blinklabs-io/chnsd/internal/indexer"
@@ -35,40 +36,51 @@ func handleQuery(w dns.ResponseWriter, r *dns.Msg) {
 	logger := logging.GetLogger()
 	m := new(dns.Msg)
 
-	switch r.Question[0].Qtype {
-	default:
-		// Return a SERVFAIL response for unsupported record types
-		m.SetRcode(r, dns.RcodeServerFailure)
-	case dns.TypeA, dns.TypeNS:
-		records := indexer.GetIndexer().LookupRecords(r.Question[0].Name, dns.Type(r.Question[0].Qtype).String())
-		if len(records) == 0 {
-			// Send NXDOMAIN
-			m.SetRcode(r, dns.RcodeNameError)
-		} else {
-			// Send response
-			m.SetReply(r)
-			for _, record := range records {
-				switch r.Question[0].Qtype {
-				case dns.TypeA:
-					ipAddr := net.ParseIP(record.Value)
-					a := &dns.A{
-						Hdr: dns.RR_Header{Name: record.Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 999},
-						A:   ipAddr,
-					}
-					m.Answer = append(m.Answer, a)
-				case dns.TypeNS:
-					ns := &dns.NS{
-						Hdr: dns.RR_Header{Name: record.Name, Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 999},
-						Ns:  record.Value,
-					}
-					m.Answer = append(m.Answer, ns)
-				default:
-
+	// Split query name into labels and lookup each domain and parent until we get a hit
+	queryLabels := dns.SplitDomainName(r.Question[0].Name)
+	for startLabelIdx := 0; startLabelIdx < len(queryLabels); startLabelIdx++ {
+		lookupDomainName := strings.Join(queryLabels[startLabelIdx:], ".") + `.`
+		domain := indexer.GetIndexer().LookupDomain(lookupDomainName)
+		if domain == nil {
+			continue
+		}
+		// Assemble response
+		m.SetReply(r)
+		for nameserver, ipAddress := range domain.Nameservers {
+			// NS record
+			ns := &dns.NS{
+				Hdr: dns.RR_Header{Name: domain.Name, Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 999},
+				Ns:  nameserver,
+			}
+			m.Ns = append(m.Ns, ns)
+			// A or AAAA record
+			ipAddr := net.ParseIP(ipAddress)
+			if ipAddr.To4() != nil {
+				// IPv4
+				a := &dns.A{
+					Hdr: dns.RR_Header{Name: nameserver, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 999},
+					A:   ipAddr,
 				}
+				m.Extra = append(m.Extra, a)
+			} else {
+				// IPv6
+				aaaa := &dns.AAAA{
+					Hdr:  dns.RR_Header{Name: nameserver, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 999},
+					AAAA: ipAddr,
+				}
+				m.Extra = append(m.Extra, aaaa)
 			}
 		}
+		// Send response
+		if err := w.WriteMsg(m); err != nil {
+			logger.Errorf("failed to write response: %s", err)
+		}
+		// We found our answer, to return from handler
+		return
 	}
 
+	// Return NXDOMAIN if we have no information about the requested domain or any of its parents
+	m.SetRcode(r, dns.RcodeNameError)
 	if err := w.WriteMsg(m); err != nil {
 		logger.Errorf("failed to write response: %s", err)
 	}

internal/indexer/indexer.go

@@ -14,17 +14,11 @@ import (
 	input_chainsync "github.com/blinklabs-io/snek/input/chainsync"
 	output_embedded "github.com/blinklabs-io/snek/output/embedded"
 	"github.com/blinklabs-io/snek/pipeline"
-	"github.com/miekg/dns"
 )
 
 type Domain struct {
-	name    string
-	records map[string]map[string][]DomainRecord
-}
-
-type DomainRecord struct {
-	Name  string
-	Value string
+	Name        string
+	Nameservers map[string]string
 }
 
 type Indexer struct {
@@ -120,63 +114,31 @@ func (i *Indexer) handleEvent(evt event.Event) error {
 			}
 			datumFields := datum.Value().(cbor.Constructor).Fields()
 			domainName := string(datumFields[0].(cbor.ByteString).Bytes()) + `.`
+			// Create empty domain record
+			// This will also clobber any previous definition of the domain
+			i.domains[domainName] = Domain{
+				Name:        domainName,
+				Nameservers: make(map[string]string),
+			}
 			for _, record := range datumFields[1].([]any) {
 				recordConstructor := record.(cbor.Constructor)
 				nameServer := string(recordConstructor.Fields()[0].(cbor.ByteString).Bytes()) + `.`
 				ipAddress := string(recordConstructor.Fields()[1].(cbor.ByteString).Bytes())
-				// Create NS record for domain
-				i.addRecord(domainName, domainName, "NS", nameServer)
-				// Create A record for name server
-				i.addRecord(domainName, nameServer, "A", ipAddress)
+				i.domains[domainName].Nameservers[nameServer] = ipAddress
 			}
 			logger.Infof("found updated registration for domain: %s", domainName)
 		}
 	}
 	return nil
 }
 
-func (i *Indexer) LookupRecords(name string, recordType string) []DomainRecord {
-	for domainName, domain := range i.domains {
-		if dns.IsSubDomain(domainName, name) {
-			if records, ok := domain.records[name]; ok {
-				if record, ok := records[recordType]; ok {
-					return record
-				} else {
-					return nil
-				}
-			} else {
-				return nil
-			}
-		}
+func (i *Indexer) LookupDomain(name string) *Domain {
+	if domain, ok := i.domains[name]; ok {
+		return &domain
 	}
 	return nil
 }
 
-func (i *Indexer) addRecord(domainName string, recordName string, recordType string, value string) {
-	// Create initial domain record
-	if _, ok := i.domains[domainName]; !ok {
-		i.domains[domainName] = Domain{
-			name:    domainName,
-			records: make(map[string]map[string][]DomainRecord),
-		}
-	}
-	// Create initial list for record type
-	if _, ok := i.domains[domainName].records[recordName]; !ok {
-		i.domains[domainName].records[recordName] = make(map[string][]DomainRecord)
-		if _, ok := i.domains[domainName].records[recordName][recordType]; !ok {
-			i.domains[domainName].records[recordName][recordType] = make([]DomainRecord, 0)
-		}
-	}
-	// Create record
-	i.domains[domainName].records[recordName][recordType] = append(
-		i.domains[domainName].records[recordName][recordType],
-		DomainRecord{
-			Name:  recordName,
-			Value: value,
-		},
-	)
-}
-
 // GetIndexer returns the global indexer instance
 func GetIndexer() *Indexer {
 	return globalIndexer