Merge pull request #2 from gaopenghigh/dev

bugfix: do proxy if no AAAA records found, e.g. only CNAME records

dns64.go

@@ -3,7 +3,6 @@ package dns64
 
 import (
 	"errors"
-	"log"
 	"net"
 	"time"
 
@@ -56,13 +55,15 @@ func (r *ResponseWriter) WriteMsg(res *dns.Msg) error {
 	// do not modify if there are AAAA records or NameError. continue if NoData or any other error.
 	ty, _ := response.Typify(res, time.Now().UTC())
 	if ty == response.NoError || ty == response.NameError {
-		return r.ResponseWriter.WriteMsg(res)
+		if hasAAAA(res) {
+			return r.ResponseWriter.WriteMsg(res)
+		}
 	}
 
 	// perform request to upstream.
 	res2, err := r.Proxy.Lookup(state, state.Name(), dns.TypeA)
 	if err != nil {
-		log.Printf("[WARNING] Unable to query upstream DNS: %v", err)
+		log.Warningf("[WARNING] Unable to query upstream DNS: %v", err)
 		res.MsgHdr.Rcode = dns.RcodeServerFailure
 		return r.ResponseWriter.WriteMsg(res)
 	}
@@ -103,7 +104,7 @@ func (r *ResponseWriter) WriteMsg(res *dns.Msg) error {
 
 // Write implements the dns.ResponseWriter interface.
 func (r *ResponseWriter) Write(buf []byte) (int, error) {
-	log.Printf("[WARNING] DNS64 called with Write: not performing DNS64")
+	log.Warning("[WARNING] DNS64 called with Write: not performing DNS64")
 	n, err := r.ResponseWriter.Write(buf)
 	return n, err
 }
@@ -141,3 +142,13 @@ func To6(prefix *net.IPNet, addr net.IP) (net.IP, error) {
 
 	return v6, nil
 }
+
+// hasAAAA checks if AAAA records exists in dns.Msg
+func hasAAAA(res *dns.Msg) bool {
+	for _, a := range res.Answer {
+		if a.Header().Rrtype == dns.TypeAAAA {
+			return true
+		}
+	}
+	return false
+}

setup.go

@@ -6,11 +6,14 @@ import (
 	"github.com/coredns/coredns/core/dnsserver"
 	"github.com/coredns/coredns/plugin"
 	"github.com/coredns/coredns/plugin/pkg/dnsutil"
+	clog "github.com/coredns/coredns/plugin/pkg/log"
 	"github.com/coredns/coredns/plugin/proxy"
 
 	"github.com/mholt/caddy"
 )
 
+var log = clog.NewWithPlugin("dns64")
+
 func init() {
 	caddy.RegisterPlugin("dns64", caddy.Plugin{
 		ServerType: "dns",
@@ -57,7 +60,8 @@ func dns64Parse(c *caddy.Controller) (proxy.Proxy, *net.IPNet, error) {
 				if !c.NextArg() {
 					return prxy, pref, c.ArgErr()
 				}
-				_, pref, err := net.ParseCIDR(c.Val())
+				var err error
+				_, pref, err = net.ParseCIDR(c.Val())
 
 				// test for valid prefix
 				n, total := pref.Mask.Size()

setup_test.go

@@ -10,58 +10,68 @@ func TestSetupDns64(t *testing.T) {
 	tests := []struct {
 		inputUpstreams string
 		shouldErr      bool
+		prefix         string
 	}{
 		{
 			`dns64`,
 			false,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 {
     upstream 8.8.8.8
 }`,
 			false,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 {
     prefix 64:ff9b::/96
 }`,
 			false,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 {
     prefix 64:ff9b::/32
 }`,
 			false,
+			"64:ff9b::/32",
 		},
 		{
 			`dns64 {
     prefix 64:ff9b::/52
 }`,
 			true,
+			"64:ff9b::/52",
 		},
 		{
 			`dns64 {
     prefix 64:ff9b::/104
 }`,
 			true,
+			"64:ff9b::/104",
 		},
 		{
 			`dns64 {
     prefix 8.8.8.8/24
 }`,
 			true,
+			"8.8.9.9/24",
 		},
 		{
 			`dns64 {
     upstream 8.8.8.8 8.8.4.4
 }`,
 			false,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 {
     upstream some_not_useable_domain
 }`,
 			true,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 {
@@ -69,6 +79,23 @@ func TestSetupDns64(t *testing.T) {
     upstream 8.8.8.8
 }`,
 			false,
+			"64:ff9b::/96",
+		},
+		{
+			`dns64 {
+    prefix 2002:ac12:b083::/96
+    upstream 8.8.8.8
+}`,
+			false,
+			"2002:ac12:b083::/96",
+		},
+		{
+			`dns64 {
+    prefix 2002:c0a8:a88a::/48
+    upstream 8.8.8.8
+}`,
+			false,
+			"2002:c0a8:a88a::/48",
 		},
 		{
 			`dns64 foobar {
@@ -76,24 +103,32 @@ func TestSetupDns64(t *testing.T) {
     upstream 8.8.8.8
 }`,
 			true,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 foobar`,
 			true,
+			"64:ff9b::/96",
 		},
 		{
 			`dns64 {
     foobar
 }`,
 			true,
+			"64:ff9b::/96",
 		},
 	}
 
 	for i, test := range tests {
 		c := caddy.NewTestController("dns", test.inputUpstreams)
-		_, _, err := dns64Parse(c)
+		_, pref, err := dns64Parse(c)
 		if (err != nil) != test.shouldErr {
 			t.Errorf("Test %d expected %v error, got %v for %s", i+1, test.shouldErr, err, test.inputUpstreams)
 		}
+		if err == nil {
+			if pref.String() != test.prefix {
+				t.Errorf("Test %d expected prefix %s, got %v", i+1, test.prefix, pref.String())
+			}
+		}
 	}
 }