Improve integration tests, fix bugs in rita

.gitignore

@@ -1,6 +1,10 @@
 .DS_Store
 *.bak
 /target/
+target-mac
 **/*.rs.bk
 .idea
-integration_test/test.db
+integration-tests/test.db
+bounty_hunter/test.db
+test.db-journal
+*.log

.travis.yml

@@ -1,11 +1,17 @@
 language: rust
 cache: cargo
+before_install:
+  - sudo apt-get -qq update
+  - sudo apt-get install -y ebtables libsqlite3-dev iperf3 python3-pip bridge-utils
+  - sudo pip3 install termcolor
+  - which diesel || cargo install diesel_cli --no-default-features --features sqlite
 env:
-  - TYPE=build
-  - TYPE=test RUST_TEST_THREADS=1
+  - TEST_COMMAND="cargo build --verbose --all"
+  - TEST_COMMAND="cargo test --verbose --all" RUST_TEST_THREADS=1
+  - TEST_COMMAND="./integration-tests/rita.sh"
 rust:
   - stable
   - beta
   - nightly
 script:
-  - cargo $TYPE --verbose --all
+  - (eval "$TEST_COMMAND")

althea_kernel_interface/src/delete_destination_counter_linux.rs

@@ -2,21 +2,25 @@ use super::{KernelInterface, Error};
 
 use std::net::{IpAddr};
 
+use eui48::MacAddress;
+
 impl KernelInterface {
     pub fn delete_destination_counter_linux(
         &mut self,
+        des_neighbor: MacAddress,
         destination: IpAddr,
     ) -> Result<(), Error> {
         self.delete_ebtables_rule(&[
             "-D",
             "OUTPUT",
+            "-d",
+            &format!("{}", des_neighbor.to_hex_string()),
             "-p",
             "IPV6",
             "--ip6-dst",
             &format!("{}", destination),
             "-j",
-            "CONTINUE",
+            "ACCEPT",
         ])
     }
-
 }

althea_kernel_interface/src/lib.rs

@@ -87,10 +87,11 @@ impl KernelInterface {
     /// Implemented with `ebtables` on linux.
     pub fn start_destination_counter(
         &mut self,
+        des_neighbor: MacAddress,
         destination: IpAddr,
     ) -> Result<(), Error> {
         if cfg!(target_os = "linux") {
-            return self.start_destination_counter_linux(destination);
+            return self.start_destination_counter_linux(des_neighbor, destination);
         }
 
         Err(Error::RuntimeError(
@@ -102,18 +103,18 @@ impl KernelInterface {
     /// Implemented with `ebtables` on linux.
     pub fn delete_destination_counter(
         &mut self,
+        des_neighbor: MacAddress,
         destination: IpAddr,
     ) -> Result<(), Error> {
         if cfg!(target_os = "linux") {
-            return self.delete_destination_counter_linux(destination);
+            return self.delete_destination_counter_linux(des_neighbor, destination);
         }
 
         Err(Error::RuntimeError(
             String::from("not implemented for this platform"),
         ))
     }
 
-
     /// This starts a counter of the bytes used by a particular "flow", a
     /// Neighbor/Destination pair. If the flow already exists, it resets the counter.
     /// Implemented with `ebtables` on linux.
@@ -151,9 +152,9 @@ impl KernelInterface {
     /// Returns a vector of traffic coming from a specific hardware address and going
     /// to a specific IP. Note that this will only track flows that have already been
     /// registered. Implemented with `ebtables` on Linux.
-    pub fn read_flow_counters(&mut self) -> Result<Vec<(MacAddress, IpAddr, u64)>, Error> {
+    pub fn read_flow_counters(&mut self, zero: bool) -> Result<Vec<(MacAddress, IpAddr, u64)>, Error> {
         if cfg!(target_os = "linux") {
-            return self.read_flow_counters_linux();
+            return self.read_flow_counters_linux(zero);
         }
 
         Err(Error::RuntimeError(
@@ -164,9 +165,9 @@ impl KernelInterface {
     /// Returns a vector of going to a specific IP address.
     /// Note that this will only track flows that have already been
     /// registered. Implemented with `ebtables` on Linux.
-    pub fn read_destination_counters(&mut self) -> Result<Vec<(IpAddr, u64)>, Error> {
+    pub fn read_destination_counters(&mut self, zero: bool) -> Result<Vec<(MacAddress, IpAddr, u64)>, Error> {
         if cfg!(target_os = "linux") {
-            return self.read_destination_counters_linux();
+            return self.read_destination_counters_linux(zero);
         }
 
         Err(Error::RuntimeError(
@@ -302,7 +303,7 @@ Bridge chain: INPUT, entries: 3, policy: ACCEPT
             }),
         };
 
-        let traffic = ki.read_flow_counters_linux().unwrap();
+        let traffic = ki.read_flow_counters_linux(false).unwrap();
 
         assert_eq!(format!("{}", traffic[0].0), "00-00-00-aa-00-02");
         assert_eq!(format!("{}", traffic[0].1), "2001::1");
@@ -412,18 +413,6 @@ Bridge chain: INPUT, entries: 3, policy: ACCEPT
     #[test]
     fn test_start_flow_counter_linux() {
         let mut counter = 0;
-        let delete_rule = &[
-            "-D",
-            "INPUT",
-            "-s",
-            "00:00:00:aa:00:02",
-            "-p",
-            "IPV6",
-            "--ip6-dst",
-            "2001::3",
-            "-j",
-            "CONTINUE",
-        ];
         let add_rule = &[
             "-A",
             "INPUT",
@@ -443,14 +432,15 @@ Bridge chain: INPUT, entries: 3, policy: ACCEPT
                 counter = counter + 1;
                 println!("COUNTER {}", counter);
                 match counter {
-                    1 => {
-                        assert_eq!(args, delete_rule);
-                        Ok(Output {
-                            stdout: b"Sorry, rule does not exist.".to_vec(),
+                    1 => { Ok(Output {
+                            stdout:
+                            b"Bridge table: filter
+
+Bridge chain: INPUT, entries: 3, policy: ACCEPT
+"
+                                .to_vec(),
                             stderr: b"".to_vec(),
-                            status: ExitStatus::from_raw(0),
-                        })
-                    }
+                            status: ExitStatus::from_raw(0)})}
                     2 => {
                         assert_eq!(args, add_rule);
                         Ok(Output {

althea_kernel_interface/src/read_destination_counters_linux.rs

@@ -3,20 +3,28 @@ use super::{KernelInterface, Error};
 use std::net::{IpAddr};
 use std::str::FromStr;
 
+use eui48::MacAddress;
 use regex::Regex;
 
 impl KernelInterface {
-    pub fn read_destination_counters_linux(&mut self) -> Result<Vec<(IpAddr, u64)>, Error> {
-        let output = self.run_command("ebtables", &["-L", "OUTPUT", "--Lc", "--Lmac2"])?;
+    pub fn read_destination_counters_linux(&mut self, zero: bool) -> Result<Vec<(MacAddress, IpAddr, u64)>, Error> {
+        let output = if zero {
+            self.run_command("ebtables", &["-L", "-Z", "OUTPUT", "--Lc", "--Lmac2"])?
+        } else {
+            self.run_command("ebtables", &["-L", "OUTPUT", "--Lc", "--Lmac2"])?
+        };
         let mut vec = Vec::new();
-        let re = Regex::new(r"-p IPv6 --ip6-dst (.*)/.* bcnt = (.*)").unwrap();
+        let re = Regex::new(r"-p IPv6 -d (.*) --ip6-dst (.*)/.* bcnt = (.*)").unwrap();
         for caps in re.captures_iter(&String::from_utf8(output.stdout)?) {
             vec.push((
-                IpAddr::from_str(&caps[1])?,
-                caps[2].parse::<u64>()?,
+                MacAddress::parse_str(&caps[1]).unwrap_or_else(|e| {
+                    panic!("{:?}, original string {:?}", e, caps);
+                }), // Ugly and inconsiderate, remove ASAP
+                IpAddr::from_str(&caps[2])?,
+                caps[3].parse::<u64>()?,
             ));
         }
-        trace!("Read destination couters {:?}", &vec);
+        trace!("Read destination counters {:?}", &vec);
         Ok(vec)
     }
 

althea_kernel_interface/src/read_flow_counters_linux.rs

@@ -7,8 +7,12 @@ use eui48::MacAddress;
 use regex::Regex;
 
 impl KernelInterface {
-    pub fn read_flow_counters_linux(&mut self) -> Result<Vec<(MacAddress, IpAddr, u64)>, Error> {
-        let output = self.run_command("ebtables", &["-L", "INPUT", "--Lc", "--Lmac2"])?;
+    pub fn read_flow_counters_linux(&mut self, zero: bool) -> Result<Vec<(MacAddress, IpAddr, u64)>, Error> {
+        let output = if zero {
+            self.run_command("ebtables", &["-L", "-Z", "INPUT", "--Lc", "--Lmac2"])?
+        } else {
+            self.run_command("ebtables", &["-L", "INPUT", "--Lc", "--Lmac2"])?
+        };
         let mut vec = Vec::new();
         let re = Regex::new(r"-s (.*) --ip6-dst (.*)/.* bcnt = (.*)").unwrap();
         for caps in re.captures_iter(&String::from_utf8(output.stdout)?) {

althea_kernel_interface/src/start_destination_counter_linux.rs

@@ -2,22 +2,39 @@ use super::{Error, KernelInterface};
 
 use std::net::{IpAddr};
 
+use eui48::MacAddress;
+
 impl KernelInterface {
-    pub fn start_destination_counter_linux(&mut self, destination: IpAddr) -> Result<(), Error> {
-        self.delete_destination_counter_linux(destination)?;
-        self.run_command(
-            "ebtables",
-            &[
-                "-A",
-                "OUTPUT",
-                "-p",
-                "IPV6",
-                "--ip6-dst",
-                &format!("{}", destination),
-                "-j",
-                "CONTINUE",
-            ],
-        )?;
+    pub fn start_destination_counter_linux(
+        &mut self,
+        des_neighbor: MacAddress,
+        destination: IpAddr,
+    ) -> Result<(), Error> {
+        let ctr = self.read_destination_counters(false)?;
+        let mut exists = false;
+        for (mac, ip, _) in ctr {
+            if (mac == des_neighbor) && (ip == destination) {
+                exists = true;
+            }
+        }
+        trace!("rule exists: {:?}", exists);
+        if !exists {
+            self.run_command(
+                "ebtables",
+                &[
+                    "-A",
+                    "OUTPUT",
+                    "-d",
+                    &format!("{}", des_neighbor.to_hex_string()),
+                    "-p",
+                    "IPV6",
+                    "--ip6-dst",
+                    &format!("{}", destination),
+                    "-j",
+                    "ACCEPT",
+                ],
+            )?;
+        }
         Ok(())
     }
 }

althea_kernel_interface/src/start_flow_counter_linux.rs

@@ -9,22 +9,31 @@ impl KernelInterface {
         source_neighbor: MacAddress,
         destination: IpAddr,
     ) -> Result<(), Error> {
-        self.delete_flow_counter_linux(source_neighbor, destination)?;
-        self.run_command(
-            "ebtables",
-            &[
-                "-A",
-                "INPUT",
-                "-s",
-                &format!("{}", source_neighbor.to_hex_string()),
-                "-p",
-                "IPV6",
-                "--ip6-dst",
-                &format!("{}", destination),
-                "-j",
-                "CONTINUE",
-            ],
-        )?;
+        let ctr = self.read_flow_counters(false)?;
+        let mut exists = false;
+        for (mac, ip, _) in ctr {
+            if (mac == source_neighbor) && (ip == destination) {
+                exists = true;
+            }
+        }
+        trace!("rule exists: {:?}", exists);
+        if !exists {
+            self.run_command(
+                "ebtables",
+                &[
+                    "-A",
+                    "INPUT",
+                    "-s",
+                    &format!("{}", source_neighbor.to_hex_string()),
+                    "-p",
+                    "IPV6",
+                    "--ip6-dst",
+                    &format!("{}", destination),
+                    "-j",
+                    "CONTINUE",
+                ],
+            )?;
+        }
         Ok(())
     }
 }

babel_monitor/src/lib.rs

@@ -70,7 +70,7 @@ pub struct Route {
 }
 
 #[derive(Debug)]
-pub struct Neighbour {
+pub struct Neighbor {
     pub id: String,
     pub iface: String,
     pub reach: u16,
@@ -138,12 +138,12 @@ impl<T: Read + Write> InnerBabel<T> {
     }
 
 
-    pub fn parse_neighs(&mut self) -> Result<VecDeque<Neighbour>, Error> {
-        let mut vector: VecDeque<Neighbour> = VecDeque::with_capacity(5);
+    pub fn parse_neighs(&mut self) -> Result<VecDeque<Neighbor>, Error> {
+        let mut vector: VecDeque<Neighbor> = VecDeque::with_capacity(5);
         self.write("dump\n")?;
         for entry in self.read()?.split("\n") {
             if entry.contains("add neighbour") {
-                vector.push_back(Neighbour {
+                vector.push_back(Neighbor {
                     id: find_babel_val("neighbour", entry)?,
                     iface: find_babel_val("if", entry)?,
                     reach: u16::from_str_radix(&find_babel_val("reach", entry)?, 16)?,

integration-tests/.gitignore

@@ -1,6 +1,5 @@
 *.log
 *.pid
-/deps/
 .cache
 .vagrant
-/babeld/
+/deps/