Merge pull request #10 from blinklabs-io/feat/indexer-dns-responses

feat: use indexer data for DNS responses

Author: agaffney

internal/dns/dns.go

@@ -2,8 +2,10 @@ package dns
 
 import (
 	"fmt"
+	"net"
 
 	"github.com/blinklabs-io/chnsd/internal/config"
+	"github.com/blinklabs-io/chnsd/internal/indexer"
 	"github.com/blinklabs-io/chnsd/internal/logging"
 
 	"github.com/miekg/dns"
@@ -13,7 +15,7 @@ func Start() error {
 	cfg := config.GetConfig()
 	listenAddr := fmt.Sprintf("%s:%d", cfg.Dns.ListenAddress, cfg.Dns.ListenPort)
 	// Setup handler
-	dns.HandleFunc(".", handleTest)
+	dns.HandleFunc(".", handleQuery)
 	// UDP listener
 	serverUdp := &dns.Server{Addr: listenAddr, Net: "udp", TsigSecret: nil, ReusePort: true}
 	go startListener(serverUdp)
@@ -29,25 +31,44 @@ func startListener(server *dns.Server) {
 	}
 }
 
-func handleTest(w dns.ResponseWriter, r *dns.Msg) {
+func handleQuery(w dns.ResponseWriter, r *dns.Msg) {
 	logger := logging.GetLogger()
 	m := new(dns.Msg)
-	m.SetReply(r)
 
-	queryStr := fmt.Sprintf(
-		"%s %s",
-		dns.Type(r.Question[0].Qtype).String(),
-		r.Question[0].Name,
-	)
+	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:
 
-	logger.Infof("request: %s", queryStr)
-
-	t := &dns.TXT{
-		Hdr: dns.RR_Header{Name: "test.zone.", Rrtype: dns.TypeTXT, Class: dns.ClassINET, Ttl: 0},
-		Txt: []string{queryStr},
+				}
+			}
+		}
 	}
 
-	m.Answer = append(m.Answer, t)
 	if err := w.WriteMsg(m); err != nil {
 		logger.Errorf("failed to write response: %s", err)
 	}

internal/indexer/indexer.go

@@ -14,14 +14,28 @@ 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
+}
+
 type Indexer struct {
 	pipeline *pipeline.Pipeline
+	domains  map[string]Domain
 }
 
 // Singleton indexer instance
-var globalIndexer = &Indexer{}
+var globalIndexer = &Indexer{
+	domains: make(map[string]Domain),
+}
 
 func (i *Indexer) Start() error {
 	cfg := config.GetConfig()
@@ -105,20 +119,63 @@ func (i *Indexer) handleEvent(evt event.Event) error {
 				return err
 			}
 			datumFields := datum.Value().(cbor.Constructor).Fields()
-			domainName := string(datumFields[0].(cbor.ByteString).Bytes())
-			nsRecords := []string{}
+			domainName := string(datumFields[0].(cbor.ByteString).Bytes()) + `.`
 			for _, record := range datumFields[1].([]any) {
-				nsRecords = append(
-					nsRecords,
-					string(record.(cbor.ByteString).Bytes()),
-				)
+				nameServer := string(record.(cbor.ByteString).Bytes()) + `.`
+				// Create NS record for domain
+				i.addRecord(domainName, domainName, "NS", nameServer)
+				// Create A record for name server
+				// We use a dummy IP address for now, since the on-chain data doesn't contain the IP yet
+				i.addRecord(domainName, nameServer, "A", "1.2.3.4")
+			}
+			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
 			}
-			logger.Infof("found domain %s with NS records: %v", domainName, nsRecords)
 		}
 	}
 	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