1 files changed, 37 insertions, 24 deletions

diff --git a/src/gnunet/service/gns/dns.go b/src/gnunet/service/gns/dns.go
index 2ebe331..fe138b0 100644
--- a/src/gnunet/service/gns/dns.go
+++ b/src/gnunet/service/gns/dns.go
@@ -47,7 +47,7 @@ func DNSNameFromBytes(b []byte, offset int) (int, string) {
 
 // queryDNS resolves a name on a given nameserver and delivers all matching
 // resource record (of type 'kind') to the result channel.
-func queryDNS(id int, name string, server net.IP, kind int, res chan *GNSRecordSet) {
+func queryDNS(id int, name string, server net.IP, kind RRTypeList, res chan *GNSRecordSet) {
         logger.Printf(logger.DBG, "[dns][%d] Starting query for '%s' on '%s'...\n", id, name, server.String())
 
         // assemble query
@@ -91,27 +91,32 @@ func queryDNS(id int, name string, server net.IP, kind int, res chan *GNSRecordS
                 }
                 set := NewGNSRecordSet()
                 for _, record := range in.Answer {
-                        // create a new GNS resource record
-                        rr := new(message.GNSResourceRecord)
-                        rr.Expires = util.AbsoluteTimeNever()
-                        rr.Flags = 0
-                        rr.Type = uint32(record.Header().Rrtype)
-                        rr.Size = uint32(record.Header().Rdlength)
-                        rr.Data = make([]byte, rr.Size)
+                        // check if answer record is of requested type
+                        if kind.HasType(int(record.Header().Rrtype)) {
+                                // get wire-format of resource record
+                                buf := make([]byte, 2048)
+                                n, err := dns.PackRR(record, buf, 0, nil, false)
+                                if err != nil {
+                                        logger.Printf(logger.WARN, "[dns][%d] Failed to get RR data for %s\n", id, err.Error())
+                                        continue
+                                }
 
-                        // get wire-format of resource record
-                        buf := make([]byte, 2048)
-                        n, err := dns.PackRR(record, buf, 0, nil, false)
-                        if err != nil {
-                                logger.Printf(logger.WARN, "[dns][%d] Failed to get RR data for %s\n", id, err.Error())
-                                continue
-                        }
-                        if n < int(rr.Size) {
-                                logger.Printf(logger.WARN, "[dns][%d] Nit enough data in RR (%d != %d)\n", id, n, rr.Size)
-                                continue
+                                // create a new GNS resource record
+                                rr := new(message.GNSResourceRecord)
+                                expires := time.Now().Add(time.Duration(record.Header().Ttl) * time.Second)
+                                rr.Expires = util.NewAbsoluteTime(expires)
+                                rr.Flags = 0
+                                rr.Type = uint32(record.Header().Rrtype)
+                                rr.Size = uint32(record.Header().Rdlength)
+                                rr.Data = make([]byte, rr.Size)
+
+                                if n < int(rr.Size) {
+                                        logger.Printf(logger.WARN, "[dns][%d] Not enough data in RR (%d != %d)\n", id, n, rr.Size)
+                                        continue
+                                }
+                                copy(rr.Data, buf[n-int(rr.Size):])
+                                set.AddRecord(rr)
                         }
-                        copy(rr.Data, buf[n-int(rr.Size):])
-                        set.AddRecord(rr)
                 }
                 logger.Printf(logger.WARN, "[dns][%d] %d resource records extracted from response (%d/5).\n", id, set.Count, retry+1)
                 res <- set
@@ -124,7 +129,7 @@ func queryDNS(id int, name string, server net.IP, kind int, res chan *GNSRecordS
 // ResolveDNS resolves a name in DNS. Multiple DNS servers are queried in
 // parallel; the first result delivered by any of the servers is returned
 // as the result list of matching resource records.
-func (gns *GNSModule) ResolveDNS(name string, servers []string, kind int, pkey *ed25519.PublicKey) (set *GNSRecordSet, err error) {
+func (gns *GNSModule) ResolveDNS(name string, servers []string, kind RRTypeList, pkey *ed25519.PublicKey) (set *GNSRecordSet, err error) {
         logger.Printf(logger.DBG, "[dns] Resolution of '%s' starting...\n", name)
 
         // start DNS queries concurrently
@@ -133,20 +138,22 @@ func (gns *GNSModule) ResolveDNS(name string, servers []string, kind int, pkey *
         for idx, srv := range servers {
                 // check if srv is an IPv4/IPv6 address
                 addr := net.ParseIP(srv)
+                logger.Printf(logger.DBG, "ParseIP('%s', len=%d) --> %v\n", srv, len(srv), addr)
                 if addr == nil {
+                        query := NewRRTypeList(enums.GNS_TYPE_DNS_A, enums.GNS_TYPE_DNS_AAAA)
                         // no; resolve server name in GNS
                         if strings.HasSuffix(srv, ".+") {
                                 // resolve server name relative to current zone
                                 zone := util.EncodeBinaryToString(pkey.Bytes())
                                 srv = strings.TrimSuffix(srv, ".+")
-                                set, err = gns.Resolve(srv, pkey, enums.GNS_TYPE_ANY, enums.GNS_LO_DEFAULT)
+                                set, err = gns.Resolve(srv, pkey, query, enums.GNS_LO_DEFAULT)
                                 if err != nil {
                                         logger.Printf(logger.ERROR, "[dns] Can't resolve NS server '%s' in '%s'\n", srv, zone)
                                         continue
                                 }
                         } else {
-                                // resolve absolute GNS name (MUST end in a PKEY)
-                                set, err = gns.Resolve(srv, nil, enums.GNS_TYPE_ANY, enums.GNS_LO_DEFAULT)
+                                // resolve absolute GNS name (name MUST end in a PKEY)
+                                set, err = gns.Resolve(srv, nil, query, enums.GNS_LO_DEFAULT)
                                 if err != nil {
                                         logger.Printf(logger.ERROR, "[dns] Can't resolve NS server '%s'\n", srv)
                                         continue
@@ -158,11 +165,17 @@ func (gns *GNSModule) ResolveDNS(name string, servers []string, kind int, pkey *
                                 switch int(rec.Type) {
                                 case enums.GNS_TYPE_DNS_AAAA:
                                         addr = net.IP(rec.Data)
+                                        // we prefer IPv6
                                         break rec_loop
                                 case enums.GNS_TYPE_DNS_A:
                                         addr = net.IP(rec.Data)
                                 }
                         }
+                        // check if we have an IP address available
+                        if addr == nil {
+                                logger.Printf(logger.WARN, "[dns] No IP address for nameserver in GNS")
+                                continue
+                        }
                 }
                 // query DNS concurrently
                 go queryDNS(idx, name, addr, kind, res)