bump gdns:20171201-c43c55c

README.md

@@ -3,8 +3,8 @@
 
 ### Thanks
 - https://github.com/fardog/secureoperator
-- https://developers.google.com/speed/public-dns/docs/dns-over-https
 - https://github.com/jackyyf/go-shadowsocks2
+- https://developers.google.com/speed/public-dns/docs/dns-over-https
 
 ### Docker
 - https://hub.docker.com/r/chenhw2/google-https-dns

gdns/dns_client.go

@@ -135,8 +135,8 @@ type SimpleDNSClient struct {
 	cache   *dnsCache
 }
 
-// LookupIP looks up a single IP against the client's configured DNS servers,
-// returning a value from cache if its still valid.
+// LookupIP does a single lookup against the client's configured DNS servers,
+// returning a value from cache if its still valid. It looks at A records only.
 func (c *SimpleDNSClient) LookupIP(host string) ([]net.IP, error) {
 	// see if cache has the entry; if it's still good, return it
 	entry, ok := c.cache.Get(host)
@@ -166,12 +166,14 @@ func (c *SimpleDNSClient) LookupIP(host string) ([]net.IP, error) {
 	for _, ans := range r.Answer {
 		h := ans.Header()
 
-		if shortestTTL == 0 || h.Ttl < shortestTTL {
-			shortestTTL = h.Ttl
-		}
-
 		if t, ok := ans.(*dns.A); ok {
 			rec.ips = append(rec.ips, t.A)
+
+			// if the TTL of this record is the shortest or first seen, use it
+			// as the cache record TTL
+			if shortestTTL == 0 || h.Ttl < shortestTTL {
+				shortestTTL = h.Ttl
+			}
 		}
 	}
 

gdns/handler.go

@@ -60,6 +60,11 @@ func (h *Handler) Handle(w dns.ResponseWriter, r *dns.Msg) {
 		})
 	}
 
