add keepalive message

src/event.rs

@@ -1,8 +1,9 @@
-use crate::packets::open::OpenMessage;
+use crate::packets::{keepalive::KeepaliveMessage, open::OpenMessage};
 
 #[derive(PartialEq, Eq, Debug, Clone, Hash)]
 pub enum Event {
     ManualStart,
     TcpConnectionConfirmed,
     BgpOpen(OpenMessage),
+    KeepaliveMsg(KeepaliveMessage),
 }

src/packets/header.rs

@@ -44,6 +44,7 @@ impl From<Header> for BytesMut {
 #[derive(PartialEq, Eq, Debug, Clone, Hash)]
 pub enum MessageType {
     Open,
+    Keepalive,
 }
 
 impl TryFrom<u8> for MessageType {
@@ -52,6 +53,7 @@ impl TryFrom<u8> for MessageType {
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
             1 => Ok(Self::Open),
+            4 => Ok(Self::Keepalive),
             _ => Err(Self::Error::from(anyhow::anyhow!(
                 "Invalid message type: {}",
                 value
@@ -64,6 +66,7 @@ impl From<MessageType> for u8 {
     fn from(value: MessageType) -> Self {
         match value {
             MessageType::Open => 1,
+            MessageType::Keepalive => 4,
         }
     }
 }

src/packets/keepalive.rs

@@ -0,0 +1,43 @@
+use bytes::BytesMut;
+
+use crate::error::ConvertBytesToBgpMessageError;
+
+use super::header::{Header, MessageType};
+
+#[derive(PartialEq, Eq, Debug, Clone, Hash)]
+pub struct KeepaliveMessage {
+    header: Header,
+}
+
+impl TryFrom<BytesMut> for KeepaliveMessage {
+    type Error = ConvertBytesToBgpMessageError;
+
+    fn try_from(bytes: BytesMut) -> Result<Self, Self::Error> {
+        let header = Header::try_from(bytes)?;
+
+        if header.type_ != MessageType::Keepalive {
+            return Err(anyhow::anyhow!("Invalid message type: {:?}", header.type_).into());
+        }
+
+        Ok(Self { header })
+    }
+}
+
+impl From<KeepaliveMessage> for BytesMut {
+    fn from(keepalive: KeepaliveMessage) -> Self {
+        keepalive.header.into()
+    }
+}
+
+impl KeepaliveMessage {
+    pub fn new() -> Self {
+        let header = Header::new(19, MessageType::Keepalive);
+        Self { header }
+    }
+}
+
+impl Default for KeepaliveMessage {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/packets/message.rs

@@ -6,12 +6,14 @@ use crate::{bgp_type::AutonomousSystemNumber, error::ConvertBytesToBgpMessageErr
 
 use super::{
     header::{Header, MessageType},
+    keepalive::KeepaliveMessage,
     open::OpenMessage,
 };
 
 #[derive(Debug)]
 pub enum Message {
     Open(OpenMessage),
+    Keepalive(KeepaliveMessage),
 }
 
 impl TryFrom<BytesMut> for Message {
@@ -34,6 +36,10 @@ impl TryFrom<BytesMut> for Message {
                 let open_message = OpenMessage::try_from(bytes)?;
                 Ok(Self::Open(open_message))
             }
+            MessageType::Keepalive => {
+                let keepalive_message = KeepaliveMessage::try_from(bytes)?;
+                Ok(Self::Keepalive(keepalive_message))
+            }
         }
     }
 }
@@ -42,6 +48,7 @@ impl From<Message> for BytesMut {
     fn from(message: Message) -> Self {
         match message {
             Message::Open(open) => open.into(),
+            Message::Keepalive(keepalive) => keepalive.into(),
         }
     }
 }
@@ -51,4 +58,9 @@ impl Message {
         let open_message = OpenMessage::new(my_as_number, my_ip_addr);
         Self::Open(open_message)
     }
+
+    pub fn new_keepalive() -> Self {
+        let keepalive_message = KeepaliveMessage::new();
+        Self::Keepalive(keepalive_message)
+    }
 }

src/packets/mod.rs

@@ -1,3 +1,4 @@
 pub mod header;
+pub mod keepalive;
 pub mod message;
 pub mod open;

src/peer.rs

@@ -50,6 +50,9 @@ impl Peer {
             Message::Open(open) => {
                 self.event_queue.enqueue(Event::BgpOpen(open));
             }
+            Message::Keepalive(keepalive) => {
+                self.event_queue.enqueue(Event::KeepaliveMsg(keepalive));
+            }
         }
     }
 
@@ -85,7 +88,11 @@ impl Peer {
             },
             State::OpenSent => match event {
                 Event::BgpOpen(open) => {
-                    //TODO: send keepalive message
+                    self.tcp_connection
+                        .as_mut()
+                        .expect("tcp-connection is None")
+                        .send(Message::new_keepalive())
+                        .await;
                     self.state = State::OpenConfirm;
                 }
                 _ => {}