packet, fib, bench: framing helpers, one netlink reader, a mesh with named phases

A code-quality pass over the periphery. The packet crate frames a
message with `begin_message` and `finish_message`, which the
exporter's hand-written UPDATE header can use instead of a bare type
code, and keeps the NLRI reader and writer together as a pair; the
rule that the body's prefixes are IPv4 unicast lives once; a session
with two-octet AS numbers no longer reserves the attributes' wire
copy it never keeps. The TCP diagnostics read netlink with the
netlink module's own attribute walk and helpers instead of copies of
them. The kernel follower learns what the kernel has in one named
step used at start and on relearning, keeps its batch buffers between
wakes, and builds its task in a constructor. The mesh benchmark,
which had grown six phases in one main, is a `Mesh` with named phases
and a `Receiver`, with one report of the sessions for both deadlines;
the collector capabilities, the KEEPALIVE bytes, the draining of a
session and the printing of a table row are helpers shared by the
benches, the examples and the integration tests. The MRT reader uses
the packet crate's attribute splitter.

Testing: a message framed by hand is the one `to_wire` writes; a
short tcp_info from an old kernel leaves the later fields zero; the
synthetic table is the same every run and every announcement decodes
to itself. The packing example gives the same figures on the RIS dump
before and after. The crates' tests, the integration tests, the
kernel tests and every lab phase pass.

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

crates/integration-tests/src/test_peer.rs

@@ -2,16 +2,55 @@ use std::net::{Ipv4Addr, SocketAddr};
 use std::time::Duration;
 
 use bgp_packet::message::{BGP_HEADER_LEN, Message, NotificationMessage, UpdateMessage};
-use bgp_packet::open::{Capability, OpenMessage, OpenOption};
+use bgp_packet::open::{
+    AddPathEntry, Capability, ExtendedNextHopEntry, OpenMessage, OpenOption, SendReceive,
+};
 use bgp_primitives::constants::{Afi, AfiSafi, Safi};
 use bgp_primitives::parser::ParserContext;
 use bytes::BytesMut;
 use eyre::{Result, bail, eyre};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::tcp::OwnedWriteHalf;
 use tokio::net::{TcpListener, TcpStream};
+use tokio::task::JoinHandle;
 
 use crate::TIMEOUT;
 
