feat: Support defining records by dns zone format

config/config.go

@@ -455,9 +455,14 @@ func loadConfig(logger *logrus.Entry, path string, mandatory bool) (rCfg *Config
 		return nil, fmt.Errorf("can't read config file(s): %w", err)
 	}
 
-	var data []byte
+	var (
+		data       []byte
+		prettyPath string
+	)
 
 	if fs.IsDir() {
+		prettyPath = filepath.Join(path, "*")
+
 		data, err = readFromDir(path, data)
 
 		if err != nil {
@@ -470,6 +475,8 @@ func loadConfig(logger *logrus.Entry, path string, mandatory bool) (rCfg *Config
 		}
 	}
 
+	cfg.CustomDNS.Zone.configPath = prettyPath
+
 	err = unmarshalConfig(logger, data, &cfg)
 	if err != nil {
 		return nil, err

config/custom_dns.go

@@ -14,14 +14,56 @@ type CustomDNS struct {
 	RewriterConfig      `yaml:",inline"`
 	CustomTTL           Duration         `yaml:"customTTL" default:"1h"`
 	Mapping             CustomDNSMapping `yaml:"mapping"`
+	Zone                ZoneFileDNS      `yaml:"zone" default:""`
 	FilterUnmappedTypes bool             `yaml:"filterUnmappedTypes" default:"true"`
 }
 
 type (
 	CustomDNSMapping map[string]CustomDNSEntries
 	CustomDNSEntries []dns.RR
+
+	ZoneFileDNS struct {
+		RRs        CustomDNSMapping
+		configPath string
+	}
 )
 
+func (z *ZoneFileDNS) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var input string
+	if err := unmarshal(&input); err != nil {
+		return err
+	}
+
+	z.RRs = make(CustomDNSMapping)
+	result := z.RRs
+
+	zoneParser := dns.NewZoneParser(strings.NewReader(input), "", z.configPath)
+	zoneParser.SetIncludeAllowed(true)
+
+	for {
+		zoneRR, ok := zoneParser.Next()
+
+		if !ok {
+			if zoneParser.Err() != nil {
+				return zoneParser.Err()
+			}
+
+			// Done
+			break
+		}
+
+		domain := zoneRR.Header().Name
+
+		if _, ok := result[domain]; !ok {
+			result[domain] = make(CustomDNSEntries, 0, 1)
+		}
+
+		result[domain] = append(result[domain], zoneRR)
+	}
+
+	return nil
+}
+
 func (c *CustomDNSEntries) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var input string
 	if err := unmarshal(&input); err != nil {
@@ -30,24 +72,16 @@ func (c *CustomDNSEntries) UnmarshalYAML(unmarshal func(interface{}) error) erro
 
 	parts := strings.Split(input, ",")
 	result := make(CustomDNSEntries, len(parts))
-	containsCNAME := false
 
 	for i, part := range parts {
 		rr, err := configToRR(part)
 		if err != nil {
 			return err
 		}
 
-		_, isCNAME := rr.(*dns.CNAME)
-		containsCNAME = containsCNAME || isCNAME
-
 		result[i] = rr
 	}
 
-	if containsCNAME && len(result) > 1 {
-		return fmt.Errorf("when a CNAME record is present, it must be the only record in the mapping")
-	}
-
 	*c = result
 
 	return nil
@@ -70,47 +104,21 @@ func (c *CustomDNS) LogConfig(logger *logrus.Entry) {
 	}
 }
 
-func removePrefixSuffix(in, prefix string) string {
-	in = strings.TrimPrefix(in, fmt.Sprintf("%s(", prefix))
-	in = strings.TrimSuffix(in, ")")
-
-	return strings.TrimSpace(in)
-}
-
-func configToRR(part string) (dns.RR, error) {
-	if strings.HasPrefix(part, "CNAME(") {
-		domain := removePrefixSuffix(part, "CNAME")
-		domain = dns.Fqdn(domain)
-		cname := &dns.CNAME{Target: domain}
-
-		return cname, nil
+func configToRR(ipStr string) (dns.RR, error) {
+	ip := net.ParseIP(ipStr)
+	if ip == nil {
+		return nil, fmt.Errorf("invalid IP address '%s'", ipStr)
 	}
 
-	// Fall back to A/AAAA records to maintain backwards compatibility in config.yml
-	// We will still remove the A() or AAAA() if it exists
-	if strings.Contains(part, ".") { // IPV4 address
-		ipStr := removePrefixSuffix(part, "A")
-		ip := net.ParseIP(ipStr)
-
-		if ip == nil {
-			return nil, fmt.Errorf("invalid IP address '%s'", part)
-		}
-
+	if ip.To4() != nil {
 		a := new(dns.A)
 		a.A = ip
 
 		return a, nil
-	} else { // IPV6 address
-		ipStr := removePrefixSuffix(part, "AAAA")
-		ip := net.ParseIP(ipStr)
-
-		if ip == nil {
-			return nil, fmt.Errorf("invalid IP address '%s'", part)
-		}
+	}
 
-		aaaa := new(dns.AAAA)
-		aaaa.AAAA = ip
+	aaaa := new(dns.AAAA)
+	aaaa.AAAA = ip
 
-		return aaaa, nil
-	}
+	return aaaa, nil
 }

config/custom_dns_test.go

@@ -2,8 +2,12 @@ package config
 
 import (
 	"errors"
+	"fmt"
 	"net"
+	"path/filepath"
+	"strings"
 
+	. "github.com/0xERR0R/blocky/helpertest"
 	"github.com/creasty/defaults"
 	"github.com/miekg/dns"
 	. "github.com/onsi/ginkgo/v2"
@@ -25,7 +29,6 @@ var _ = Describe("CustomDNSConfig", func() {
 					&dns.A{A: net.ParseIP("192.168.143.125")},
 					&dns.AAAA{AAAA: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334")},
 				},
-				"cname.domain": {&dns.CNAME{Target: "custom.domain"}},
 			},
 		}
 	})
@@ -62,12 +65,11 @@ var _ = Describe("CustomDNSConfig", func() {
 				ContainSubstring("custom.domain = "),
 				ContainSubstring("ip6.domain = "),
 				ContainSubstring("multiple.ips = "),
-				ContainSubstring("cname.domain = "),
 			))
 		})
 	})
 
