Handle update messages (#14)

* Ignore update messages unless in established

* Compare MED for routes from same AS only

* Check update message size

* Implement MRAI per peer

* Test MRAI

* Split file

* Setup protoc

Author: sungwoncho

Makefile

@@ -1,9 +1,11 @@
-.PHONY: build clean run test fmt release setup
+.PHONY: all build clean run test fmt release setup
+
+all: build
 
 setup:
-	command -v protoc >/dev/null 2>&1 || sudo apt-get update && sudo apt-get install -y protobuf-compiler
+	./script/setup-protoc.sh
 
-build: fmt
+build: setup
 	cargo build --release
 
 release:
@@ -12,10 +14,10 @@ release:
 clean:
 	cargo clean
 
-run:
+run: setup
 	cargo run
 
-test:
+test: setup
 	cargo test
 
 fmt:

README.md

@@ -2,24 +2,45 @@
 
 A BGP implementation written in Rust.
 
-## Structure
+## Quick Start
 
-- `core` - Core BGP protocol implementation
-- `daemon` - BGP daemon
-- `cli` - Command-line interface
+```bash
+# Build
+make
 
-## Build
+# Run daemon
+./target/release/bgpggd -c config.yaml
 
+# Use CLI (in another terminal)
+./target/release/bgpgg peer add 192.168.1.1:179
+./target/release/bgpgg peer list
 ```
-make build
-```
 
-## Test
+## Configuration
+
+Edit `config.yaml`:
 
+```yaml
+asn: 65000                      # Your AS number
+listen_addr: "127.0.0.1:1790"   # BGP listen address
+router_id: "1.1.1.1"            # Router ID
+grpc_listen_addr: "[::1]:50051" # gRPC API address
 ```
-make test
+
+## Development
+
+```bash
+make        # Build
+make test   # Run tests
+make fmt    # Format code
 ```
 
+## Structure
+
+- `core` - Core BGP protocol implementation
+- `daemon` - BGP daemon server
+- `cli` - Command-line interface
+
 ## License
 
 Apache-2.0

core/src/config.rs

@@ -68,6 +68,10 @@ pub struct PeerConfig {
     /// Default false: collision detection is ignored when peer is in Established state.
     #[serde(default)]
     pub collision_detect_established_state: bool,
+    /// MinRouteAdvertisementIntervalTimer - minimum seconds between route advertisements (RFC 4271 9.2.1.1).
+    /// Default: 30 seconds for eBGP, 5 seconds for iBGP (or disabled for iBGP).
+    #[serde(default)]
+    pub min_route_advertisement_interval_secs: Option<u64>,
 }
 
 fn default_idle_hold_time() -> Option<u64> {
@@ -110,6 +114,7 @@ impl Default for PeerConfig {
             max_prefix: None,
             send_notification_without_open: false,
             collision_detect_established_state: false,
+            min_route_advertisement_interval_secs: None,
         }
     }
 }

core/src/grpc/service.rs

@@ -89,6 +89,7 @@ fn proto_to_peer_config(proto: Option<ProtoSessionConfig>) -> PeerConfig {
         collision_detect_established_state: cfg
             .collision_detect_established_state
             .unwrap_or(defaults.collision_detect_established_state),
+        min_route_advertisement_interval_secs: cfg.min_route_advertisement_interval_secs,
     }
 }
 

core/src/peer/messages.rs

@@ -286,6 +286,9 @@ impl Peer {
 mod tests {
     use super::*;
     use crate::bgp::msg::Message;
+    use crate::bgp::msg_update::{AsPathSegment, AsPathSegmentType, Origin, UpdateMessage};
+    use crate::peer::fsm::BgpState;
+    use std::net::Ipv4Addr;
 
     #[test]
     fn test_admin_shutdown_notification() {
@@ -298,4 +301,97 @@ mod tests {
         assert_eq!(bytes[1], 2); // AdministrativeShutdown subcode
         assert_eq!(bytes.len(), 2); // No data
     }
+
+    #[tokio::test]
+    async fn test_update_rejected_in_non_established_states() {
+        // RFC 4271 Section 9: "An UPDATE message may be received only in the Established state.
+        // Receiving an UPDATE message in any other state is an error."
+        use crate::peer::states::tests::create_test_peer_with_state;
+
+        let non_established_states = vec![
+            BgpState::Connect,
+            BgpState::Active,
+            BgpState::OpenSent,
+            BgpState::OpenConfirm,
+        ];
+
+        for state in non_established_states {
+            let mut peer = create_test_peer_with_state(state).await;
+            peer.config.send_notification_without_open = true;
+
+            let update = UpdateMessage::new(
+                Origin::IGP,
+                vec![AsPathSegment {
+                    segment_type: AsPathSegmentType::AsSequence,
+                    segment_len: 1,
+                    asn_list: vec![65001],
+                }],
+                Ipv4Addr::new(10, 0, 0, 1),
+                vec![],
+                None,
+                None,
+                false,
+                vec![],
+            );
+
+            let result = peer.handle_message(BgpMessage::Update(update)).await;
+
+            assert!(
+                result.is_err(),
+                "UPDATE should cause error in {:?} state",
+                state
+            );
+            assert_eq!(
+                peer.state(),
+                BgpState::Idle,
+                "Peer should transition to Idle after UPDATE in {:?}",
+                state
+            );
+            assert_eq!(
+                peer.statistics.notification_sent, 1,
+                "FSM error NOTIFICATION should be sent in {:?}",
+                state
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_update_accepted_in_established() {
+        // RFC 4271 Section 9: UPDATE is processed normally in Established state
+        use crate::peer::states::tests::create_test_peer_with_state;
+
+        let mut peer = create_test_peer_with_state(BgpState::Established).await;
+        peer.fsm.timers.start_hold_timer();
+
+        let update = UpdateMessage::new(
+            Origin::IGP,
+            vec![AsPathSegment {
+                segment_type: AsPathSegmentType::AsSequence,
+                segment_len: 1,
+                asn_list: vec![65001],
+            }],
+            Ipv4Addr::new(10, 0, 0, 1),
+            vec![],
+            None,
+            None,
+            false,
+            vec![],
+        );
+
+        let result = peer.handle_message(BgpMessage::Update(update)).await;
+
+        assert!(
+            result.is_ok(),
+            "UPDATE should be accepted in Established state"
+        );
+        assert_eq!(
+            peer.state(),
+            BgpState::Established,
+            "Peer should remain in Established state"
+        );
+        assert_eq!(
+            peer.statistics.notification_sent, 0,
+            "No NOTIFICATION should be sent for valid UPDATE"
+        );
+    }
 }

core/src/peer/mod.rs

@@ -18,6 +18,7 @@ use crate::config::PeerConfig;
 use crate::debug;
 use crate::rib::rib_in::AdjRibIn;
 use crate::server::{ConnectionType, ServerOp};
+use std::collections::VecDeque;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::time::{Duration, Instant};
 
@@ -156,6 +157,12 @@ pub struct Peer {
     manually_stopped: bool,
     /// Timestamp when Established state was entered (for stability-based damping reset)
     established_at: Option<Instant>,
+    /// RFC 4271 9.2.1.1: Last time we sent an UPDATE
+    last_update_sent: Option<Instant>,
+    /// Queued UPDATE messages waiting for MRAI timer
+    pending_updates: VecDeque<UpdateMessage>,
+    /// MinRouteAdvertisementIntervalTimer from config
+    mrai_interval: Duration,
 }
 
 impl Peer {
@@ -193,6 +200,11 @@ impl Peer {
             rib_in: AdjRibIn::new(),
             session_type: None,
             statistics: PeerStatistics::default(),
+            mrai_interval: Duration::from_secs(
+                config.min_route_advertisement_interval_secs.unwrap_or(0),
+            ),
+            last_update_sent: None,
+            pending_updates: VecDeque::new(),
             config,
             peer_rx,
             server_tx,
@@ -224,8 +236,13 @@ impl Peer {
                 BgpState::Active => {
                     self.handle_active_state().await;
                 }
-                BgpState::OpenSent | BgpState::OpenConfirm | BgpState::Established => {
-                    if self.handle_open_and_established().await {
+                BgpState::OpenSent | BgpState::OpenConfirm => {
+                    if self.handle_open_states().await {
+                        return; // Shutdown requested
+                    }
+                }
+                BgpState::Established => {
+                    if self.handle_established().await {
                         return; // Shutdown requested
                     }
                 }
@@ -334,6 +351,9 @@ pub mod test_helpers {
             conn_type: ConnectionType::Outgoing,
             manually_stopped: false,
             established_at: None,
+            mrai_interval: Duration::from_secs(0),
+            last_update_sent: None,
+            pending_updates: VecDeque::new(),
         }
     }
 }

core/src/peer/state_active.rs

@@ -170,14 +170,27 @@ impl Peer {
                 self.fsm.increment_connect_retry_counter();
             }
 
-            // RFC 4271 8.2.2: Any other events (8, 10-11, 13, 19, 25-28) in Active -> Idle
+            // RFC 4271 8.2.2: Events 26-27 (KeepAlive, Update) in Active -> FSM Error
+            (BgpState::Idle, FsmEvent::BgpKeepaliveReceived)
+            | (BgpState::Idle, FsmEvent::BgpUpdateReceived) => {
+                let _ = self
+                    .send_notification(NotifcationMessage::new(
+                        BgpError::FiniteStateMachineError,
+                        vec![],
+                    ))
+                    .await;
+                self.fsm.timers.stop_connect_retry();
+                self.disconnect(true);
+                self.fsm.increment_connect_retry_counter();
+                return Err(PeerError::FsmError);
+            }
+
+            // RFC 4271 8.2.2: Any other events (8, 10-11, 13, 19, 28) in Active -> Idle
             (BgpState::Idle, FsmEvent::AutomaticStop(_))
             | (BgpState::Idle, FsmEvent::HoldTimerExpires)
             | (BgpState::Idle, FsmEvent::KeepaliveTimerExpires)
             | (BgpState::Idle, FsmEvent::IdleHoldTimerExpires)
             | (BgpState::Idle, FsmEvent::BgpOpenReceived(_))
-            | (BgpState::Idle, FsmEvent::BgpKeepaliveReceived)
-            | (BgpState::Idle, FsmEvent::BgpUpdateReceived)
             | (BgpState::Idle, FsmEvent::BgpUpdateMsgErr(_)) => {
                 self.fsm.timers.stop_connect_retry();
                 self.disconnect(true);