+/// The capabilities a route collector offers in its OPEN: four-octet AS
+/// numbers as `asn`, each of `families`, and to be sent several routes
+/// for a prefix (ADD-PATH, RFC 7911) in each of them; with
+/// `ipv4_over_ipv6`, IPv4 routes with IPv6 next hops too (RFC 8950), as a
+/// collector on an IPv6-only session wants. For the tests and benchmarks
+/// that play a collector taking a router's whole table.
+pub fn collector_capabilities(
+    asn: u32,
+    families: &[AfiSafi],
+    ipv4_over_ipv6: bool,
+) -> Vec<Capability> {
+    let mut capabilities = vec![Capability::FourByteAsn { asn }];
+    capabilities.extend(families.iter().copied().map(Capability::multiprotocol));
+    capabilities.push(Capability::AddPath {
+        entries: families
+            .iter()
+            .map(|family| AddPathEntry {
+                afi: family.afi,
+                safi: family.safi,
+                send_recv: SendReceive::Receive,
+            })
+            .collect(),
+    });
+    if ipv4_over_ipv6 {
+        capabilities.push(Capability::ExtendedNextHop {
+            entries: vec![ExtendedNextHopEntry {
+                afi: Afi::IPV4,
+                safi: Safi::UNICAST,
+                nh_afi: Afi::IPV6,
+            }],
+        });
+    }
+    capabilities
+}
+
 /// A minimal BGP peer for use in tests. Connects over TCP and can exchange
 /// framed BGP messages using the `bgp-packet` wire format.
 pub struct TestPeer {
@@ -57,6 +96,32 @@ impl TestPeer {
         self.stream
     }
 
+    /// The connection with a task reading and dropping whatever the server
+    /// sends over it, and the half that is left for writing: for a peer
+    /// that has nothing to hear, as one feeding a table or taking one by
+    /// the megabyte has not, and whose writer must never be held up by
+    /// what it has not read. The task ends with the connection, or when
+    /// its handle is dropped.
+    pub fn drain(self) -> (OwnedWriteHalf, JoinHandle<()>) {
+        let (mut reader, writer) = self.stream.into_split();
+        let sink = tokio::spawn(async move {
+            let mut sink = vec![0u8; 1 << 16];
+            while matches!(reader.read(&mut sink).await, Ok(n) if n > 0) {}
+        });
+        (writer, sink)
+    }
+
+    /// A KEEPALIVE as it goes on the wire, for whoever writes to the
+    /// connection without the framing and has to keep the session alive
+    /// past its hold time.
+    pub fn keepalive_bytes() -> Vec<u8> {
+        let mut wire = BytesMut::new();
+        Message::KeepAlive
+            .to_wire(&ParserContext::default(), &mut wire)
+            .expect("a KEEPALIVE is nineteen octets");
+        wire.to_vec()
+    }
+
     /// Our end of the connection: what the server sees the peer as.
     pub fn local_addr(&self) -> Result<SocketAddr> {
         Ok(self.stream.local_addr()?)
@@ -145,7 +210,9 @@ impl TestPeer {
     pub async fn recv_open(&mut self) -> Result<OpenMessage> {
         match self.recv().await? {
             Message::Open(o) => {
-                // Enable 4-octet ASN parsing if the peer advertised it.
+                // AS numbers are four octets wide only if both sides
+                // offered it (RFC 6793 §4.1): the server's offer is read
+                // here, ours was noted when the OPEN went out.
                 let four_byte = o.options.iter().any(|opt| {
                     matches!(opt, OpenOption::Capabilities(caps)
                         if caps.iter().any(|c| matches!(c, Capability::FourByteAsn { .. })))
@@ -243,7 +310,8 @@ impl TestPeer {
 
     async fn finish_handshake(&mut self) -> Result<OpenMessage> {
         let server_open = self.recv_open().await?;
-        // Expect server KEEPALIVE
+        // The server's KEEPALIVE says it accepted our OPEN; anything else
+        // is its refusal, or a server out of step.
         match self.recv().await? {
             Message::KeepAlive => {}
             other => {
@@ -253,12 +321,15 @@ impl TestPeer {
                 ));
             }
         }
-        // Send our KEEPALIVE
+        // Ours says the same of its OPEN, and the session is established.
         self.send(&Message::KeepAlive).await?;
         Ok(server_open)
     }
 
-    /// Send raw bytes without framing — useful for testing invalid input.
+    /// Writes `bytes` as they are, with no framing of its own: for a test
+    /// that sends what no message would be, and for the benchmarks, which
+    /// send a table encoded once as one stream rather than message by
+    /// message.
     pub async fn send_raw(&mut self, bytes: &[u8]) -> Result<()> {
         self.stream.write_all(bytes).await?;
         Ok(())

crates/integration-tests/tests/add_path.rs

@@ -7,16 +7,15 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use bgp_integration_tests::announcement::{Announcement, withdrawal};
-use bgp_integration_tests::test_peer::TestPeer;
+use bgp_integration_tests::test_peer::{TestPeer, collector_capabilities};
 use bgp_integration_tests::test_server::TestServer;
 use bgp_integration_tests::{peer_config, prefix, wait_until};
 use bgp_packet::message::{
     AsPathAttribute, Message, MpReachNlriPathAttribute, NlriNextHop, OriginPathAttribute,
     PathAttribute, UpdateMessage,
 };
-use bgp_packet::open::{AddPathEntry, Capability, ExtendedNextHopEntry, OpenMessage, SendReceive};
+use bgp_packet::open::{AddPathEntry, Capability, OpenMessage, SendReceive};
 use bgp_primitives::constants::AfiSafi;
-use bgp_primitives::constants::{Afi, Safi};
 use bgp_primitives::ip_prefix::Nlri;
 use bgp_rib::{LocalRoute, LocalRouteAttrs};
 use bgp_server::config::PeerConfig;
@@ -350,25 +349,16 @@ async fn test_every_route_goes_to_a_collector_told_apart_by_path_identifiers() -
     b.announce(route(&[PEER_ASN + 1, 64510])).await?;
     server.wait_for_routes(2).await?;
 
-    let mut capabilities = vec![Capability::FourByteAsn { asn: COLLECTOR_ASN }];
-    capabilities.extend(SUPPORTED.into_iter().map(Capability::multiprotocol));
-    capabilities.push(Capability::AddPath {
-        entries: vec![AddPathEntry {
-            afi: AfiSafi::IPV4_UNICAST.afi,
-            safi: AfiSafi::IPV4_UNICAST.safi,
-            send_recv: SendReceive::Receive,
-        }],
-    });
     let mut collector = TestPeer::connect(server.addr).await?;
     collector
         .handshake_with(
             COLLECTOR_ASN,
             Ipv4Addr::new(10, 0, 0, 100),
             90,
-            capabilities,
+            collector_capabilities(COLLECTOR_ASN, &SUPPORTED, false),
         )
         .await?;
-    collector.ctx.add_path = vec![AfiSafi::IPV4_UNICAST];
+    collector.ctx.add_path = SUPPORTED.to_vec();
 
     // Both routes, told apart.
     let mut held = Held::new();
@@ -437,25 +427,16 @@ async fn test_a_large_table_reaches_a_collector_that_was_there_first() -> Result
         c.connect_retry = Duration::from_secs(3600);
     })
     .await?;
-    let mut capabilities = vec![Capability::FourByteAsn { asn: COLLECTOR_ASN }];
-    capabilities.extend(SUPPORTED.into_iter().map(Capability::multiprotocol));
-    capabilities.push(Capability::AddPath {
-        entries: vec![AddPathEntry {
-            afi: AfiSafi::IPV4_UNICAST.afi,
-            safi: AfiSafi::IPV4_UNICAST.safi,
-            send_recv: SendReceive::Receive,
-        }],
-    });
     let mut collector = TestPeer::connect(server.addr).await?;
     collector
         .handshake_with(
             COLLECTOR_ASN,
             Ipv4Addr::new(10, 0, 0, 100),
             90,
-            capabilities,
+            collector_capabilities(COLLECTOR_ASN, &SUPPORTED, false),
         )
         .await?;
-    collector.ctx.add_path = vec![AfiSafi::IPV4_UNICAST];
+    collector.ctx.add_path = SUPPORTED.to_vec();
     server.wait_for_sessions(1).await?;
 
     // Two feeders, each sending the same prefixes a hundred to an UPDATE.
@@ -518,35 +499,16 @@ async fn test_both_families_reach_a_collector_over_one_ipv6_session() -> Result<
         c.connect_retry = Duration::from_secs(3600);
     })
     .await?;
-    let mut capabilities = vec![Capability::FourByteAsn { asn: COLLECTOR_ASN }];
-    capabilities.extend(SUPPORTED.into_iter().map(Capability::multiprotocol));
-    capabilities.push(Capability::AddPath {
-        entries: [AfiSafi::IPV4_UNICAST, AfiSafi::IPV6_UNICAST]
-            .into_iter()
-            .map(|family| AddPathEntry {
-                afi: family.afi,
-                safi: family.safi,
-                send_recv: SendReceive::Receive,
-            })
-            .collect(),
-    });
-    capabilities.push(Capability::ExtendedNextHop {
-        entries: vec![ExtendedNextHopEntry {
-            afi: Afi::IPV4,
-            safi: Safi::UNICAST,
-            nh_afi: Afi::IPV6,
-        }],
-    });
     let mut collector = TestPeer::connect(server.addrs[1]).await?;
     collector
         .handshake_with(
             COLLECTOR_ASN,
             Ipv4Addr::new(10, 0, 0, 100),
             90,
-            capabilities,
+            collector_capabilities(COLLECTOR_ASN, &SUPPORTED, true),
         )
         .await?;
-    collector.ctx.add_path = vec![AfiSafi::IPV4_UNICAST, AfiSafi::IPV6_UNICAST];
+    collector.ctx.add_path = SUPPORTED.to_vec();
     server.wait_for_sessions(1).await?;
     let session = &server.registry.list()[0];
     assert!(session.extended_next_hop, "RFC 8950 agreed");