-	Describe("UnmarshalYAML", func() {
+	Describe("CustomDNSEntries UnmarshalYAML", func() {
 		It("Should parse config as map", func() {
 			c := CustomDNSEntries{}
 			err := c.UnmarshalYAML(func(i interface{}) error {
@@ -82,24 +84,183 @@ var _ = Describe("CustomDNSConfig", func() {
 			Expect(aRecord.A).Should(Equal(net.ParseIP("1.2.3.4")))
 		})
 
-		It("Should return an error if a CNAME is accomanied by any other record", func() {
-			c := CustomDNSEntries{}
+		It("should fail if wrong YAML format", func() {
+			c := &CustomDNSEntries{}
 			err := c.UnmarshalYAML(func(i interface{}) error {
-				*i.(*string) = "CNAME(example.com),A(1.2.3.4)"
+				return errors.New("some err")
+			})
+			Expect(err).Should(HaveOccurred())
+			Expect(err).Should(MatchError("some err"))
+		})
+	})
+
+	Describe("ZoneFileDNS UnmarshalYAML", func() {
+		It("Should parse config as map", func() {
+			z := ZoneFileDNS{}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = strings.TrimSpace(`
+$ORIGIN example.com.
+www 3600 A 1.2.3.4
+www 3600 AAAA 2001:0db8:85a3:0000:0000:8a2e:0370:7334
+www6 3600 AAAA 2001:0db8:85a3:0000:0000:8a2e:0370:7334
+cname 3600 CNAME www
+				`)
+
+				return nil
+			})
+			Expect(err).Should(Succeed())
+			Expect(z.RRs).Should(HaveLen(3))
+
+			Expect(z.RRs["www.example.com."]).
+				Should(SatisfyAll(
+					HaveLen(2),
+					ContainElements(
+						SatisfyAll(
+							BeDNSRecord("www.example.com.", A, "1.2.3.4"),
+							HaveTTL(BeNumerically("==", 3600)),
+						),
+						SatisfyAll(
+							BeDNSRecord("www.example.com.", AAAA, "2001:db8:85a3::8a2e:370:7334"),
+							HaveTTL(BeNumerically("==", 3600)),
+						))))
+
+			Expect(z.RRs["www6.example.com."]).
+				Should(SatisfyAll(
+					HaveLen(1),
+					ContainElements(
+						SatisfyAll(
+							BeDNSRecord("www6.example.com.", AAAA, "2001:db8:85a3::8a2e:370:7334"),
+							HaveTTL(BeNumerically("==", 3600)),
+						))))
+
+			Expect(z.RRs["cname.example.com."]).
+				Should(SatisfyAll(
+					HaveLen(1),
+					ContainElements(
+						SatisfyAll(
+							BeDNSRecord("cname.example.com.", CNAME, "www.example.com."),
+							HaveTTL(BeNumerically("==", 3600)),
+						))))
+		})
+
+		It("Should support the $INCLUDE directive with a bare filename", func() {
+			folder := NewTmpFolder("zones")
+			folder.CreateStringFile("other.zone", `
+www 3600 A 1.2.3.4
+			`)
+
+			z := ZoneFileDNS{configPath: filepath.Join(folder.Path, "*")}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = strings.TrimSpace(`
+$ORIGIN example.com.
+$INCLUDE other.zone`)
+
+				return nil
+			})
+			Expect(err).Should(Succeed())
+			Expect(z.RRs).Should(HaveLen(1))
+
+			Expect(z.RRs["www.example.com."]).
+				Should(SatisfyAll(
+
+					HaveLen(1),
+					ContainElements(
+						SatisfyAll(
+							BeDNSRecord("www.example.com.", A, "1.2.3.4"),
+							HaveTTL(BeNumerically("==", 3600)),
+						)),
+				))
+		})
+		It("Should support the $INCLUDE directive with a relative filename", func() {
+			folder := NewTmpFolder("zones")
+			folder.CreateStringFile("other.zone", `
+www 3600 A 1.2.3.4
+			`)
+
+			z := ZoneFileDNS{configPath: filepath.Join(folder.Path, "*")}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = strings.TrimSpace(`
+$ORIGIN example.com.
+$INCLUDE ./other.zone`)
+
+				return nil
+			})
+			Expect(err).Should(Succeed())
+			Expect(z.RRs).Should(HaveLen(1))
+
+			Expect(z.RRs["www.example.com."]).
+				Should(SatisfyAll(
+
+					HaveLen(1),
+					ContainElements(
+						SatisfyAll(
+							BeDNSRecord("www.example.com.", A, "1.2.3.4"),
+							HaveTTL(BeNumerically("==", 3600)),
+						)),
+				))
+		})
+		It("Should support the $INCLUDE directive with an absolute path", func() {
+			folder := NewTmpFolder("zones")
+			file := folder.CreateStringFile("other.zone", `
+www 3600 A 1.2.3.4
+			`)
+
+			z := ZoneFileDNS{}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = strings.TrimSpace(`
+$ORIGIN example.com.
+$INCLUDE ` + file.Path)
+
+				return nil
+			})
+			Expect(err).Should(Succeed())
+			Expect(z.RRs).Should(HaveLen(1))
+
+			Expect(z.RRs["www.example.com."]).
+				Should(SatisfyAll(
+
+					HaveLen(1),
+					ContainElements(
+						SatisfyAll(
+							BeDNSRecord("www.example.com.", A, "1.2.3.4"),
+							HaveTTL(BeNumerically("==", 3600)),
+						)),
+				))
+		})
+
+		It("Should return an error if the zone file is malformed", func() {
+			z := ZoneFileDNS{}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = strings.TrimSpace(`
+$ORIGIN example.com.
+www A 1.2.3.4
+				`)
 
 				return nil
 			})
 			Expect(err).Should(HaveOccurred())
-			Expect(err).Should(MatchError("when a CNAME record is present, it must be the only record in the mapping"))
+			Expect(err.Error()).Should(ContainSubstring("dns: missing TTL with no previous value"))
 		})
