Changes after review feedback.

3 files changed, 157 insertions, 14 deletions

diff --git a/src/gnunet/enums/gns.go b/src/gnunet/enums/gns.go
index d5b1f7a..1d45fff 100644
--- a/src/gnunet/enums/gns.go
+++ b/src/gnunet/enums/gns.go
@@ -4,6 +4,11 @@ package enums
 var (
         GNS_MAX_BLOCK_SIZE = (63 * 1024) // Maximum size of a value that can be stored in a GNS block.
 
+        // GNS record flags
+        GNS_FLAG_PRIVATE = 2
+        GNS_FLAGS_EXPREL = 8
+        GNS_FLAG_SHADOW  = 16
+
         // GNS record types
         GNS_TYPE_ANY                   = 0     // Record type indicating any record/'*'
         GNS_TYPE_DNS_A                 = 1     // [RFC1035] IPv4 Address record
diff --git a/src/gnunet/service/gns/block_handler.go b/src/gnunet/service/gns/block_handler.go
index bf65e95..c3372f2 100644
--- a/src/gnunet/service/gns/block_handler.go
+++ b/src/gnunet/service/gns/block_handler.go
@@ -21,6 +21,7 @@ var (
         ErrInvalidRecordBody = fmt.Errorf("Invalid resource record body")
         ErrInvalidPKEY       = fmt.Errorf("Invalid PKEY resource record")
         ErrInvalidCNAME      = fmt.Errorf("Invalid CNAME resource record")
+        ErrInvalidVPN        = fmt.Errorf("Invalid VPN resource record")
         ErrInvalidRecordMix  = fmt.Errorf("Invalid mix of RR types in block")
         ErrBlockHandler      = fmt.Errorf("Internal block handler failure")
 )
@@ -33,6 +34,7 @@ var (
                 enums.GNS_TYPE_BOX:       NewBoxHandler,
                 enums.GNS_TYPE_LEHO:      NewLehoHandler,
                 enums.GNS_TYPE_DNS_CNAME: NewCnameHandler,
+                enums.GNS_TYPE_VPN:       NewVpnHandler,
         }
 )
 
@@ -60,6 +62,9 @@ type BlockHandler interface {
         // Records returns a list of RR of the given types associated with
         // the custom handler
         Records(kind RRTypeList) *GNSRecordSet
+
+        // Name returns the human-readable name of the handler
+        Name() string
 }
 
 //----------------------------------------------------------------------
