feat: Support defining records by dns zone format

config/custom_dns.go

@@ -14,14 +14,56 @@ type CustomDNS struct {
 	RewriterConfig      `yaml:",inline"`
 	CustomTTL           Duration         `yaml:"customTTL" default:"1h"`
 	Mapping             CustomDNSMapping `yaml:"mapping"`
+	ZoneFileMapping     ZoneFileDNS      `yaml:"zoneFileMapping" default:""`
 	FilterUnmappedTypes bool             `yaml:"filterUnmappedTypes" default:"true"`
 }
 
 type (
 	CustomDNSMapping map[string]CustomDNSEntries
 	CustomDNSEntries []dns.RR
+
+	ZoneFileDNS CustomDNSMapping
 )
 
+func (z *ZoneFileDNS) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var input string
+	if err := unmarshal(&input); err != nil {
+		return err
+	}
+
+	result := make(ZoneFileDNS, len(input))
+
+	if input != "" {
+		zoneParser := dns.NewZoneParser(strings.NewReader(input), "", "")
+		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)
+			}
+
+			result[domain] = append(result[domain], zoneRR)
+		}
+	}
+
+	*z = result
+
+	return nil
+}
+
 func (c *CustomDNSEntries) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var input string
 	if err := unmarshal(&input); err != nil {

config/custom_dns_test.go

@@ -2,7 +2,9 @@ package config
 
 import (
 	"errors"
+	"fmt"
 	"net"
+	"strings"
 
 	"github.com/creasty/defaults"
 	"github.com/miekg/dns"
@@ -67,7 +69,7 @@ var _ = Describe("CustomDNSConfig", func() {
 		})
 	})
 
-	Describe("UnmarshalYAML", func() {
+	Describe("#CustomDNSEntries UnmarshalYAML", func() {
 		It("Should parse config as map", func() {
 			c := CustomDNSEntries{}
 			err := c.UnmarshalYAML(func(i interface{}) error {
@@ -102,4 +104,71 @@ var _ = Describe("CustomDNSConfig", func() {
 			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
+www6 3600 AAAA 2001:0db8:85a3:0000:0000:8a2e:0370:7334
+cname 3600 CNAME www
+				`)
+
+				return nil
+			})
+			Expect(err).Should(Succeed())
+			Expect(z).Should(HaveLen(3))
+
+			for url, records := range z {
+				if url == "www.example.com." {
+					Expect(records).Should(HaveLen(1))
+
+					record, isA := records[0].(*dns.A)
+
+					Expect(isA).Should(BeTrue())
+					Expect(record.A).Should(Equal(net.ParseIP("1.2.3.4")))
+				} else if url == "www6.example.com." {
+					Expect(records).Should(HaveLen(1))
+
+					record, isAAAA := records[0].(*dns.AAAA)
+
+					Expect(isAAAA).Should(BeTrue())
+					Expect(record.AAAA).Should(Equal(net.ParseIP("2001:db8:85a3::8a2e:370:7334")))
+				} else if url == "cname.example.com." {
+					Expect(records).Should(HaveLen(1))
+
+					record, isCNAME := records[0].(*dns.CNAME)
+
+					Expect(isCNAME).Should(BeTrue())
+					Expect(record.Target).Should(Equal("www.example.com."))
+				} else {
+					Fail("unexpected record")
+				}
+			}
+		})
+
+		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.Error()).Should(ContainSubstring("dns: missing TTL with no previous value"))
+		})
+		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/configuration.md

@@ -264,6 +264,7 @@ domain must be separated by a comma.
 | customTTL           | duration (no unit is minutes)               | no        | 1h            |
 | rewrite             | string: string (domain: domain)             | no        |               |
 | mapping             | string: string (hostname: address or CNAME) | no        |               |
+| zoneFileMapping     | multiline string containing a DNS Zone File | no        |               |
 | filterUnmappedTypes | boolean                                     | no        | true          |
 
 !!! example
@@ -279,6 +280,10 @@ domain must be separated by a comma.
         printer.lan: 192.168.178.3
         otherdevice.lan: 192.168.178.15,2001:0db8:85a3:08d3:1319:8a2e:0370:7344
         anothername.lan: CNAME(otherdevice.lan)
+      zoneFileMapping: |
+        $ORIGIN example.com.
+        www 3600 A 1.2.3.4
+        @ 3600 CNAME www
     ```
 
 This configuration will also resolve any subdomain of the defined domain, recursively. For example querying any of

resolver/custom_dns_resolver.go

@@ -31,12 +31,21 @@ type CustomDNSResolver struct {
 
 // NewCustomDNSResolver creates new resolver instance
 func NewCustomDNSResolver(cfg config.CustomDNS) *CustomDNSResolver {
-	m := make(config.CustomDNSMapping, len(cfg.Mapping))
-	reverse := make(map[string][]string, len(cfg.Mapping))
+	dnsRecords := make(config.CustomDNSMapping, len(cfg.Mapping)+len(cfg.ZoneFileMapping))
 
 	for url, entries := range cfg.Mapping {
-		m[strings.ToLower(url)] = entries
+		url = util.ExtractDomainOnly(url)
+		dnsRecords[url] = entries
+	}
+
+	for url, entries := range cfg.ZoneFileMapping {
+		url = util.ExtractDomainOnly(url)
+		dnsRecords[url] = entries
+	}
+
+	reverse := make(map[string][]string, len(dnsRecords))
 
+	for url, entries := range dnsRecords {
 		for _, entry := range entries {
 			a, isA := entry.(*dns.A)
 
@@ -59,7 +68,7 @@ func NewCustomDNSResolver(cfg config.CustomDNS) *CustomDNSResolver {
 		typed:        withType("custom_dns"),
 
 		createAnswerFromQuestion: util.CreateAnswerFromQuestion,
-		mapping:                  m,
+		mapping:                  dnsRecords,
 		reverseAddresses:         reverse,
 	}
 }

resolver/custom_dns_resolver_test.go

@@ -53,6 +53,9 @@ var _ = Describe("CustomDNSResolver", func() {
 				"cname.recursive": {&dns.CNAME{Target: "cname.recursive"}},
 				"mx.domain":       {&dns.MX{Mx: "mx.domain"}},
 			},
+			ZoneFileMapping: config.ZoneFileDNS{
+				"example.zone.": {&dns.A{A: net.ParseIP("1.2.3.4")}},
+			},
 			CustomTTL:           config.Duration(time.Duration(TTL) * time.Second),
 			FilterUnmappedTypes: true,
 		}
@@ -136,6 +139,19 @@ var _ = Describe("CustomDNSResolver", func() {
 		When("Ip 4 mapping is defined for custom domain and", func() {
 			Context("filterUnmappedTypes is true", func() {
 				BeforeEach(func() { cfg.FilterUnmappedTypes = true })
+				It("defined ip4 query should be resolved from zone mappings", func() {
+					Expect(sut.Resolve(ctx, newRequest("example.zone.", A))).
+						Should(
+							SatisfyAll(
+								BeDNSRecord("example.zone.", A, "1.2.3.4"),
+								HaveTTL(BeNumerically("==", TTL)),
+								HaveResponseType(ResponseTypeCUSTOMDNS),
+								HaveReason("CUSTOM DNS"),
+								HaveReturnCode(dns.RcodeSuccess),
+							))
+					// will not delegate to next resolver
+					m.AssertNotCalled(GinkgoT(), "Resolve", mock.Anything)
+				})
 				It("defined ip4 query should be resolved", func() {
 					Expect(sut.Resolve(ctx, newRequest("custom.domain.", A))).
 						Should(