Judge every route a peer announces: import policy, prefix limit, hold-down

A configured peer could announce any prefix with any path, in any
number, and all of it was stored and could be chosen as best. Each
peer now has an import policy, and every route goes through it before
it reaches the routing table.

Checks that hold for any peer unless turned off for it:
- no prefixes that are not routed on the Internet (private, loopback,
  link-local, documentation, multicast, reserved; for IPv6, anything
  outside global unicast);
- nothing longer than /24 or /48, no default route, nothing shorter
  than /8 or /16;
- no reserved, private or documentation AS number in the path;
- a path that begins with the peer's own AS (turned off for a route
  server), and of at most 64 AS numbers.

Always: a route with our own AS number in its path is refused. RFC 4271
requires this loop check and it was missing.

Per peer, if configured: the prefixes it may announce, each with an
optional longest more-specific, and the AS numbers its routes may
originate from. This is the list generated from the routing registries.

max_prefixes limits how many routes a peer may have. One more ends the
session with Cease / Maximum Number of Prefixes Reached, and the peer
is kept down for hold_down_seconds (ten minutes unless set): its
connections are not taken and it is not dialled. Refused routes do not
count towards the limit.

A refused route is withdrawn rather than ignored, so that it replaces
whatever the peer had announced for it before.

On a session with two-octet AS numbers the path is judged with its
AS4_PATH merged in, so that the real AS numbers are what is checked.

Peers that are not configured (accept_unconfigured_peers, for test
networks) get a policy that takes everything but loops.

Refusals are counted in bgp_routes_rejected_total by reason. The status
page and /api/peers show, for each session, how many routes the peer
has and how many were refused. The server warns at startup about peers
with no limit.

The prefix check costs about 4 ns a route with the default policy; the
end-to-end benchmark is unchanged.

Also: the benchmark's server AS is one that is in none of its generated
paths, and a table test that depended on the hasher's seed is fixed.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

crates/server/src/session.rs

@@ -7,7 +7,7 @@
 
 use std::collections::HashMap;
 use std::net::{IpAddr, SocketAddr};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, SystemTime};
 
@@ -61,6 +61,36 @@ pub struct ConfiguredPeer {
     pub remote_asn: u32,
 }
 
+/// Counts kept by a session as it goes, for whoever wants to look.
+#[derive(Debug, Default)]
+pub struct SessionCounters {
+    /// Routes of the peer's that are in the routing table now.
+    routes: AtomicU64,
+    /// Routes the peer announced that its import policy refused, since the
+    /// session came up.
+    rejected: AtomicU64,
+}
+
+impl SessionCounters {
+    pub fn routes(&self) -> u64 {
+        self.routes.load(Ordering::Relaxed)
+    }
+
+    pub fn rejected(&self) -> u64 {
+        self.rejected.load(Ordering::Relaxed)
+    }
+
+    /// Notes what one UPDATE did, and returns how many routes the peer has
+    /// in the table after it.
+    pub(crate) fn note(&self, added: usize, removed: usize, rejected: usize) -> u64 {
+        self.rejected.fetch_add(rejected as u64, Ordering::Relaxed);
+        // Only the session writes this, so the two steps are not a race.
+        let routes = (self.routes() + added as u64).saturating_sub(removed as u64);
+        self.routes.store(routes, Ordering::Relaxed);
+        routes
+    }
+}
+
 /// Handle to one established session. Cloning is cheap.
 #[derive(Debug, Clone)]
 pub struct SessionHandle {
@@ -89,6 +119,8 @@ pub struct SessionHandle {
     /// The peer's number in the routing table: what its routes there are
     /// marked with.
     pub rib_peer: PeerIndex,
+    /// How many routes the peer has, and how many were refused.
+    pub counters: Arc<SessionCounters>,
     outbound: mpsc::Sender<Message>,
 }
 
@@ -118,6 +150,7 @@ impl SessionHandle {
             add_path_receive: negotiated.add_path_receive.clone(),
             add_path_send: negotiated.add_path_send.clone(),
             rib_peer,
+            counters: Arc::default(),
             outbound,
         }
     }