Prefix Insertion Support in dv

dv/config/config.go

@@ -17,7 +17,7 @@ const CostPfxInfinity = uint64(0xFFFFFFFF)
 
 // NlsrOrigin is the origin to use for local registration.
 const NlsrOrigin = uint64(mgmt.RouteOriginNLSR)
-const PrefixInjOrigin = uint64(mgmt.RouteOriginPrefixInj)
+const PrefixInsOrigin = uint64(mgmt.RouteOriginPrefixIns)
 
 var MulticastStrategy = enc.LOCALHOST.
 	Append(enc.NewGenericComponent("nfd")).
@@ -40,12 +40,12 @@ type Config struct {
 	KeyChainUri string `json:"keychain"`
 	// List of trust anchor full names.
 	TrustAnchors []string `json:"trust_anchors"`
-	// Path to trust schema for prefix injection.
-	PrefixInjectionSchemaPath string `json:"prefix_injection_schema"`
-	// URI specifying KeyChain location for prefix injection verifier.
-	PrefixInjectionKeychainUri string `json:"prefix_injection_keychain"`
-	// List of trust anchor full names for prefix injection.
-	PrefixInjectionTrustAnchors []string `json:"prefix_injection_trust_anchors"`
+	// Path to trust schema for prefix insertion.
+	PrefixInsertionSchemaPath string `json:"prefix_insertion_schema"`
+	// URI specifying KeyChain location for prefix insertion verifier.
+	PrefixInsertionKeychainUri string `json:"prefix_insertion_keychain"`
+	// List of trust anchor full names for prefix insertion.
+	PrefixInsertionTrustAnchors []string `json:"prefix_insertion_trust_anchors"`
 	// List of permanent neighbors.
 	Neighbors []Neighbor `json:"neighbors"`
 
@@ -67,8 +67,8 @@ type Config struct {
 	mgmtPrefix enc.Name
 	// Trust anchor names
 	trustAnchorsN []enc.Name
-	// Prefix Injection trust anchor names
-	prefixInjectionTrustAnchorsN []enc.Name
+	// Prefix Insertion trust anchor names
+	prefixInsertionTrustAnchorsN []enc.Name
 }
 
 type Neighbor struct {
@@ -90,8 +90,8 @@ func DefaultConfig() *Config {
 		AdvertisementSyncInterval_ms: 5000,
 		RouterDeadInterval_ms:        30000,
 		KeyChainUri:                  "undefined",
-		PrefixInjectionSchemaPath:    "deny",
-		PrefixInjectionKeychainUri:   "undefined",
+		PrefixInsertionSchemaPath:    "deny",
+		PrefixInsertionKeychainUri:   "undefined",
 	}
 }
 
@@ -147,13 +147,13 @@ func (c *Config) Parse() (err error) {
 		c.trustAnchorsN = append(c.trustAnchorsN, name)
 	}
 
-	c.prefixInjectionTrustAnchorsN = make([]enc.Name, 0, len(c.PrefixInjectionTrustAnchors))
-	for _, anchor := range c.PrefixInjectionTrustAnchors {
+	c.prefixInsertionTrustAnchorsN = make([]enc.Name, 0, len(c.PrefixInsertionTrustAnchors))
+	for _, anchor := range c.PrefixInsertionTrustAnchors {
 		name, err := enc.NameFromStr(anchor)
 		if err != nil {
 			return err
 		}
-		c.prefixInjectionTrustAnchorsN = append(c.prefixInjectionTrustAnchorsN, name)
+		c.prefixInsertionTrustAnchorsN = append(c.prefixInsertionTrustAnchorsN, name)
 	}
 
 	// Advertisement sync and data prefixes
@@ -226,8 +226,8 @@ func (c *Config) TrustAnchorNames() []enc.Name {
 	return c.trustAnchorsN
 }
 
-func (c *Config) PrefixInjectionTrustAnchorNames() []enc.Name {
-	return c.prefixInjectionTrustAnchorsN
+func (c *Config) PrefixInsertionTrustAnchorNames() []enc.Name {
+	return c.prefixInsertionTrustAnchorsN
 }
 
 func (c *Config) SchemaBytes() []byte {

dv/dv.sample.yml

@@ -12,16 +12,16 @@ dv:
   trust_anchors:
     - "/ndn/KEY/%27%C4%B2%2A%9F%7B%81%27/ndn/v=1651246789556"
 
-  # [optional] Trust schema for prefix injection
+  # [optional] Trust schema for prefix insertion
   # - If "insecure" is specified, security is disabled
-  # - If "deny" is specified, the prefix injection handler will be turned off
+  # - If "deny" is specified, the prefix insertion handler will be turned off
   # - Example: /absolute/path/to/schema.tlv
-  prefix_injection_schema: "insecure"
-  # [optional] Keychain URI for prefix injection
-  prefix_injection_keychain: "insecure"
-  # [optional] List of full names of all prefix injection trust anchors
+  prefix_insertion_schema: "insecure"
+  # [optional] Keychain URI for prefix insertion
+  prefix_insertion_keychain: "insecure"
+  # [optional] List of full names of all prefix insertion trust anchors
   # - There should be at least one trust anchor if the schema is not "insecure" or "deny"
-  prefix_injection_trust_anchors: []
+  prefix_insertion_trust_anchors: []
 
   # [optional] List of permanent neighbors
   # Example with all options:

dv/dv/injection.go → dv/dv/insertion.go

@@ -15,11 +15,11 @@ import (
 	"github.com/named-data/ndnd/std/types/optional"
 )
 
-func (dv *Router) onInjection(args ndn.InterestHandlerArgs) {
+func (dv *Router) onInsertion(args ndn.InterestHandlerArgs) {
 	resError := &mgmt.ControlResponse{
 		Val: &mgmt.ControlResponseVal{
 			StatusCode: 400,
-			StatusText: "Failed to execute prefix injection",
+			StatusText: "Failed to execute prefix insertion",
 			Params:     nil,
 		},
 	}
@@ -35,39 +35,39 @@ func (dv *Router) onInjection(args ndn.InterestHandlerArgs) {
 			res.Encode(),
 			signer)
 		if err != nil {
-			log.Warn(dv, "Failed to make inject response Data", "err", err)
+			log.Warn(dv, "Failed to make Prefix Insertion response Data", "err", err)
 			return
 		}
 		args.Reply(data.Wire)
 	}
 
 	// If there is no incoming face ID, we can't use this
 	if !args.IncomingFaceId.IsSet() {
-		log.Warn(dv, "Received Prefix Injection with no incoming face ID, ignoring")
+		log.Warn(dv, "Received Prefix Insertion with no incoming face ID, ignoring")
 		reply(resError)
 		return
 	}
 
 	// Check if app param is present
 	if args.Interest.AppParam() == nil {
-		log.Warn(dv, "Received Prefix Injection with no AppParam, ignoring")
+		log.Warn(dv, "Received Prefix Insertion with no AppParam, ignoring")
 		reply(resError)
 		return
 	}
 
-	paParams, err := tlv.ParsePrefixInjection(enc.NewWireView(args.Interest.AppParam()), true)
+	paParams, err := tlv.ParsePrefixInsertion(enc.NewWireView(args.Interest.AppParam()), true)
 	if err != nil {
-		log.Warn(dv, "Failed to parse Prefix Injection AppParam", "err", err)
+		log.Warn(dv, "Failed to parse Prefix Insertion AppParam", "err", err)
 		reply(resError)
 		return
 	}
 
-	// Decode Prefix Injection Object
+	// Decode Prefix Announcement Object
 	dCtx := spec.DataParsingContext{}
 	dCtx.Init()
 	data, err := dCtx.Parse(enc.NewBufferView(paParams.ObjectWire), true)
 	if err != nil {
-		log.Warn(dv, "Failed to parse Prefix Injection inner data", "err", err)
+		log.Warn(dv, "Failed to parse Prefix Insertion inner data", "err", err)
 		reply(resError)
 		return
 	}
@@ -93,26 +93,26 @@ func (dv *Router) onInjection(args ndn.InterestHandlerArgs) {
 	}
 
 	// Validate signature
-	dv.prefixInjectionClient.ValidateExt(ndn.ValidateExtArgs{
+	dv.prefixInsertionClient.ValidateExt(ndn.ValidateExtArgs{
 		Data:       data,
 		SigCovered: sigCov,
 		Fetch: optional.Some(func(name enc.Name, config *ndn.InterestConfig, callback ndn.ExpressCallbackFunc) {
 			for _, certCallback := range stapledCertCallbacks {
 				if certCallback.Data.Name().Equal(name) {
-					dv.prefixInjectionClient.Engine().Post(func() {
+					dv.prefixInsertionClient.Engine().Post(func() {
 						callback(certCallback)
 					})
 					return
 				}
 			}
 
 			config.NextHopId = optional.None[uint64]()
-			dv.prefixInjectionClient.ExpressR(ndn.ExpressRArgs{
+			dv.prefixInsertionClient.ExpressR(ndn.ExpressRArgs{
 				Name:     name,
 				Config:   config,
 				Retries:  3,
 				Callback: callback,
-				TryStore: dv.prefixInjectionClient.Store(),
+				TryStore: dv.prefixInsertionClient.Store(),
 			})
 		}),
 		Callback: func(valid bool, err error) {
@@ -122,54 +122,124 @@ func (dv *Router) onInjection(args ndn.InterestHandlerArgs) {
 				return
 			}
 
-			res := dv.onPrefixInjectionObject(data, args.IncomingFaceId.Unwrap())
+			res := dv.onPrefixInsertionObject(data, args.IncomingFaceId.Unwrap())
 			reply(res)
 		},
 	})
 }
 
-func (dv *Router) onPrefixInjectionObject(object ndn.Data, faceId uint64) *mgmt.ControlResponse {
+func (dv *Router) onPrefixInsertionObject(object ndn.Data, faceId uint64) *mgmt.ControlResponse {
 	resError := &mgmt.ControlResponse{
 		Val: &mgmt.ControlResponseVal{
 			StatusCode: 400,
-			StatusText: "Failed to execute prefix injection",
+			StatusText: "Failed to execute prefix insertion",
 			Params:     nil,
 		},
 	}
 
-	if contentType, set := object.ContentType().Get(); !set || contentType != ndn.ContentTypePrefixInjection {
-		log.Warn(dv, "Prefix Injection Object does not have the correct content type",
+	if contentType, set := object.ContentType().Get(); !set || contentType != ndn.ContentTypePrefixAnnouncement {
+		log.Warn(dv, "Prefix Announcement Object does not have the correct content type",
 			"contentType", object.ContentType())
 		return resError
 	}
 
-	// TODO: reject already seen injections (using version)
 	var prefix enc.Name
 	found := false
+	var version uint64
 
 	for i, c := range object.Name() {
-		if c.IsKeyword("inject") {
+		if c.IsKeyword("PA") {
+			if len(object.Name()) != i+3 ||
+				!object.Name().At(i+1).IsVersion() ||
+				!object.Name().At(i+2).IsSegment() ||
+				object.Name().At(i+2).NumberVal() != 0 {
+				found = false
+				break
+			}
+
 			prefix = object.Name().Prefix(i)
+			version = object.Name().At(i + 1).NumberVal()
 			found = true
 			break
 		}
 	}
 
 	if !found {
-		log.Warn(dv, "Prefix Injection Object name not in correct format", "name", object.Name())
+		log.Warn(dv, "Prefix Announcement Object name not in correct format", "name", object.Name())
 		return resError
 	}
 
+	// Check if we've seen a newer version of this prefix insertion
+	prefixHash := prefix.Hash()
+	if lastVersion, exists := dv.seenPrefixVersions[prefixHash]; exists && lastVersion >= version {
+		log.Info(dv, "Rejecting older or duplicate prefix insertion",
+			"prefix", prefix,
+			"version", version,
+			"lastVersion", lastVersion)
+		return &mgmt.ControlResponse{
+			Val: &mgmt.ControlResponseVal{
+				StatusCode: 409,
+				StatusText: "Older or duplicate prefix insertion version",
+				Params:     nil,
+			},
+		}
+	}
+
+	dv.seenPrefixVersions[prefixHash] = version
+
 	piWire := object.Content()
-	params, err := tlv.ParsePrefixInjectionInnerContent(enc.NewWireView(piWire), true)
+	params, err := tlv.ParsePrefixInsertionInnerContent(enc.NewWireView(piWire), true)
 	if err != nil {
-		log.Warn(dv, "Failed to parse prefix injection object", "err", err)
+		log.Warn(dv, "Failed to parse prefix announcement object", "err", err)
 		return resError
 	}
 
+	// Check validity period if it exists
+	expirationPeriod := params.ExpirationPeriod
+	if params.ValidityPeriod != nil {
+		const timeFormat = "20060102T150405" // Format for YYYYMMDDThhmmss
+		notBefore, err := time.Parse(timeFormat, params.ValidityPeriod.NotBefore)
+		if err != nil {
+			log.Warn(dv, "Failed to parse NotBefore time", "err", err, "value", params.ValidityPeriod.NotBefore)
+			return resError
+		}
+		notAfter, err := time.Parse(timeFormat, params.ValidityPeriod.NotAfter)
+		if err != nil {
+			log.Warn(dv, "Failed to parse NotAfter time", "err", err, "value", params.ValidityPeriod.NotAfter)
+			return resError
+		}
+
+		now := time.Now().UTC()
+		if now.Before(notBefore) || now.After(notAfter) {
+			log.Info(dv, "Prefix insertion outside validity period",
+				"prefix", prefix,
+				"notBefore", notBefore,
+				"notAfter", notAfter,
+				"now", now)
+			return &mgmt.ControlResponse{
+				Val: &mgmt.ControlResponseVal{
+					StatusCode: 403,
+					StatusText: "Prefix insertion outside validity period",
+					Params:     nil,
+				},
+			}
+		}
+
+		// Adjust expiration to be the minimum of the current expiration and notAfter - now
+		if expirationPeriod > 0 {
+			timeUntilExpiry := notAfter.Sub(now)
+			if timeUntilExpiry < time.Duration(expirationPeriod)*time.Millisecond {
+				expirationPeriod = uint64(timeUntilExpiry.Milliseconds())
+				log.Debug(dv, "Adjusted expiration period based on validity period",
+					"prefix", prefix,
+					"newExpiration", expirationPeriod)
+			}
+		}
+	}
+
 	var shouldRemove bool
 	var cost uint64
-	if params.ExpirationPeriod == 0 {
+	if expirationPeriod == 0 {
 		// Remove the RIB entry
 		shouldRemove = true
 		cost = config.CostInfinity
@@ -183,6 +253,9 @@ func (dv *Router) onPrefixInjectionObject(object ndn.Data, faceId uint64) *mgmt.
 		}
 	}
 
+	// TODO: use the expiration period to set the lifetime of the RIB and prefix table entry
+	// (Currently the prefix table does not have a lifetime)
+
 	if shouldRemove {
 		dv.nfdc.Exec(nfdc.NfdMgmtCmd{
 			Module: "rib",
@@ -200,7 +273,7 @@ func (dv *Router) onPrefixInjectionObject(object ndn.Data, faceId uint64) *mgmt.
 			Args: &mgmt.ControlArgs{
 				Name:   prefix,
 				FaceId: optional.Some(faceId),
-				Origin: optional.Some(config.PrefixInjOrigin),
+				Origin: optional.Some(config.PrefixInsOrigin),
 				Cost:   optional.Some(cost),
 			},
 			Retries: 3,
@@ -219,11 +292,11 @@ func (dv *Router) onPrefixInjectionObject(object ndn.Data, faceId uint64) *mgmt.
 	return &mgmt.ControlResponse{
 		Val: &mgmt.ControlResponseVal{
 			StatusCode: 200,
-			StatusText: "Prefix Injection command successful",
+			StatusText: "Prefix Insertion command successful",
 			Params: &mgmt.ControlArgs{
 				Name:   prefix,
 				FaceId: optional.Some(faceId),
-				Origin: optional.Some(config.PrefixInjOrigin),
+				Origin: optional.Some(config.PrefixInsOrigin),
 				Cost:   optional.Some(cost),
 			},
 		},