feat: support CNAME records in customDNS mappings

.gitignore

@@ -15,3 +15,4 @@ vendor/
 coverage.html
 coverage.txt
 coverage/
+blocky

config/config_test.go

@@ -235,6 +235,17 @@ blocking:
 				Expect(err.Error()).Should(ContainSubstring("invalid IP address '192.168.178.WRONG'"))
 			})
 		})
+		When("CustomDNS hast wrong IPv6 defined", func() {
+			It("should return error", func() {
+				cfg := Config{}
+				data := `customDNS:
+  mapping:
+    someDomain: 2001:MALFORMED:IP:ADDRESS:0000:8a2e:0370:7334`
+				err := unmarshalConfig(logger, []byte(data), &cfg)
+				Expect(err).Should(HaveOccurred())
+				Expect(err.Error()).Should(ContainSubstring("invalid IP address '2001:MALFORMED:IP:ADDRESS:0000:8a2e:0370:7334'"))
+			})
+		})
 		When("Conditional mapping hast wrong defined upstreams", func() {
 			It("should return error", func() {
 				cfg := Config{}
@@ -866,12 +877,24 @@ func defaultTestFileConfig(config *Config) {
 	Expect(config.Upstreams.Groups["default"][0].Host).Should(Equal("8.8.8.8"))
 	Expect(config.Upstreams.Groups["default"][1].Host).Should(Equal("8.8.4.4"))
 	Expect(config.Upstreams.Groups["default"][2].Host).Should(Equal("1.1.1.1"))
-	Expect(config.CustomDNS.Mapping.HostIPs).Should(HaveLen(2))
-	Expect(config.CustomDNS.Mapping.HostIPs["my.duckdns.org"][0]).Should(Equal(net.ParseIP("192.168.178.3")))
-	Expect(config.CustomDNS.Mapping.HostIPs["multiple.ips"][0]).Should(Equal(net.ParseIP("192.168.178.3")))
-	Expect(config.CustomDNS.Mapping.HostIPs["multiple.ips"][1]).Should(Equal(net.ParseIP("192.168.178.4")))
-	Expect(config.CustomDNS.Mapping.HostIPs["multiple.ips"][2]).Should(Equal(
-		net.ParseIP("2001:0db8:85a3:08d3:1319:8a2e:0370:7344")))
+	Expect(config.CustomDNS.Mapping).Should(HaveLen(2))
+
+	duckDNSEntry := config.CustomDNS.Mapping["my.duckdns.org"][0]
+	duckDNSA := duckDNSEntry.(*dns.A)
+	Expect(duckDNSA.A).Should(Equal(net.ParseIP("192.168.178.3")))
+
+	multipleIpsEntry := config.CustomDNS.Mapping["multiple.ips"][0]
+	multipleIpsA := multipleIpsEntry.(*dns.A)
+	Expect(multipleIpsA.A).Should(Equal(net.ParseIP("192.168.178.3")))
+
+	multipleIpsEntry = config.CustomDNS.Mapping["multiple.ips"][1]
+	multipleIpsA = multipleIpsEntry.(*dns.A)
+	Expect(multipleIpsA.A).Should(Equal(net.ParseIP("192.168.178.4")))
+
+	multipleIpsEntry = config.CustomDNS.Mapping["multiple.ips"][2]
+	multipleIpsAAAA := multipleIpsEntry.(*dns.AAAA)
+	Expect(multipleIpsAAAA.AAAA).Should(Equal(net.ParseIP("2001:db8:85a3:8d3:1319:8a2e:370:7344")))
+
 	Expect(config.Conditional.Mapping.Upstreams).Should(HaveLen(2))
 	Expect(config.Conditional.Mapping.Upstreams["fritz.box"]).Should(HaveLen(1))
 	Expect(config.Conditional.Mapping.Upstreams["multiple.resolvers"]).Should(HaveLen(2))

config/custom_dns.go

@@ -5,6 +5,7 @@ import (
 	"net"
 	"strings"
 
+	"github.com/miekg/dns"
 	"github.com/sirupsen/logrus"
 )
 
@@ -16,14 +17,45 @@ type CustomDNS struct {
 	FilterUnmappedTypes bool             `yaml:"filterUnmappedTypes" default:"true"`
 }
 
-// CustomDNSMapping mapping for the custom DNS configuration
-type CustomDNSMapping struct {
-	HostIPs map[string][]net.IP `yaml:"hostIPs"`
+type (
+	CustomDNSMapping map[string]CustomDNSEntries
+	CustomDNSEntries []dns.RR
+)
+
+func (c *CustomDNSEntries) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var input string
+	if err := unmarshal(&input); err != nil {
+		return err
+	}
+
+	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
 }
 
 // IsEnabled implements `config.Configurable`.
 func (c *CustomDNS) IsEnabled() bool {
-	return len(c.Mapping.HostIPs) != 0
+	return len(c.Mapping) != 0
 }
 
 // LogConfig implements `config.Configurable`.
@@ -33,36 +65,52 @@ func (c *CustomDNS) LogConfig(logger *logrus.Entry) {
 
 	logger.Info("mapping:")
 
-	for key, val := range c.Mapping.HostIPs {
+	for key, val := range c.Mapping {
 		logger.Infof("  %s = %s", key, val)
 	}
 }
 
-// UnmarshalYAML implements `yaml.Unmarshaler`.
-func (c *CustomDNSMapping) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var input map[string]string
-	if err := unmarshal(&input); err != nil {
-		return err
-	}
+func removePrefixSuffix(in, prefix string) string {
+	in = strings.TrimPrefix(in, fmt.Sprintf("%s(", prefix))
+	in = strings.TrimSuffix(in, ")")
+
+	return strings.TrimSpace(in)
+}
 
-	result := make(map[string][]net.IP, len(input))
+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}
 
-	for k, v := range input {
-		var ips []net.IP
+		return cname, nil
+	}
 
-		for _, part := range strings.Split(v, ",") {
-			ip := net.ParseIP(strings.TrimSpace(part))
-			if ip == nil {
-				return fmt.Errorf("invalid IP address '%s'", part)
-			}
+	// 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)
 
-			ips = append(ips, ip)
+		if ip == nil {
+			return nil, fmt.Errorf("invalid IP address '%s'", part)
 		}
 
-		result[k] = ips
-	}
+		a := new(dns.A)
+		a.A = ip
 
-	c.HostIPs = result
+		return a, nil
+	} else { // IPV6 address
+		ipStr := removePrefixSuffix(part, "AAAA")
+		ip := net.ParseIP(ipStr)
 
-	return nil
+		if ip == nil {
+			return nil, fmt.Errorf("invalid IP address '%s'", part)
+		}
+
+		aaaa := new(dns.AAAA)
+		aaaa.AAAA = ip
+
+		return aaaa, nil
+	}
 }

config/custom_dns_test.go

@@ -5,6 +5,7 @@ import (
 	"net"
 
 	"github.com/creasty/defaults"
+	"github.com/miekg/dns"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@@ -17,15 +18,14 @@ var _ = Describe("CustomDNSConfig", func() {
 	BeforeEach(func() {
 		cfg = CustomDNS{
 			Mapping: CustomDNSMapping{
-				HostIPs: map[string][]net.IP{
-					"custom.domain": {net.ParseIP("192.168.143.123")},
-					"ip6.domain":    {net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334")},
-					"multiple.ips": {
-						net.ParseIP("192.168.143.123"),
-						net.ParseIP("192.168.143.125"),
-						net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"),
-					},
+				"custom.domain": {&dns.A{A: net.ParseIP("192.168.143.123")}},
+				"ip6.domain":    {&dns.AAAA{AAAA: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334")}},
+				"multiple.ips": {
+					&dns.A{A: net.ParseIP("192.168.143.123")},
+					&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"}},
 			},
 		}
 	})
@@ -60,27 +60,41 @@ var _ = Describe("CustomDNSConfig", func() {
 			Expect(hook.Calls).ShouldNot(BeEmpty())
 			Expect(hook.Messages).Should(ContainElements(
 				ContainSubstring("custom.domain = "),
+				ContainSubstring("ip6.domain = "),
 				ContainSubstring("multiple.ips = "),
+				ContainSubstring("cname.domain = "),
 			))
 		})
 	})
 
 	Describe("UnmarshalYAML", func() {
 		It("Should parse config as map", func() {
-			c := &CustomDNSMapping{}
+			c := CustomDNSEntries{}
 			err := c.UnmarshalYAML(func(i interface{}) error {
-				*i.(*map[string]string) = map[string]string{"key": "1.2.3.4"}
+				*i.(*string) = "1.2.3.4"
 
 				return nil
 			})
 			Expect(err).Should(Succeed())
-			Expect(c.HostIPs).Should(HaveLen(1))
-			Expect(c.HostIPs["key"]).Should(HaveLen(1))
-			Expect(c.HostIPs["key"][0]).Should(Equal(net.ParseIP("1.2.3.4")))
+			Expect(c).Should(HaveLen(1))
+
+			aRecord := c[0].(*dns.A)
+			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{}
+			err := c.UnmarshalYAML(func(i interface{}) error {
+				*i.(*string) = "CNAME(example.com),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"))
 		})
 
 		It("should fail if wrong YAML format", func() {
-			c := &CustomDNSMapping{}
+			c := &CustomDNSEntries{}
 			err := c.UnmarshalYAML(func(i interface{}) error {
 				return errors.New("some err")
 			})

docs/config.yml

@@ -47,6 +47,7 @@ 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

docs/configuration.md

@@ -259,12 +259,12 @@ You can define your own domain name to IP mappings. For example, you can use a u
 or define a domain name for your local device on order to use the HTTPS certificate. Multiple IP addresses for one
 domain must be separated by a comma.
 
-| Parameter           | Type                                    | Mandatory | Default value |
-| ------------------- | --------------------------------------- | --------- | ------------- |
-| customTTL           | duration (no unit is minutes)           | no        | 1h            |
-| rewrite             | string: string (domain: domain)         | no        |               |
-| mapping             | string: string (hostname: address list) | no        |               |
-| filterUnmappedTypes | boolean                                 | no        | true          |
+| Parameter           | Type                                        | Mandatory | Default value |
+| ------------------- | ------------------------------------------- | --------- | ------------- |
+| customTTL           | duration (no unit is minutes)               | no        | 1h            |
+| rewrite             | string: string (domain: domain)             | no        |               |
+| mapping             | string: string (hostname: address or CNAME) | no        |               |
+| filterUnmappedTypes | boolean                                     | no        | true          |
 
 !!! example
 
@@ -278,11 +278,14 @@ domain must be separated by a comma.
       mapping:
         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)
     ```
 
 This configuration will also resolve any subdomain of the defined domain, recursively. For example querying any of
 `printer.lan`, `my.printer.lan` or `i.love.my.printer.lan` will return 192.168.178.3.
 
+CNAME records are supported by setting the value of the mapping to `CNAME(target)`. Note that the target will be recursively resolved and will return an error if a loop is detected.
+
 With the optional parameter `rewrite` you can replace domain part of the query with the defined part **before** the
 resolver lookup is performed.
 The query "printer.home" will be rewritten to "printer.lan" and return 192.168.178.3.

e2e/containers.go

@@ -66,7 +66,7 @@ func createDNSMokkaContainer(ctx context.Context, alias string, rules ...string)
 // createHTTPServerContainer creates a static HTTP server container that serves one file with the given lines
 // and is attached to the test network under the given alias.
 // It is automatically terminated when the test is finished.
-func createHTTPServerContainer(ctx context.Context, alias string, filename string, lines ...string,
+func createHTTPServerContainer(ctx context.Context, alias, filename string, lines ...string,
 ) (testcontainers.Container, error) {
 	file := createTempFile(lines...)
 

helpertest/helper.go

@@ -212,6 +212,8 @@ func (matcher *dnsRecordMatcher) matchSingle(rr dns.RR) (success bool, err error
 		return v.A.String() == matcher.answer, nil
 	case *dns.AAAA:
 		return v.AAAA.String() == matcher.answer, nil
+	case *dns.CNAME:
+		return v.Target == matcher.answer, nil
 	case *dns.PTR:
 		return v.Ptr == matcher.answer, nil
 	case *dns.MX: