tui: display ARP packets

Author: pythops

Cargo.lock

@@ -10,7 +10,7 @@ use aya::maps::{MapData, RingBuf};
 use aya::programs::{tc, SchedClassifier, TcAttachType};
 use aya::{include_bytes_aligned, Bpf};
 use mio::{Events, Interest, Poll, Registry, Token};
-use oryx_common::IpPacket;
+use oryx_common::RawPacket;
 
 use crate::event::Event;
 use crate::notification::{Notification, NotificationLevel};
@@ -166,8 +166,9 @@ impl Ebpf {
                                 if terminate.load(std::sync::atomic::Ordering::Relaxed) {
                                     break;
                                 }
-                                let packet: [u8; 40] = item.to_owned().try_into().unwrap();
-                                sender.send(Event::Packet(IpPacket::from(packet))).ok();
+                                let packet: [u8; RawPacket::LEN] =
+                                    item.to_owned().try_into().unwrap();
+                                sender.send(Event::Packet(packet)).ok();
                             }
                         }
                     }
@@ -283,8 +284,9 @@ impl Ebpf {
                                 if terminate.load(std::sync::atomic::Ordering::Relaxed) {
                                     break;
                                 }
-                                let packet: [u8; 40] = item.to_owned().try_into().unwrap();
-                                sender.send(Event::Packet(IpPacket::from(packet))).ok();
+                                let packet: [u8; RawPacket::LEN] =
+                                    item.to_owned().try_into().unwrap();
+                                sender.send(Event::Packet(packet)).ok();
                             }
                         }
                     }

oryx-tui/src/app.rs

@@ -1,19 +1,18 @@
 use crate::app::AppResult;
 use crate::notification::Notification;
-use oryx_common::IpPacket;
 use ratatui::crossterm::event::{
     self, Event as CrosstermEvent, KeyEvent, KeyEventKind, MouseEvent,
 };
 use std::thread;
 use std::time::{Duration, Instant};
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum Event {
     Tick,
     Key(KeyEvent),
     Mouse(MouseEvent),
     Resize(u16, u16),
-    Packet(IpPacket),
+    Packet([u8; 48]),
     Notification(Notification),
     Reset,
 }

oryx-tui/src/ebpf.rs

@@ -2,7 +2,7 @@ use std::fs::{create_dir, OpenOptions};
 use std::io::prelude::*;
 use std::os::unix::fs::chown;
 
-use oryx_common::IpPacket;
+use oryx_common::ip::IpPacket;
 
 use crate::app::AppResult;
 

oryx-tui/src/event.rs

@@ -5,25 +5,25 @@ use ratatui::{
 };
 use tui_input::Input;
 
-use oryx_common::IpPacket;
+use oryx_common::AppPacket;
 
 #[derive(Debug, Default)]
 pub struct Fuzzy {
     enabled: bool,
     paused: bool,
     pub filter: Input,
-    pub packets: Vec<IpPacket>,
+    pub packets: Vec<AppPacket>,
     pub scroll_state: TableState,
     pub packet_end_index: usize,
 }
 
 impl Fuzzy {
-    pub fn find(&mut self, packets: &[IpPacket]) {
+    pub fn find(&mut self, packets: &[AppPacket]) {
         self.packets = packets
             .iter()
             .copied()
             .filter(|p| p.to_string().contains(self.filter.value()))
-            .collect::<Vec<IpPacket>>();
+            .collect::<Vec<AppPacket>>();
     }
 
     pub fn enable(&mut self) {

oryx-tui/src/export.rs

@@ -0,0 +1,103 @@
+use std::fmt::Display;
+
+use ratatui::{
+    layout::{Alignment, Constraint, Direction, Flex, Layout, Rect},
+    style::{Color, Style, Stylize},
+    widgets::{Block, BorderType, Borders, Row, Table, TableState},
+    Frame,
+};
+
+use crate::app::FocusedBlock;
+
+pub const NB_LINK_PROTOCOL: u16 = 1;
+
+#[derive(Debug)]
+pub struct LinkFilter {
+    pub state: TableState,
+    pub selected_protocols: Vec<LinkProtocol>,
+    pub applied_protocols: Vec<LinkProtocol>,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum LinkProtocol {
+    Arp,
+}
+
+impl Display for LinkProtocol {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Arp")
+    }
+}
+
+impl Default for LinkFilter {
+    fn default() -> Self {
+        Self {
+            state: TableState::default(),
+            selected_protocols: vec![LinkProtocol::Arp],
+            applied_protocols: Vec::new(),
+        }
+    }
+}
+
+impl LinkFilter {
+    pub fn apply(&mut self) {
+        self.applied_protocols = self.selected_protocols.clone();
+        self.selected_protocols.clear();
+    }
+
+    pub fn render(&mut self, frame: &mut Frame, block: Rect, focused_block: &FocusedBlock) {
+        let layout = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints(
+                [
+                    Constraint::Fill(1),
+                    Constraint::Length(55),
+                    Constraint::Fill(1),
+                ]
+                .as_ref(),
+            )
+            .flex(Flex::Center)
+            .split(block);
+
+        let area = layout[1];
+
+        let widths = [Constraint::Length(2), Constraint::Fill(1)];
+        let link_filters = vec![Row::new(vec![
+            {
+                if self.selected_protocols.contains(&LinkProtocol::Arp) {
+                    " "
+                } else {
+                    ""
+                }
+            },
+            "ARP",
+        ])];
+
+        let table = Table::new(link_filters, widths)
+            .highlight_style(Style::new().bg(ratatui::style::Color::DarkGray));
+
+        frame.render_widget(
+            Block::new()
+                .title(" Link Filters 󱪤 ")
+                .title_style(Style::default().bold().fg(Color::Green))
+                .title_alignment(Alignment::Center)
+                .borders(Borders::LEFT)
+                .border_type(if *focused_block == FocusedBlock::LinkFilter {
+                    BorderType::Thick
+                } else {
+                    BorderType::default()
+                })
+                .border_style(Style::default().fg(Color::Green)),
+            area,
+        );
+
+        frame.render_stateful_widget(
+            table,
+            area.inner(ratatui::layout::Margin {
+                horizontal: 6,
+                vertical: 2,
+            }),
+            &mut self.state,
+        );
+    }
+}