+		It("Should return an error if a relative record is provided without an origin", func() {
+			z := ZoneFileDNS{}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = strings.TrimSpace(`
+$TTL 3600
+www A 1.2.3.4
+				`)
 
-		It("should fail if wrong YAML format", func() {
-			c := &CustomDNSEntries{}
-			err := c.UnmarshalYAML(func(i interface{}) error {
-				return errors.New("some err")
+				return nil
 			})
 			Expect(err).Should(HaveOccurred())
-			Expect(err).Should(MatchError("some err"))
+			Expect(err.Error()).Should(ContainSubstring("dns: bad owner name: \"www\""))
+		})
+		It("Should return an error if the unmarshall function returns an error", func() {
+			z := ZoneFileDNS{}
+			err := z.UnmarshalYAML(func(i interface{}) error {
+				return fmt.Errorf("Failed to unmarshal")
+			})
+			Expect(err).Should(HaveOccurred())
+			Expect(err).Should(MatchError("Failed to unmarshal"))
 		})
 	})
 })

docs/config.yml

@@ -47,7 +47,6 @@ customDNS:
     example.com: printer.lan
   mapping:
     printer.lan: 192.168.178.3,2001:0db8:85a3:08d3:1319:8a2e:0370:7344
-    second-printer-address.lan: CNAME(printer.lan)
 
 # optional: definition, which DNS resolver(s) should be used for queries to the domain (with all sub-domains). Multiple resolvers must be separated by a comma
 # Example: Query client.fritz.box will ask DNS server 192.168.178.1. This is necessary for local network, to resolve clients by host name