Improve parsing of [un]signed integers.

Allow the [un]signed functions to return integers smaller than [iu]64 and
also use the standard `byteorder` definitions of endianness rather than
implementing our own enum type.

Unfortunately, Rust functions are no longer allowed to have default type
arguments (see PR 30724, rust-lang/rust#30724),
so we still have to specify the endianness explicitly every time we use
one of these functions. The may require wrapping inside a type...

Author: trombonehero

Cargo.toml

@@ -11,6 +11,7 @@ readme = "README.md"
 [dependencies]
 byteorder = "0.5.2"
 docopt = "0.6.80"
+num = "0.1.32"
 pcap = "0.5.7"
 promising-future = "0.2.2"
 rustc-serialize="0.3.19"

src/ethernet/mod.rs

@@ -10,7 +10,6 @@
 //! Dissection of Ethernet (IEEE 802.3) frames.
 
 use {
-    Endianness,
     Error,
     NamedValue,
     Protocol,
@@ -21,6 +20,8 @@ use {
     unsigned,
 };
 
+use byteorder::*;
+
 
 /// The IEEE 802.3 Ethernet protocol.
 pub struct Ethernet;
@@ -59,12 +60,12 @@ impl Protocol for Ethernet {
         values.push(("Source".to_string(), mac_address(&data[6..12])));
 
         // The type/length field might be either a type or a length.
-        let tlen = unsigned(&data[12..14], Endianness::BigEndian);
+        let tlen = unsigned::<u16,NetworkEndian>(&data[12..14]);
         let remainder = &data[14..];
 
         match tlen {
             Ok(i) if i <= 1500 => {
-                values.push(("Length".to_string(), Ok(Val::Unsigned(i))));
+                values.push(("Length".to_string(), Ok(Val::Unsigned(i as u64))));
             },
 
             Ok(i) => {
@@ -83,7 +84,7 @@ impl Protocol for Ethernet {
                 let protoname = protocol.short_name().to_string();
                 let description = protocol.full_name().to_string();
 
-                values.push(("Type".to_string(), Ok(Val::Enum(i, protoname))));
+                values.push(("Type".to_string(), Ok(Val::Enum(i as u64, protoname))));
                 values.push((description, protocol.dissect(remainder)));
             },
             Err(e) => {

src/ethernet/testproto.rs

@@ -10,7 +10,6 @@
 //! Dissection of the test protocol from the Xerox Blue Book (but not IEEE 802.3).
 
 use {
-    Endianness,
     Error,
     NamedValue,
     Protocol,
@@ -20,6 +19,8 @@ use {
     unsigned,
 };
 
+use byteorder::*;
+
 
 /// Testing protocol from the Xerox Blue Book.
 ///
@@ -28,7 +29,7 @@ use {
 pub struct TestProtocol;
 
 enum TestMessage<'a> {
-    Reply { receipt_number: Result<u64>, data: &'a [u8] },
+    Reply { receipt_number: Result<u16>, data: &'a [u8] },
     ForwardData { dest: Result<Val>, message: Result<Box<TestMessage<'a>>> },
 }
 
@@ -38,7 +39,7 @@ impl Protocol for TestProtocol {
     fn dissect(&self, data: &[u8]) -> Result {
         let mut values:Vec<NamedValue> = vec![];
 
-        let skip_count = unsigned(&data[0..2], Endianness::BigEndian);
+        let skip_count = unsigned::<u64, NetworkEndian>(&data[0..2]);
         values.push(("Skip count".to_string(), skip_count.map(Val::Unsigned)));
 
         let top_message =
@@ -68,7 +69,7 @@ impl <'a> TestMessage <'a> {
                 vec![
                     ("Function Code".to_string(),
                         Ok(Val::Enum(1, "Reply Message".to_string()))),
-                    ("Receipt Number".to_string(), receipt_number.map(Val::Unsigned)),
+                    ("Receipt Number".to_string(), receipt_number.and_then(Val::unsigned)),
                     ("Data".to_string(), Ok(Val::Bytes(data.to_vec()))),
                 ],
 
@@ -91,10 +92,10 @@ impl <'a> TestMessage <'a> {
     }
 
     fn parse(data: &[u8]) -> Result<TestMessage> {
-        let function_code = unsigned(&data[0..2], Endianness::LittleEndian);
+        let function_code = unsigned::<u16, LittleEndian>(&data[0..2]);
         match function_code {
             Ok(1) => Ok({
-                let receipt_number = unsigned(&data[2..4], Endianness::LittleEndian);
+                let receipt_number = unsigned::<u16, LittleEndian>(&data[2..4]);
 
                 TestMessage::Reply{
                     receipt_number: receipt_number,

src/ip/mod.rs

@@ -16,7 +16,6 @@
 //! See [RFC 791](https://tools.ietf.org/html/rfc791).
 
 use {
-    Endianness,
     Error,
     NamedValue,
     Protocol,
@@ -26,6 +25,8 @@ use {
     unsigned,
 };
 
+use byteorder::*;
+
 
 pub struct IPv4;
 
@@ -58,8 +59,8 @@ impl Protocol for IPv4 {
         values.push(("ECN".to_string(), Ok(Val::Unsigned(ecn as u64))));
 
         // Total length (including header)
-        let length = unsigned(&data[2..4], Endianness::BigEndian);
-        values.push(("Length".to_string(), length.map(Val::Unsigned)));
+        let length = unsigned::<u16, NetworkEndian>(&data[2..4]);
+        values.push(("Length".to_string(), length.and_then(Val::unsigned)));
 
         // Identification (of datagraph fragments): RFC 6864
         values.push(("Identification".to_string(), Ok(Val::Unsigned(data[8] as u64))));

src/lib.rs

@@ -61,12 +61,12 @@
 #![doc(html_logo_url = "https://raw.githubusercontent.com/musec/rusty-shark/master/artwork/wordmark.png")]
 
 extern crate byteorder;
+extern crate num;
 extern crate promising_future;
 
-use byteorder::ReadBytesExt;
+use byteorder::ByteOrder;
 pub use promising_future::Future;
 use std::fmt;
-use std::io;
 
 
 /// A description of a protocol, including code that can parse it.
@@ -121,6 +121,14 @@ pub enum Val {
 }
 
 impl Val {
+    pub fn unsigned<T>(x: T) -> Result<Val>
+        where T: num::ToPrimitive + std::fmt::Display
+    {
+        x.to_u64()
+         .map(Val::Unsigned)
+         .ok_or(Error::InvalidData(format!["Cannot convert {} to u64", x]))
+    }
+
     pub fn pretty_print(self, indent_level:usize) -> String {
         match self {
             Val::Subpacket(values) => {
@@ -194,72 +202,47 @@ pub type Result<T=Val> = ::std::result::Result<T,Error>;
 /// A named value-or-error.
 pub type NamedValue = (String,Result<Val>);
 
-/// Little- or big-endian integer representations.
-pub enum Endianness {
-    BigEndian,
-    LittleEndian,
-}
 
 /// Parse a signed integer of a given endianness from a byte buffer.
 ///
 /// The size of the buffer will be used to determine the size of the integer
-/// that should be parsed (i8, i16, i32 or i64), but the result will be stored
-/// in an i64.
-pub fn signed(buffer: &[u8], endianness: Endianness) -> Result<i64> {
-    let mut reader = io::Cursor::new(buffer);
-
-    match endianness {
-        Endianness::BigEndian => {
-            match buffer.len() {
-                1 => Ok(buffer[0] as i64),
-                2 => Ok(reader.read_i16::<byteorder::BigEndian>().unwrap() as i64),
-                4 => Ok(reader.read_i32::<byteorder::BigEndian>().unwrap() as i64),
-                8 => Ok(reader.read_i64::<byteorder::BigEndian>().unwrap()),
-                x => Err(Error::InvalidData(format!["Invalid integer size: {} B", x])),
-            }
-        }
-
-        Endianness::LittleEndian => {
-            match buffer.len() {
-                1 => Ok(buffer[0] as i64),
-                2 => Ok(reader.read_i16::<byteorder::LittleEndian>().unwrap() as i64),
-                4 => Ok(reader.read_i32::<byteorder::LittleEndian>().unwrap() as i64),
-                8 => Ok(reader.read_i64::<byteorder::LittleEndian>().unwrap()),
-                x => Err(Error::InvalidData(format!["Invalid integer size: {} B", x])),
-            }
-        }
+/// that should be parsed (i8, i16, i32 or i64).
+pub fn signed<T, E>(buffer: &[u8]) -> Result<T>
+    where T: num::FromPrimitive, E: ByteOrder
+{
+    let len = buffer.len();
+    let conversion_error = "Failed to convert integer";
+
+    match len {
+        1 => T::from_u8(buffer[0]).ok_or(conversion_error),
+        2 => T::from_i16(E::read_i16(buffer)).ok_or(conversion_error),
+        4 => T::from_i32(E::read_i32(buffer)).ok_or(conversion_error),
+        8 => T::from_i64(E::read_i64(buffer)).ok_or(conversion_error),
+        _ => Err("Invalid integer size"),
     }
+    .map_err(|s| format!["{} ({} B)", s, len])
+    .map_err(Error::InvalidData)
 }
 
-/// Parse a signed integer of a given endianness from a byte buffer.
+/// Parse an unsigned integer of a given endianness from a byte buffer.
 ///
 /// The size of the buffer will be used to determine the size of the integer
-/// that should be parsed (u8, u16, u32 or u64), but the result will be stored
-/// in a u64.
-pub fn unsigned(buffer: &[u8], endianness: Endianness) -> Result<u64> {
-    let mut reader = io::Cursor::new(buffer);
-
-    match endianness {
-        Endianness::BigEndian => {
-            match buffer.len() {
-                1 => Ok(buffer[0] as u64),
-                2 => Ok(reader.read_u16::<byteorder::BigEndian>().unwrap() as u64),
-                4 => Ok(reader.read_u32::<byteorder::BigEndian>().unwrap() as u64),
-                8 => Ok(reader.read_u64::<byteorder::BigEndian>().unwrap()),
-                x => Err(Error::InvalidData(format!["Invalid integer size: {} B", x])),
-            }
-        }
-
-        Endianness::LittleEndian => {
-            match buffer.len() {
-                1 => Ok(buffer[0] as u64),
-                2 => Ok(reader.read_u16::<byteorder::LittleEndian>().unwrap() as u64),
-                4 => Ok(reader.read_u32::<byteorder::LittleEndian>().unwrap() as u64),
-                8 => Ok(reader.read_u64::<byteorder::LittleEndian>().unwrap()),
-                x => Err(Error::InvalidData(format!["Invalid integer size: {} B", x])),
-            }
-        }
+/// that should be parsed (u8, u16, u32 or u64).
+pub fn unsigned<T, E>(buffer: &[u8]) -> Result<T>
+    where T: num::FromPrimitive, E: ByteOrder
+{
+    let len = buffer.len();
+    let conversion_error = "Failed to convert {} B integer";
+
+    match len {
+        1 => T::from_u8(buffer[0]).ok_or(conversion_error),
+        2 => T::from_u16(E::read_u16(buffer)).ok_or(conversion_error),
+        4 => T::from_u32(E::read_u32(buffer)).ok_or(conversion_error),
+        8 => T::from_u64(E::read_u64(buffer)).ok_or(conversion_error),
+        _ => Err("Invalid integer size: {}"),
     }
+    .map_err(|s| format!["{} ({} B)", s, len])
+    .map_err(Error::InvalidData)
 }