bgp: implement routing policies for redistributed routes

Add the capability to filter and/or modify redistributed routes.
Routing policy application is performed on the same thread pool used
by neighbor import/export policies.

Signed-off-by: Renato Westphal <[email protected]>

holo-bgp/src/events.rs

@@ -318,7 +318,7 @@ fn process_nbr_reach_prefixes<A>(
         .unwrap_or(&nbr.config.apply_policy);
 
     // Enqueue import policy application.
-    let rpinfo = RoutePolicyInfo::new(origin, attrs, route_type);
+    let rpinfo = RoutePolicyInfo::new(origin, route_type, None, None, attrs);
     let msg = PolicyApplyMsg::Neighbor {
         policy_type: PolicyType::Import,
         nbr_addr: nbr.remote_addr,
@@ -637,6 +637,49 @@ fn attrs_tx_update<A>(
     A::nexthop_tx_change(nbr, local, &mut attrs.base);
 }
 
+// ===== redistribute policy import result =====
+
+pub(crate) fn process_redistribute_policy_import<A>(
+    instance: &mut InstanceUpView<'_>,
+    prefix: IpNetwork,
+    result: PolicyResult<RoutePolicyInfo>,
+) -> Result<(), Error>
+where
+    A: AddressFamily,
+{
+    let rib = &mut instance.state.rib;
+    let table = A::table(&mut rib.tables);
+    let prefix = A::IpNetwork::get(prefix).unwrap();
+
+    match result {
+        PolicyResult::Accept(rpinfo) => {
+            // Get prefix RIB entry.
+            let dest = table.prefixes.entry(prefix).or_default();
+
+            // Update redistributed route in the RIB.
+            let route_attrs = rib.attr_sets.get_route_attr_sets(&rpinfo.attrs);
+            let route = Route::new(
+                rpinfo.origin,
+                route_attrs.clone(),
+                RouteType::Internal,
+            );
+            dest.redistribute = Some(Box::new(route));
+        }
+        PolicyResult::Reject => {
+            // Remove redistributed route from the RIB.
+            if let Some(dest) = table.prefixes.get_mut(&prefix) {
+                dest.redistribute = None;
+            }
+        }
+    }
+
+    // Enqueue prefix and schedule the BGP Decision Process.
+    table.queued_prefixes.insert(prefix);
+    instance.state.schedule_decision_process(instance.tx);
+
+    Ok(())
+}
+
 // ===== BGP decision process =====
 
 pub(crate) fn decision_process<A>(

holo-bgp/src/instance.rs

@@ -544,6 +544,22 @@ fn process_protocol_msg(
                     )?
                 }
             },
+            PolicyResultMsg::Redistribute {
+                afi_safi,
+                prefix,
+                result,
+            } => match afi_safi {
+                AfiSafi::Ipv4Unicast => {
+                    events::process_redistribute_policy_import::<Ipv4Unicast>(
+                        instance, prefix, result,
+                    )?
+                }
+                AfiSafi::Ipv6Unicast => {
+                    events::process_redistribute_policy_import::<Ipv6Unicast>(
+                        instance, prefix, result,
+                    )?
+                }
+            },
         },
         // Decision process.
         ProtocolInputMsg::TriggerDecisionProcess(_) => {

holo-bgp/src/lib.rs

@@ -8,7 +8,7 @@
     feature = "testing",
     allow(dead_code, unused_variables, unused_imports)
 )]
-#![feature(let_chains, lazy_cell)]
+#![feature(if_let_guard, let_chains, lazy_cell)]
 
 pub mod af;
 pub mod debug;