cargo fmt, clippy fixes

Cargo.toml

@@ -4,7 +4,8 @@ members = [
     "datatypes",
     "examples/websites",
     "examples/port_count",
-    "examples/filter_stats",
+    # Exclude from compilation; many subscriptions takes a long time to compile
+    # "examples/filter_stats",
     "examples/protocols",
 ]
 resolver = "2"

core/src/filter/actions.rs

@@ -1,3 +1,4 @@
+use bitmask_enum::bitmask;
 /// For each connectionn, the Retina framework applies multiple filtering stages as
 /// packets are received in order to determine (1) whether packets from that connection
 /// should continue to be processed and (2) what to do with these packets.
@@ -11,7 +12,7 @@
 /// Each filter stage returns a set of actions and a set of terminal actions.
 /// The terminal actions are the subset of actions that are maintained through
 /// the next filter stage.
-use bitmask_enum::bitmask;
+use std::fmt;
 
 #[bitmask]
 #[bitmask_config(vec_debug)]
@@ -280,7 +281,6 @@ use proc_macro2::{Ident, Span};
 use quote::{quote, ToTokens};
 use std::str::FromStr;
 
-#[allow(clippy::to_string_trait_impl)]
 impl FromStr for ActionData {
     type Err = core::fmt::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -301,23 +301,23 @@ impl FromStr for ActionData {
     }
 }
 
-#[allow(clippy::to_string_trait_impl)]
-impl ToString for ActionData {
-    fn to_string(&self) -> String {
-        match *self {
-            ActionData::PacketContinue => "PacketContinue".into(),
-            ActionData::PacketDeliver => "PacketDeliver".into(),
-            ActionData::ProtoProbe => "ProtoProbe".into(),
-            ActionData::ProtoFilter => "ProtoFilter".into(),
-            ActionData::SessionFilter => "SessionFilter".into(),
-            ActionData::SessionDeliver => "SessionDeliver".into(),
-            ActionData::SessionTrack => "SessionTrack".into(),
-            ActionData::UpdatePDU => "UpdatePDU".into(),
-            ActionData::ReassembledUpdatePDU => "ReassembledUpdatePDU".into(),
-            ActionData::PacketTrack => "PacketTrack".into(),
-            ActionData::ConnDeliver => "ConnDeliver".into(),
+impl fmt::Display for ActionData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let s = match *self {
+            ActionData::PacketContinue => "PacketContinue",
+            ActionData::PacketDeliver => "PacketDeliver",
+            ActionData::ProtoProbe => "ProtoProbe",
+            ActionData::ProtoFilter => "ProtoFilter",
+            ActionData::SessionFilter => "SessionFilter",
+            ActionData::SessionDeliver => "SessionDeliver",
+            ActionData::SessionTrack => "SessionTrack",
+            ActionData::UpdatePDU => "UpdatePDU",
+            ActionData::ReassembledUpdatePDU => "ReassembledUpdatePDU",
+            ActionData::PacketTrack => "PacketTrack",
+            ActionData::ConnDeliver => "ConnDeliver",
             _ => panic!("Unknown ActionData"),
-        }
+        };
+        write!(f, "{}", s)
     }
 }
 

core/src/lib.rs

@@ -27,9 +27,9 @@
 //!
 //! ```rust
 //! use retina_core::config::default_config;
-//! use retina_core::subscription::TlsHandshake;
 //! use retina_core::Runtime;
-//! use retina_filtergen::filter;
+//! use retina_filtergen::{retina_main, filter};
+//! use retina_datatypes::*;
 //!
 //! // Specify a subscription: filter, datatype(s), and callback. The filter determines what
 //! // subset of traffic is delivered to the callback. The datatype(s) determine what data is
@@ -46,7 +46,7 @@
 //! // A Retina application consists of one or more subscriptions.
 //! // Define other subscriptions in the same file.
 //! #[filter("dns")]
-//! fn log_tls(dns: &DnsTransaction) {
+//! fn log_dns(dns: &DnsTransaction) {
 //!      println!("{:?}", dns);
 //! }
 //!
@@ -58,7 +58,7 @@
 //!     let cfg = default_config();
 //!     // SubscribedWrapper is the type generated at compile-time to "wrap" all
 //!     // data tracking and delivering functionality, while `filter` wraps all filtering.
-//!     let mut runtime<SubscribedWrapper> = Runtime::new(cfg, filter, callback).unwrap();
+//!     let runtime::<SubscribedWrapper> = Runtime::new(cfg, filter).unwrap();
 //!     // Starts Retina
 //!     runtime.run();
 //! }

core/src/subscription/mod.rs

@@ -5,6 +5,9 @@ use crate::lcore::CoreId;
 use crate::memory::mbuf::Mbuf;
 use crate::protocols::stream::{ConnData, ParserRegistry, Session};
 
+#[cfg(feature = "timing")]
+use crate::timing::timer::Timers;
+
 pub trait Subscribable {
     type Tracked: Trackable<Subscribed = Self>;
 }

core/src/timing/timer.rs

@@ -42,6 +42,7 @@ impl Timers {
         Timers(timers)
     }
 
+    #[allow(dead_code)]
     pub(crate) fn record(&self, which: &str, value: u64, sample: u64) {
         if let Some(timer) = self.0.get(which) {
             timer

examples/protocols/src/main.rs

@@ -1,7 +1,7 @@
-use retina_filtergen::{filter, retina_main};
-use retina_core::{CoreId, Runtime, FiveTuple};
 use retina_core::config::load_config;
+use retina_core::{CoreId, FiveTuple, Runtime};
 use retina_datatypes::*;
+use retina_filtergen::{filter, retina_main};
 
 use std::fs::File;
 use std::io::{BufRead, BufReader, BufWriter, Write};
@@ -163,7 +163,6 @@ fn combine_results(outfile: &PathBuf) {
     file.write_all(results.as_bytes()).unwrap();
 }
 
-
 #[retina_main(4)]
 fn main() {
     init();
@@ -186,4 +185,4 @@ fn main() {
     let mut runtime: Runtime<SubscribedWrapper> = Runtime::new(config, filter).unwrap();
     runtime.run();
     combine_results(&args.outfile);
-}
+}