version 1.0.0 (branch e2d2-rs-v1), packet.rs replaced by pdu.rs

Author: rstade

Cargo.toml

@@ -14,7 +14,6 @@ members=["framework",
         "test/tcp_payload",
         "test/sctp-test",
         "test/config-test",
-        "test/reset-parse",
         "test/tcp_reconstruction",
         "test/acl-fw",]
 [profile.release]

README.md

@@ -1,3 +1,16 @@
+## Remarks to Branch e2d2-rs-v1
+
+This branch is a major change to the original NetBricks code. The code of packet.rs was replaced by pdu.rs. Pdu stands for "protocol data unit". Objective was to allow for a more arbitrary protocol stacking and header parsing. In the original code the protocol stacks must follow a tree topology, which is fixed at compile time through type parameters (e.g. PreviousHeader). The Pdu struct has no longer type parameters but includes a stack of Rust enumeration values (enum Header) which can abstract any arbitrary sequence of protocol encapsulations. The protocol sequence is determined at run time by the pdu parser and not limited at compile time, except through the capabilities of the parser. 
+
+As a positive side effect the code becomes more comprehensive as a lot of type parameters can be removed. This makes also the code easier to understand. Also we found no negative impact on the performance.
+ 
+After parsing we specialize the parsed generic Header type to a specific Rust struct type, e.g. a struct IpHeader. Therefore we still utilize the full type checking capabilities of Rust at compile time and we lose nothing compared to the original code. 
+
+
+## The original NetBricks ReadMe:
+
+
+
 [NetBricks](http://netbricks.io/) is a Rust based framework for NFV development. Please refer to the
 [paper](https://people.eecs.berkeley.edu/~apanda/assets/papers/osdi16.pdf) for information
 about the architecture and design. Currently NetBricks requires a relatively modern Linux version.

examples.sh

@@ -11,7 +11,6 @@ export examples=(
         test/tcp_check
         test/sctp-test
         test/config-test
-        test/reset-parse
         test/tcp_reconstruction
         test/acl-fw
         test/packet_generation

framework/src/headers/ip.rs

@@ -66,7 +66,7 @@ impl EndOffset for IpHeader {
     }
 
     #[inline]
-    fn is_header(&self) -> HeaderKind {
+    fn header_kind(&self) -> HeaderKind {
         HeaderKind::Ip
     }
 }

framework/src/headers/mac.rs

@@ -53,7 +53,7 @@ impl EndOffset for MacHeader {
     }
 
     #[inline]
-    fn is_header(&self) -> HeaderKind {
+    fn header_kind(&self) -> HeaderKind {
         HeaderKind::Mac
     }
 }

framework/src/headers/mod.rs

@@ -38,10 +38,10 @@ pub trait EndOffset: Send {
 
     fn check_correct(&self, prev: &Self::PreviousHeader) -> bool;
 
-    fn is_header(&self) -> HeaderKind;
+    fn header_kind(&self) -> HeaderKind;
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum Header {
     Null,
     Mac(*mut MacHeader),
@@ -51,6 +51,17 @@ pub enum Header {
 }
 
 impl Header {
+
+    pub fn new<T:EndOffset>(ptr: *mut T) -> Header {
+        match unsafe { (*ptr).header_kind() } {
+            HeaderKind::Null => Header::Null,
+            HeaderKind::Mac  => Header::Mac(ptr as *mut MacHeader),
+            HeaderKind::Ip   => Header::Ip(ptr as *mut IpHeader),
+            HeaderKind::Tcp  => Header::Tcp(ptr as *mut TcpHeader),
+            HeaderKind::Udp  => Header::Udp(ptr as *mut UdpHeader),
+        }
+    }
+
     pub fn as_mac(&self) -> Option<&mut MacHeader> {
         match &self {
             Header::Mac(p) => Some(unsafe { &mut **p }),
@@ -113,11 +124,11 @@ impl Header {
 impl fmt::Display for Header {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self {
-            Header::Null => write!(f, "{:?}", &self),
-            Header::Mac(_) => write!(f, "{:?}", &self.as_mac().unwrap()),
-            Header::Ip(_) => write!(f, "{:?}", &self.as_ip().unwrap()),
-            Header::Tcp(_) => write!(f, "{:?}", &self.as_tcp().unwrap()),
-            Header::Udp(_) => write!(f, "{:?}", &self.as_udp().unwrap()),
+            Header::Null => write!(f, "{:?}", self),
+            Header::Mac(_) => write!(f, "{:?}", self.as_mac().unwrap()),
+            Header::Ip(_) => write!(f, "{ }", self.as_ip().unwrap()),
+            Header::Tcp(_) => write!(f, "{ }", self.as_tcp().unwrap()),
+            Header::Udp(_) => write!(f, "{:?}", self.as_udp().unwrap()),
         }
     }
 }

framework/src/headers/null_header.rs

@@ -35,7 +35,7 @@ impl EndOffset for NullHeader {
     }
 
     #[inline]
-    fn is_header(&self) -> HeaderKind {
+    fn header_kind(&self) -> HeaderKind {
         HeaderKind::Null
     }
 }

framework/src/headers/tcp.rs

@@ -87,7 +87,7 @@ impl EndOffset for TcpHeader {
     }
 
     #[inline]
-    fn is_header(&self) -> HeaderKind {
+    fn header_kind(&self) -> HeaderKind {
         HeaderKind::Tcp
     }
 }
@@ -350,23 +350,27 @@ impl TcpHeader {
     // END FLAGS
 
     /// Receive window.
+    #[inline]
     pub fn window_size(&self) -> u16 {
         u16::from_be(self.window)
     }
 
+    #[inline]
     pub fn set_window_size(&mut self, wnd: u16) {
         self.window = u16::to_be(wnd);
     }
 
     /// Checksum
+    #[inline]
     pub fn checksum(&self) -> u16 {
         u16::from_be(self.csum)
     }
 
     // TODO: Validate checksum and update checksum
 
+    #[inline]
     pub fn set_checksum(&mut self, csum: u16) {
-        self.csum = u16::to_be(csum)
+        self.csum = u16::to_be(csum);
     }
 
     pub fn update_checksum_incremental(&mut self, old_word: u16, new_word: u16) {

framework/src/headers/udp.rs

@@ -50,7 +50,7 @@ impl EndOffset for UdpHeader {
     }
 
     #[inline]
-    fn is_header(&self) -> HeaderKind {
+    fn header_kind(&self) -> HeaderKind {
         HeaderKind::Udp
     }
 }

framework/src/interface/mod.rs

@@ -1,8 +1,6 @@
-pub use self::packet::*;
 pub use self::pdu::*;
 pub use self::port::*;
 pub mod dpdk;
-mod packet;
 mod pdu;
 mod port;
 use common::errors;