+	// Parse google RRs to DNS RRs
+	answers := transformRR(dnsResp.Answer, "answer")
+	authorities := transformRR(dnsResp.Authority, "authority")
+	extras := transformRR(dnsResp.Extra, "extra")
+
 	resp := dns.Msg{
 		MsgHdr: dns.MsgHdr{
 			Id:                 r.Id,
@@ -75,41 +80,29 @@ func (h *Handler) Handle(w dns.ResponseWriter, r *dns.Msg) {
 		},
 		Compress: r.Compress,
 		Question: questions,
+		Answer:   answers,
+		Ns:       authorities,
+		Extra:    extras,
 	}
 
-	// Parse google RRs to DNS RRs
-	for _, a := range dnsResp.Answer {
-		rr, err := a.RR()
-		if err != nil {
-			glog.V(LERROR).Infof("%+v", err)
-		} else {
-			resp.Answer = append(resp.Answer, rr)
-		}
+	// glog.V(LINFO).Infof("%+v", resp)
+	// Write the response
+	if err = w.WriteMsg(&resp); err != nil {
+		glog.V(LERROR).Infoln("provider failed", err)
 	}
+}
 
-	// Parse google RRs to DNS RRs
-	for _, ns := range dnsResp.Authority {
-		rr, err := ns.RR()
-		if err != nil {
-			glog.V(LERROR).Infof("%+v", err)
-		} else {
-			resp.Ns = append(resp.Answer, rr)
-		}
-	}
+// for a given []DNSRR, transform to dns.RR, logging if any errors occur
+func transformRR(rrs []DNSRR, logType string) []dns.RR {
+	var t []dns.RR
 
-	// Parse google RRs to DNS RRs
-	for _, extra := range dnsResp.Extra {
-		rr, err := extra.RR()
-		if err != nil {
-			glog.V(LERROR).Infof("%+v", err)
+	for _, r := range rrs {
+		if rr, err := r.DNSRR(); err != nil {
+			glog.V(LERROR).Infoln("unable to translate record rr", logType, r, err)
 		} else {
-			resp.Extra = append(resp.Answer, rr)
+			t = append(t, rr)
 		}
 	}
 
-	// glog.V(LINFO).Infof("%+v", resp)
-	// Write the response
-	if err = w.WriteMsg(&resp); err != nil {
-		glog.V(LERROR).Infoln("provider failed", err)
-	}
+	return t
 }

gdns/provider.go

@@ -18,13 +18,27 @@ type DNSRR struct {
 	Data string `json:"data,omitempty"`
 }
 
-// RR transforms a DNSRR to a dns.RR.
-func (r DNSRR) RR() (dns.RR, error) {
+// RR is deprecated as of 2.2.0, use DNSRR instead
+func (r DNSRR) RR() dns.RR {
+	hdr := dns.RR_Header{Name: r.Name, Rrtype: r.Type, Class: dns.ClassINET, Ttl: r.TTL}
+	str := hdr.String() + r.Data
+	rr, _ := dns.NewRR(str)
+	return rr
+}
+
+// DNSRR transforms a DNSRR to a dns.RR; returns `nil` if an RR could not be
+// created from the record.
+func (r DNSRR) DNSRR() (dns.RR, error) {
 	hdr := dns.RR_Header{Name: r.Name, Rrtype: r.Type, Class: dns.ClassINET, Ttl: r.TTL}
 	str := hdr.String() + r.Data
 	return dns.NewRR(str)
 }
 
+func (r DNSRR) String() string {
+	hdr := dns.RR_Header{Name: r.Name, Rrtype: r.Type, Class: dns.ClassINET, Ttl: r.TTL}
+	return hdr.String()
+}
+
 // DNSResponse represents a complete DNS server response, to be served by the
 // DNS server handler.
 type DNSResponse struct {

gdns/provider_google.go

@@ -79,12 +79,12 @@ func (rs GDNSRRs) DNSRRs() (rrs []DNSRR) {
 
 // GDNSResponse represents a response from the Google DNS-over-HTTPS servers
 type GDNSResponse struct {
-	Status           int32         `json:"Status,omitempty"`
-	TC               bool          `json:"TC,omitempty"`
-	RD               bool          `json:"RD,omitempty"`
-	RA               bool          `json:"RA,omitempty"`
-	AD               bool          `json:"AD,omitempty"`
-	CD               bool          `json:"CD,omitempty"`
+	Status           int32         `json:"Status"`
+	TC               bool          `json:"TC"`
+	RD               bool          `json:"RD"`
+	RA               bool          `json:"RA"`
+	AD               bool          `json:"AD"`
+	CD               bool          `json:"CD"`
 	Question         GDNSQuestions `json:"Question,omitempty"`
 	Answer           GDNSRRs       `json:"Answer,omitempty"`
 	Authority        GDNSRRs       `json:"Authority,omitempty"`

gdns/provider_test.go

@@ -17,9 +17,9 @@ func TestDNSRRTypeA(t *testing.T) {
 		Data: "10.10.10.1",
 	}
 
-	rr, err := r.RR()
+	rr, err := r.DNSRR()
 	if err != nil {
-		t.Errorf("Parse RR: %v", err)
+		t.Fatal(err)
 	}
 
 	v, ok := rr.(*dns.A)
@@ -49,9 +49,9 @@ func TestDNSRRTypeMX(t *testing.T) {
 		Data: "10 mail.who.wut.co.jp",
 	}
 
-	rr, err := r.RR()
+	rr, err := r.DNSRR()
 	if err != nil {
-		t.Errorf("Parse RR: %v", err)
+		t.Fatal(err)
 	}
 
 	v, ok := rr.(*dns.MX)
@@ -84,9 +84,9 @@ func TestDNSRRTypeCNAME(t *testing.T) {
 		Data: "omg.wtf.bbq",
 	}
 
-	rr, err := r.RR()
+	rr, err := r.DNSRR()
 	if err != nil {
-		t.Errorf("Parse RR: %v", err)
+		t.Fatal(err)
 	}
 
 	v, ok := rr.(*dns.CNAME)
@@ -116,9 +116,9 @@ func TestDNSRRTypeAAAA(t *testing.T) {
 		Data: "::1",
 	}
 
-	rr, err := r.RR()
+	rr, err := r.DNSRR()
 	if err != nil {
-		t.Errorf("Parse RR: %v", err)
+		t.Fatal(err)
 	}
 
 	v, ok := rr.(*dns.AAAA)