add IPFIX diagnostic messages in waiting_page

Author: GyulyVGC

src/gui/pages/waiting_page.rs

@@ -11,6 +11,10 @@ use crate::translations::translations::{
 };
 use crate::translations::translations_3::unsupported_link_type_translation;
 use crate::translations::translations_4::reading_from_pcap_translation;
+use crate::translations::translations_6::{
+    invalid_ipfix_received_translation, make_sure_valid_ipfix_translation,
+    waiting_ipfix_connections_translation,
+};
 use crate::utils::types::icon::Icon;
 use iced::widget::{Column, Container, Space, Text};
 use iced::{Alignment, Length};
@@ -21,27 +25,46 @@ pub fn waiting_page(sniffer: &Sniffer) -> Option<Container<'_, Message, StyleTyp
     let dots = &sniffer.dots_pulse.0;
     let cs = &sniffer.capture_source;
 
-    let pcap_error = sniffer.pcap_error.as_ref();
+    let capture_error = sniffer.capture_error.as_ref();
     let tot_packets = sniffer
         .info_traffic
         .tot_data_info
         .tot_data(DataRepr::Packets);
 
-    if pcap_error.is_none() && tot_packets > 0 {
+    // a rejected IPFIX exporter doesn't stop the others from being read, so the
+    // page makes way as soon as any traffic is actually observed
+    if tot_packets > 0 {
         return None;
     }
 
     let link_type = cs.get_link_type();
-    let (icon_text, nothing_to_see_text) = if let Some(error) = pcap_error {
-        (
-            Icon::Error.to_text().size(60),
-            format!("{}\n\n{error}", error_translation(language)),
-        )
+    let (icon_text, nothing_to_see_text) = if let Some(error) = capture_error {
+        // the IPFIX collector reports rejected datagrams as an empty error: the
+        // capture is running fine, so it's a warning and its text is static.
+        // A non-empty one is a failure to start, and keeps its own message.
+        if matches!(cs, CaptureSource::Ipfix(_)) && error.is_empty() {
+            (
+                Icon::Warning.to_text().size(60),
+                format!(
+                    "{}\n\n{}",
+                    invalid_ipfix_received_translation(language),
+                    make_sure_valid_ipfix_translation(language)
+                ),
+            )
+        } else {
+            (
+                Icon::Error.to_text().size(60),
+                format!("{}\n\n{error}", error_translation(language)),
+            )
+        }
     } else if matches!(cs, CaptureSource::Ipfix(_)) {
-        // TODO!
         (
-            Icon::File.to_text().size(60),
-            reading_from_pcap_translation(language).to_string(),
+            Icon::get_hourglass(dots.len()).size(60),
+            format!(
+                "{}\n\n{}",
+                waiting_ipfix_connections_translation(language),
+                make_sure_valid_ipfix_translation(language)
+            ),
         )
     } else if !link_type.is_supported() {
         (

src/gui/sniffer.rs

@@ -105,8 +105,10 @@ pub struct Sniffer {
     pub newer_release_available: Option<bool>,
     /// Network device to be analyzed, or PCAP file to be imported
     pub capture_source: CaptureSource,
-    /// Signals if a pcap error occurred
-    pub pcap_error: Option<String>,
+    /// Signals if the capture backend reported a problem; empty when the problem
+    /// is the IPFIX collector rejecting datagrams, whose text the waiting page
+    /// supplies itself so that it follows a language change
+    pub capture_error: Option<String>,
     /// Messages status
     pub dots_pulse: (String, u8),
     /// Traffic chart displayed in the Overview page
@@ -170,7 +172,7 @@ impl Sniffer {
             logged_notifications: LoggedNotifications::default(),
             newer_release_available: None,
             capture_source,
-            pcap_error: None,
+            capture_error: None,
             dots_pulse: (".".to_string(), 0),
             traffic_chart: TrafficChart::new(style, language, data_repr),
             preview_charts,
@@ -363,6 +365,7 @@ impl Sniffer {
             Message::SetIpfixPort(port) => self.set_ipfix_port(port),
             Message::PendingHosts(cap_id, host_msgs) => self.pending_hosts(cap_id, host_msgs),
             Message::OfflineGap(cap_id, gap) => self.offline_gap(cap_id, gap),
+            Message::IpfixRejection(cap_id) => self.ipfix_rejection(cap_id),
             Message::Periodic => self.periodic(),
             Message::ExpandNotification(id, expand) => self.expand_notification(id, expand),
             Message::ToggleRemoteNotifications => self.toggle_remote_notifications(),
@@ -858,6 +861,13 @@ impl Sniffer {
         }
     }
 
+    fn ipfix_rejection(&mut self, cap_id: usize) {
+        if cap_id == self.current_capture_rx.0 {
+            // the correct translated error is displayed in waiting_page
+            self.capture_error = Some(String::new());
+        }
+    }
+
     fn periodic(&mut self) {
         self.update_waiting_dots();
         self.capture_source.set_addresses();
@@ -1007,7 +1017,7 @@ impl Sniffer {
             let pcap_path = self.conf.export_pcap.full_path();
             let capture_context =
                 CaptureContext::new(&self.capture_source, pcap_path.as_ref(), &self.conf.filters);
-            self.pcap_error = capture_context.error().map(ToString::to_string);
+            self.capture_error = capture_context.error().map(ToString::to_string);
             self.running_page = Some(self.conf.last_opened_page);
 
             if capture_context.error().is_none() {
@@ -1077,6 +1087,9 @@ impl Sniffer {
                     BackendTrafficMessage::OfflineGap(cap_id, gap) => {
                         Message::OfflineGap(cap_id, gap)
                     }
+                    BackendTrafficMessage::IpfixRejection(cap_id) => {
+                        Message::IpfixRejection(cap_id)
+                    }
                 });
             }
         }
@@ -1097,7 +1110,7 @@ impl Sniffer {
         self.addresses_resolved = HashMap::new();
         self.latency_statuses = HashMap::new();
         self.logged_notifications = LoggedNotifications::default();
-        self.pcap_error = None;
+        self.capture_error = None;
         self.traffic_chart = TrafficChart::new(style, language, self.conf.data_repr);
         self.modal = None;
         self.settings_page = None;

src/gui/types/message.rs

@@ -158,6 +158,8 @@ pub enum Message {
     PendingHosts(usize, Vec<HostMessage>),
     /// Sent by offline captures: ticks without packets
     OfflineGap(usize, u32),
+    /// Sent by the IPFIX collector: incoming datagrams aren't decodable as IPFIX
+    IpfixRejection(usize),
     /// Emitted every second to repeat certain tasks (such as fetching the network devices)
     Periodic,
     /// Expand or collapse the given logged notification