From d6a767f549c152801f753bfba50242b846bec530 Mon Sep 17 00:00:00 2001 From: "jh.gao" Date: Wed, 27 Jun 2018 12:06:41 +0800 Subject: [PATCH 1/3] bugfix: do proxy if no AAAA records found, e.g. only CNAME records --- dns64.go | 19 +++++++++++++++---- setup.go | 3 +++ 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/dns64.go b/dns64.go index d5cee27..4454807 100644 --- a/dns64.go +++ b/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 +} diff --git a/setup.go b/setup.go index 7618f24..097e11e 100644 --- a/setup.go +++ b/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("hosts") + func init() { caddy.RegisterPlugin("dns64", caddy.Plugin{ ServerType: "dns", From 6d3220235323206342f2daa1dc72dab6602d97f1 Mon Sep 17 00:00:00 2001 From: "jh.gao" Date: Wed, 27 Jun 2018 13:14:33 +0800 Subject: [PATCH 2/3] typo fix --- setup.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.go b/setup.go index 097e11e..e011661 100644 --- a/setup.go +++ b/setup.go @@ -12,7 +12,7 @@ import ( "github.com/mholt/caddy" ) -var log = clog.NewWithPlugin("hosts") +var log = clog.NewWithPlugin("dns64") func init() { caddy.RegisterPlugin("dns64", caddy.Plugin{ From e57765b5af9e39d25e005e43871caa702c0edf20 Mon Sep 17 00:00:00 2001 From: "jh.gao" Date: Wed, 27 Jun 2018 17:10:24 +0800 Subject: [PATCH 3/3] bugfix user defined prefix can not setup correctly --- setup.go | 3 ++- setup_test.go | 37 ++++++++++++++++++++++++++++++++++++- 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/setup.go b/setup.go index e011661..eb40307 100644 --- a/setup.go +++ b/setup.go @@ -60,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() diff --git a/setup_test.go b/setup_test.go index b3f5c8d..3acae9b 100644 --- a/setup_test.go +++ b/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()) + } + } } }