Remove DNS records storage, use dnsmasq or PopuraDNS instead

pkg/meshname/config.go

@@ -1,52 +0,0 @@
-package meshname
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net"
-
-	"github.com/miekg/dns"
-)
-
-func GenConf(target, zone string) (string, error) {
-	ip := net.ParseIP(target)
-	if ip == nil {
-		return "", errors.New("Invalid IP address")
-	}
-	subDomain := DomainFromIP(&ip)
-	selfRecord := fmt.Sprintf("\t\t\"%s.%s AAAA %s\"\n", subDomain, zone, target)
-	confString := fmt.Sprintf("{\n\t\"%s\":[\n%s\t]\n}", subDomain, selfRecord)
-
-	return confString, nil
-}
-
-// Load dnsRecords from a JSON file
-func ParseConfigFile(configPath string) (map[string][]dns.RR, error) {
-	conf, err := ioutil.ReadFile(configPath)
-	if err != nil {
-		return nil, err
-	}
-	var dat map[string][]string
-	if err := json.Unmarshal(conf, &dat); err == nil {
-		return ParseDNSRecordsMap(dat)
-	} else {
-		return nil, err
-	}
-}
-
-// ParseDNSRecordsMap takes a string map and returns a resource record map
-func ParseDNSRecordsMap(dnsRecordsMap map[string][]string) (map[string][]dns.RR, error) {
-	var dnsRecords = make(map[string][]dns.RR)
-	for subDomain, records := range dnsRecordsMap {
-		for _, r := range records {
-			if rr, err := dns.NewRR(r); err == nil {
-				dnsRecords[subDomain] = append(dnsRecords[subDomain], rr)
-			} else {
-				return nil, err
-			}
-		}
-	}
-	return dnsRecords, nil
-}

pkg/meshname/server.go

@@ -19,9 +19,6 @@ type MeshnameServer struct {
 	enableMeshIP bool
 	allowRemote  bool
 
-	dnsRecordsLock sync.RWMutex
-	dnsRecords     map[string][]dns.RR
-
 	startedLock sync.RWMutex
 	started     bool
 }
@@ -34,7 +31,6 @@ func New(log *log.Logger, listenAddr string, networks map[string]*net.IPNet, ena
 	return &MeshnameServer{
 		log:          log,
 		listenAddr:   listenAddr,
-		dnsRecords:   make(map[string][]dns.RR),
 		networks:     networks,
 		dnsClient:    dnsClient,
 		enableMeshIP: enableMeshIP,
@@ -89,19 +85,12 @@ func (s *MeshnameServer) Start() error {
 	}
 }
 
-func (s *MeshnameServer) ConfigureDNSRecords(dnsRecords map[string][]dns.RR) {
-	s.dnsRecordsLock.Lock()
-	s.dnsRecords = dnsRecords
-	s.dnsRecordsLock.Unlock()
-}
-
 func (s *MeshnameServer) handleMeshnameRequest(w dns.ResponseWriter, r *dns.Msg) {
 	var remoteLookups = make(map[string][]dns.Question)
 	m := new(dns.Msg)
 	m.SetReply(r)
 	s.log.Debugln(r.String())
 
-	s.dnsRecordsLock.RLock()
 	for _, q := range r.Question {
 		labels := dns.SplitDomainName(q.Name)
 		if len(labels) < 2 {
@@ -110,13 +99,7 @@ func (s *MeshnameServer) handleMeshnameRequest(w dns.ResponseWriter, r *dns.Msg)
 		}
 		subDomain := labels[len(labels)-2]
 
-		if records, ok := s.dnsRecords[subDomain]; ok {
-			for _, rec := range records {
-				if h := rec.Header(); h.Name == q.Name && h.Rrtype == q.Qtype && h.Class == q.Qclass {
-					m.Answer = append(m.Answer, rec)
-				}
-			}
-		} else if s.isRemoteLookupAllowed(w.RemoteAddr()) {
+		if s.isRemoteLookupAllowed(w.RemoteAddr()) {
 			// do remote lookups only for local clients
 			resolvedAddr, err := IPFromDomain(&subDomain)
 			if err != nil {
@@ -133,7 +116,6 @@ func (s *MeshnameServer) handleMeshnameRequest(w dns.ResponseWriter, r *dns.Msg)
 			}
 		}
 	}
-	s.dnsRecordsLock.RUnlock()
 
 	for remoteServer, questions := range remoteLookups {
 		rm := new(dns.Msg)