Merge long-living absorb-fsm

Cargo.toml

@@ -12,20 +12,25 @@ keywords = ["routing", "bgp"]
 license = "BSD-3-Clause"
 
 [dependencies]
-arbitrary   = { version = "1", optional = true, features = ["derive"] }
-bytes       = { version = "1", optional = true }
+inetnum     = { version = "0.1.0", features = ["arbitrary", "serde"] }
+arbitrary   = { version = "1.3.1", optional = true, features = ["derive"] }
+bytes       = { version = "1.2", optional = true }
 chrono      = { version = "0.4.20", optional = true, default-features = false }
 const-str   = { version = "0.5", optional = true, features = ["case"] }
 log         = { version = "0.4.4", optional = true }
 octseq      = { version = "0.4.0", optional = true, features = ["bytes"] }
+paste       = { version = "1" }
 serde       = { version = "1.0.165", optional = true, features = ["derive"] }
-tokio       = { version = ">=1.24.2", optional = true, features = ["sync", "rt"] }
+tokio       = { version = ">=1.24.2", optional = true, features = ["io-util", "macros", "net", "sync", "rt-multi-thread", "time"] }
 
 [dev-dependencies]
 memmap2         = "0.9"
 serde_test      = "1"
 
 [features]
-default = []
+default = ["bgp"]
 bgp = ["bytes", "log", "octseq", "const-str"]
 bmp = ["bgp", "chrono"]
+fsm = ["tokio"]
+bgpsec = []
+

fuzz/Cargo.toml

@@ -45,3 +45,15 @@ name = "parse_open_message"
 path = "fuzz_targets/parse_open_message.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "nlri_ord"
+path = "fuzz_targets/nlri_ord.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "path_selection"
+path = "fuzz_targets/path_selection.rs"
+test = false
+doc = false

fuzz/fuzz_targets/nlri_ord.rs

@@ -0,0 +1,32 @@
+#![no_main]
+
+use std::cmp::Ordering::*;
+use libfuzzer_sys::fuzz_target;
+use routecore::bgp::nlri::afisafi::Nlri;
+
+fuzz_target!(|data: (Nlri<&[u8]>, Nlri<&[u8]>, Nlri<&[u8]>)| {
+    let (a, b, c) = data;
+    match (a.cmp(&b), b.cmp(&c)) {
+        // a < b < c
+        (Less, Less) => assert_eq!(a.cmp(&c), Less),
+        // a < b == c
+        (Less, Equal) => assert_eq!(a.cmp(&c), Less),
+        // a < b > c
+        (Less, Greater) => { } ,
+
+        // a == b == c
+        (Equal, Equal) => assert_eq!(a.cmp(&c), Equal),
+        // a == b < c
+        (Equal, Less) => assert_eq!(a.cmp(&c), Less),
+        // a == b > c
+        (Equal, Greater) => assert_eq!(a.cmp(&c), Greater),
+
+        // a > b > c
+        (Greater, Greater) => assert_eq!(a.cmp(&c), Greater),
+        // a > b < c
+        (Greater, Less) => { },
+        // a > b == c
+        (Greater, Equal) => assert_eq!(a.cmp(&c), Greater),
+    }
+});
+

fuzz/fuzz_targets/parse_update_message.rs

@@ -5,23 +5,18 @@ use routecore::bgp::message::{UpdateMessage, SessionConfig};
 use routecore::bgp::message::update_builder::UpdateBuilder;
 
 fuzz_target!(|data: (&[u8], SessionConfig)| {
-    if let Ok(upd) =  UpdateMessage::from_octets(data.0, data.1) {
+    if let Ok(upd) =  UpdateMessage::from_octets(data.0, &data.1) {
         if let Ok(pas) = upd.path_attributes() {
             for pa in pas.into_iter() {
-                if let Ok(pa) = pa {
-                    let _ = pa.to_owned();
-                }
+                let _ = pa.unwrap().to_owned();
             }
         }
-        /*
-        if let Ok(builder) = UpdateBuilder::from_update_message(
-            &upd,
-            data.1,
-            target,
-        ) {
-            let _ = builder.into_message(); //.unwrap();
+        if let Ok(iter) =  upd.announcements() {
+            iter.count();
+        }
+        if let Ok(iter) =  upd.withdrawals() {
+            iter.count();
         }
-        */
     }
 });
 

fuzz/fuzz_targets/path_selection.rs

@@ -0,0 +1,80 @@
+#![no_main]
+
+use std::cmp::Ordering::*;
+use libfuzzer_sys::fuzz_target;
+use routecore::bgp::{path_attributes::PaMap, path_selection::{OrdRoute, Rfc4271, SkipMed, TiebreakerInfo}};
+
+fn verify_ord<T>(a: &T, b: &T, c: &T)
+    where T: Ord
+{
+    match (a.cmp(b), b.cmp(c)) {
+        // a < b < c
+        (Less, Less) => assert_eq!(a.cmp(c), Less),
+        // a < b == c
+        (Less, Equal) => assert_eq!(a.cmp(c), Less),
+        // a < b > c
+        (Less, Greater) => { } ,
+
+        // a == b == c
+        (Equal, Equal) => {
+            assert_eq!(a.cmp(c), Equal);
+            // Test PartialEq
+            assert!(a == b);
+            assert!(b == c);
+        }
+        // a == b < c
+        (Equal, Less) => assert_eq!(a.cmp(c), Less),
+        // a == b > c
+        (Equal, Greater) => assert_eq!(a.cmp(c), Greater),
+
+        // a > b > c
+        (Greater, Greater) => assert_eq!(a.cmp(c), Greater),
+        // a > b < c
+        (Greater, Less) => { },
+        // a > b == c
+        (Greater, Equal) => assert_eq!(a.cmp(c), Greater),
+    }
+}
+
+// XXX while doing fuzz_target!(|data: &[u8]| ... and then creating an
+// Unstructured from `data` can be useful, the Debug output becomes quite
+// useless. It'll be just a bunch of bytes without any structure.
+// So, something like
+//      fuzz_target!(|data: (OrdRoute, OrdRoute, OrdRoute)| {
+//  has benefits.
+//
+
+fuzz_target!(|data: (
+        PaMap, TiebreakerInfo,
+        PaMap, TiebreakerInfo,
+        PaMap, TiebreakerInfo
+    )|{
+
+    //dbg!(&data);
+
+    let a = match OrdRoute::<SkipMed>::try_new(&data.0, data.1) {
+        Ok(r) => r,
+        Err(_) => return,
+    };
+    let b = match OrdRoute::<SkipMed>::try_new(&data.2, data.3) {
+        Ok(r) => r,
+        Err(_) => return,
+    };
+    let c = match OrdRoute::<SkipMed>::try_new(&data.4, data.5) {
+        Ok(r) => r,
+        Err(_) => return,
+    };
+
+    //dbg!("skipmed");
+    verify_ord(&a, &b, &c);
+
+    //dbg!("rfc4271");
+    /*
+    verify_ord(
+        &a.into_strat::<Rfc4271>(),
+        &b.into_strat::<Rfc4271>(),
+        &c.into_strat::<Rfc4271>()
+    );
+    */
+
+});

rustfmt.toml

@@ -1 +1,3 @@
-max_width = 78
+edition = "2021"
+max_width = 78
+