@@ -71,6 +76,9 @@ type BlockHandler interface {
 // The BlockHandlerList maintains a map of actually instantiated handlers
 // (indexed by record type) and a list of record types (with occurrence
 // count) in the block.
+// The instance is also responsible for any required post-processing like
+// filtering out expired records (and eventually "activating" associated
+// shadow records collect from the same block).
 //----------------------------------------------------------------------
 
 // BlockHandlerList is a list of block handlers instantiated.
@@ -81,15 +89,46 @@ type BlockHandlerList struct {
 
 // NewBlockHandlerList instantiates an a list of active block handlers
 // for a given set of records (GNS block).
-func NewBlockHandlerList(records []*message.GNSResourceRecord, labels []string) (*BlockHandlerList, error) {
+func NewBlockHandlerList(records []*message.GNSResourceRecord, labels []string) (*BlockHandlerList, []*message.GNSResourceRecord, error) {
         // initialize block handler list
         hl := &BlockHandlerList{
                 list:   make(map[int]BlockHandler),
                 counts: make(util.CounterMap),
         }
 
-        // Traverse record list and build list of handler instances
+        // first pass: build list of shadow records in this block
+        shadows := make([]*message.GNSResourceRecord, 0)
+        for _, rec := range records {
+                // filter out shadow records...
+                if (int(rec.Flags) & enums.GNS_FLAG_SHADOW) != 0 {
+                        shadows = append(shadows, rec)
+                }
+        }
+        // second pass: normalize block by filtering out expired records (and
+        // replacing them with shadow records if available
+        active := make([]*message.GNSResourceRecord, 0)
         for _, rec := range records {
+                // don't process shadow records again
+                if (int(rec.Flags) & enums.GNS_FLAG_SHADOW) != 0 {
+                        continue
+                }
+                // check for expired record
+                if rec.Expires.Expired() {
+                        // do we have an associated shadow record?
+                        for _, shadow := range shadows {
+                                if shadow.Type == rec.Type && !shadow.Expires.Expired() {
+                                        // deliver un-expired shadow record instead.
+                                        shadow.Flags &^= uint32(enums.GNS_FLAG_SHADOW)
+                                        active = append(active, shadow)
+                                }
+                        }
+                } else {
+                        active = append(active, rec)
+                }
+        }
+
+        // Third pass: Traverse active list and build list of handler instances.
+        for _, rec := range active {
                 // update counter map
                 rrType := int(rec.Type)
                 hl.counts.Add(rrType)
@@ -104,13 +143,13 @@ func NewBlockHandlerList(records []*message.GNSResourceRecord, labels []string)
                         if hdlr, ok = hl.list[rrType]; ok {
                                 // add record to existing handler
                                 if err = hdlr.AddRecord(rec, labels); err != nil {
-                                        return nil, err
+                                        return nil, active, err
                                 }
                                 continue
                         }
                         // create a new handler instance
                         if hdlr, err = creat(rec, labels); err != nil {
-                                return nil, err
+                                return nil, active, err
                         }
                         // store handler in list
                         hl.list[rrType] = hdlr
@@ -121,11 +160,12 @@ func NewBlockHandlerList(records []*message.GNSResourceRecord, labels []string)
         // all the other records of varying type
         for _, hdlr := range hl.list {
                 if !hdlr.Coexist(hl.counts) {
-                        return nil, ErrInvalidRecordMix
+                        logger.Printf(logger.ERROR, "[gns] %s.Coexist() failed!\n", hdlr.Name())
+                        return nil, active, ErrInvalidRecordMix
                 }
         }
         // return assembled handler list
-        return hl, nil
+        return hl, active, nil
 }
 
 // GetHandler returns a BlockHandler for the given key. If no block handler exists
@@ -139,6 +179,12 @@ func (hl *BlockHandlerList) GetHandler(t int) BlockHandler {
         return nil
 }
 
+// FinalizeRecord post-processes records
+func (hl *BlockHandlerList) FinalizeRecord(rec *message.GNSResourceRecord) *message.GNSResourceRecord {
+        // no implementation yet
+        return rec
+}
+
 //----------------------------------------------------------------------
 // PKEY handler: Only one PKEY as sole record in a block
 //----------------------------------------------------------------------
@@ -198,13 +244,18 @@ func (h *PkeyHandler) Records(kind RRTypeList) *GNSRecordSet {
         return rs
 }
 
+// Name returns the human-readable name of the handler.
+func (h *PkeyHandler) Name() string {
+        return "PKEY_Handler"
+}
+
 //----------------------------------------------------------------------
 // GNS2DNS handler
 //----------------------------------------------------------------------
 
 // Gns2DnsHandler implementing the BlockHandler interface
 type Gns2DnsHandler struct {
-        Name    string                       // DNS query name
+        Query   string                       // DNS query name
         Servers []string                     // DNS servers to ask
         recs    []*message.GNSResourceRecord // list of rersource records
 }
@@ -215,7 +266,7 @@ func NewGns2DnsHandler(rec *message.GNSResourceRecord, labels []string) (BlockHa
                 return nil, ErrInvalidRecordType
         }
         h := &Gns2DnsHandler{
-                Name:    "",
+                Query:   "",
                 Servers: make([]string, 0),
                 recs:    make([]*message.GNSResourceRecord, 0),
         }
@@ -242,9 +293,9 @@ func (h *Gns2DnsHandler) AddRecord(rec *message.GNSResourceRecord, labels []stri
 
         // check if all GNS2DNS records refer to the same query name
         if len(h.Servers) == 0 {
-                h.Name = dnsQuery
+                h.Query = dnsQuery
         }
-        if dnsQuery != h.Name {
+        if dnsQuery != h.Query {
                 return ErrInvalidRecordBody
         }
         h.Servers = append(h.Servers, dnsServer)
@@ -270,6 +321,11 @@ func (h *Gns2DnsHandler) Records(kind RRTypeList) *GNSRecordSet {
         return rs
 }
 
+// Name returns the human-readable name of the handler.
+func (h *Gns2DnsHandler) Name() string {
+        return "GNS2DNS_Handler"
+}
+
 //----------------------------------------------------------------------
 // BOX handler
 //----------------------------------------------------------------------
@@ -342,6 +398,11 @@ func (h *BoxHandler) Records(kind RRTypeList) *GNSRecordSet {
         return rs
 }
 
+// Name returns the human-readable name of the handler.
+func (h *BoxHandler) Name() string {
+        return "BOX_Handler"
+}
+
 //----------------------------------------------------------------------
 // LEHO handler
 //----------------------------------------------------------------------
@@ -386,7 +447,7 @@ func (h *LehoHandler) Coexist(cm util.CounterMap) bool {
         if cm.Num(enums.GNS_TYPE_LEHO) != 1 {
                 return false
         }
-        return cm.Num(enums.GNS_TYPE_DNS_A) == 1 || cm.Num(enums.GNS_TYPE_DNS_AAAA) == 1
+        return (cm.Num(enums.GNS_TYPE_DNS_A) + cm.Num(enums.GNS_TYPE_DNS_AAAA)) > 1
 }
 
 // Records returns a list of RR of the given type associated with this handler
@@ -398,6 +459,11 @@ func (h *LehoHandler) Records(kind RRTypeList) *GNSRecordSet {
         return rs
 }
 
+// Name returns the human-readable name of the handler.
+func (h *LehoHandler) Name() string {
+        return "LEHO_Handler"
+}
+
 //----------------------------------------------------------------------
 // CNAME handler
 //----------------------------------------------------------------------
@@ -450,3 +516,62 @@ func (h *CnameHandler) Records(kind RRTypeList) *GNSRecordSet {
         }
         return rs
 }
+
+// Name returns the human-readable name of the handler.
+func (h *CnameHandler) Name() string {
+        return "CNAME_Handler"
+}
+
+//----------------------------------------------------------------------
+// VPN handler
+//----------------------------------------------------------------------
+
+// VpnHandler implementing the BlockHandler interface
+type VpnHandler struct {
+        rec *message.GNSResourceRecord
+}
+
+// NewVpnHandler returns a new BlockHandler instance
+func NewVpnHandler(rec *message.GNSResourceRecord, labels []string) (BlockHandler, error) {
+        if int(rec.Type) != enums.GNS_TYPE_VPN {
+                return nil, ErrInvalidRecordType
+        }
+        h := &VpnHandler{}
+        if err := h.AddRecord(rec, labels); err != nil {
+                return nil, err
+        }
+        return h, nil
+}
+
+// AddRecord inserts a VPN record into the handler.
+func (h *VpnHandler) AddRecord(rec *message.GNSResourceRecord, labels []string) error {
+        if int(rec.Type) != enums.GNS_TYPE_VPN {
+                return ErrInvalidRecordType
+        }
+        if h.rec != nil {
+                return ErrInvalidVPN
+        }
+        h.rec = rec
+        return nil
+}
+
+// Coexist return a flag indicating how a resource record of a given type
+// is to be treated (see BlockHandler interface)
+func (h *VpnHandler) Coexist(cm util.CounterMap) bool {
+        // anything goes
+        return true
+}
+
+// Records returns a list of RR of the given type associated with this handler
+func (h *VpnHandler) Records(kind RRTypeList) *GNSRecordSet {
+        rs := NewGNSRecordSet()
+        if kind.HasType(enums.GNS_TYPE_VPN) {
+                rs.AddRecord(h.rec)
+        }
+        return rs
+}
+
+// Name returns the human-readable name of the handler.
+func (h *VpnHandler) Name() string {
+        return "VPN_Handler"
+}
diff --git a/src/gnunet/service/gns/module.go b/src/gnunet/service/gns/module.go
index 6732e08..b5583ac 100644
--- a/src/gnunet/service/gns/module.go
+++ b/src/gnunet/service/gns/module.go
@@ -167,7 +167,7 @@ func (gns *GNSModule) ResolveRelative(labels []string, pkey *ed25519.PublicKey,
                 // assemble a list of block handlers for this block: if multiple
                 // block handlers are present, they are consistent with all block
                 // records.
-                if hdlrs, err = NewBlockHandlerList(records, labels[1:]); err != nil {
+                if hdlrs, records, err = NewBlockHandlerList(records, labels[1:]); err != nil {
                         // conflicting block handler records found: terminate with error.
                         // (N.B.: The BlockHandlerList class executes the logic which mix
                         // of resource records in a single block is considered valid.)
@@ -203,7 +203,7 @@ func (gns *GNSModule) ResolveRelative(labels []string, pkey *ed25519.PublicKey,
                         if len(lbls) > 0 {
                                 lbls += "."
                         }
-                        fqdn := lbls + inst.Name
+                        fqdn := lbls + inst.Query
                         if set, err = gns.ResolveDNS(fqdn, inst.Servers, kind, pkey); err != nil {
                                 logger.Println(logger.ERROR, "[gns] GNS2DNS resolution failed.")
                                 return
@@ -243,7 +243,20 @@ func (gns *GNSModule) ResolveRelative(labels []string, pkey *ed25519.PublicKey,
                 // is this the record type we are looking for?
                 if kind.HasType(int(rec.Type)) {
                         // add it to the result
-                        set.AddRecord(rec)
+                        if rec = hdlrs.FinalizeRecord(rec); rec != nil {
+                                set.AddRecord(rec)
+                        }
+                }
+        }
+
+        // if no records of the requested type (either A or AAAA) have been found,
+        // and we have a VPN record, return this instead.
+        if set.Count == 0 && (kind.HasType(enums.GNS_TYPE_DNS_A) || kind.HasType(enums.GNS_TYPE_DNS_AAAA)) {
+                // check for VPN record
+                if hdlr := hdlrs.GetHandler(enums.GNS_TYPE_VPN); hdlr != nil {
+                        // add VPN record to result set
+                        inst := hdlr.(*VpnHandler)
+                        set.AddRecord(inst.rec)
                 }
         }
         return