Extended makeDNSReply to PTR replies too

server/dns.go

@@ -10,21 +10,46 @@ const (
 	// downstream to cache results
 )
 
-func makeDNSReply(r *dns.Msg, name string, qtype uint16, addrs []net.IP) *dns.Msg {
+func makeHeader(r *dns.Msg, q *dns.Question) *dns.RR_Header {
+	return &dns.RR_Header{
+		Name: q.Name, Rrtype: q.Qtype,
+		Class: dns.ClassINET, Ttl: localTTL}
+}
+
+func makeReply(r *dns.Msg, as []dns.RR) *dns.Msg {
 	m := new(dns.Msg)
 	m.SetReply(r)
 	m.RecursionAvailable = true
-	hdr := dns.RR_Header{Name: name, Rrtype: qtype, Class: dns.ClassINET, Ttl: localTTL}
+	m.Answer = as
+	return m
+}
+
+func makeAReply(r *dns.Msg, q *dns.Question, addrs []net.IP) *dns.Msg {
+	answers := make([]dns.RR, len(addrs))
+	header := makeHeader(r, q)
+	count := 0
 	for _, addr := range addrs {
-		if qtype == dns.TypeA {
+		switch q.Qtype {
+		case dns.TypeA:
 			if ip4 := addr.To4(); ip4 != nil {
-				m.Answer = append(m.Answer, &dns.A{hdr, addr})
+				answers[count] = &dns.A{*header, addr}
+				count++
 			}
-		} else if qtype == dns.TypeAAAA {
+		case dns.TypeAAAA:
 			if ip4 := addr.To4(); ip4 == nil {
-				m.Answer = append(m.Answer, &dns.AAAA{hdr, addr})
+				answers[count] = &dns.AAAA{*header, addr}
+				count++
 			}
 		}
 	}
-	return m
+	return makeReply(r, answers[:count])
+}
+
+func makePTRReply(r *dns.Msg, q *dns.Question, names []string) *dns.Msg {
+	answers := make([]dns.RR, len(names))
+	header := makeHeader(r, q)
+	for i, name := range names {
+		answers[i] = &dns.PTR{*header, name}
+	}
+	return makeReply(r, answers)
 }

server/mdns_server.go

@@ -43,7 +43,7 @@ func (s *MDNSServer) Start(ifi *net.Interface) error {
 			q := r.Question[0]
 			ip, err := s.zone.MatchLocal(q.Name)
 			if err == nil {
-				m := makeDNSReply(r, q.Name, dns.TypeA, []net.IP{ip})
+				m := makeAReply(r, &q, []net.IP{ip})
 				s.SendResponse(m)
 			} else if s.addrIsLocal(w.RemoteAddr()) {
 				// ignore this - it's our own query received via multicast

server/server.go

@@ -41,7 +41,7 @@ func queryHandler(zone Zone, mdnsClient *MDNSClient) dns.HandlerFunc {
 		if q.Qtype == dns.TypeA {
 			ip, err := zone.MatchLocal(q.Name)
 			if err == nil {
-				m := makeDNSReply(r, q.Name, dns.TypeA, []net.IP{ip})
+				m := makeAReply(r, &q, []net.IP{ip})
 				w.WriteMsg(m)
 			} else {
 				Debug.Printf("Failed lookup for %s; sending mDNS query", q.Name)
@@ -55,7 +55,7 @@ func queryHandler(zone Zone, mdnsClient *MDNSClient) dns.HandlerFunc {
 					}
 					var responseMsg *dns.Msg
 					if len(replies) > 0 {
-						responseMsg = makeDNSReply(r, q.Name, dns.TypeA, replies)
+						responseMsg = makeAReply(r, &q, replies)
 					} else {
 						responseMsg = makeDNSFailResponse(r)
 					}
@@ -84,11 +84,7 @@ func rdnsHandler(zone Zone, mdnsClient *MDNSClient) dns.HandlerFunc {
 				name, err := zone.MatchLocalIP(revIP)
 				if err == nil {
 					Debug.Printf("Found name: %s", name)
-					m := new(dns.Msg)
-					m.SetReply(r)
-					m.RecursionAvailable = true
-					hdr := dns.RR_Header{Name: q.Name, Rrtype: q.Qtype, Class: dns.ClassINET, Ttl: localTTL}
-					m.Answer = []dns.RR{&dns.PTR{hdr, name}}
+					m := makePTRReply(r, &q, []string{name})
 					w.WriteMsg(m)
 				} else {
 					Debug.Printf("Failed lookup for %s; sending mDNS query", q.Name)
@@ -112,7 +108,7 @@ func notUsHandler() dns.HandlerFunc {
 		if q.Qtype == dns.TypeA {
 			addrs, err := net.LookupIP(q.Name)
 			if err == nil {
-				responseMsg = makeDNSReply(r, q.Name, q.Qtype, addrs)
+				responseMsg = makeAReply(r, &q, addrs)
 			} else {
 				responseMsg = makeDNSFailResponse(r)
 				Debug.Print("Failed fallback lookup ", err)