net_util: added ser/de support for MacAddr

Implemented the Serialize and Deserialize traits for struct MacAddr.
Added checks to ensure we only accept MAC address components which
contain two digits. Also, added some unit tests for the new functionality.

Signed-off-by: Alexandru Agache <[email protected]>

Author: alexandruag

net_util/Cargo.toml

@@ -5,10 +5,12 @@ authors = ["The Chromium OS Authors"]
 
 [dependencies]
 libc = ">=0.2.39"
+serde = "=1.0.27"
 
 net_sys = { path = "../net_sys" }
 sys_util = { path = "../sys_util" }
 
 [dev-dependencies]
 lazy_static = "=1.0.0"
 pnet = "=0.21.0"
+serde_json = "=1.0.9"

net_util/src/lib.rs

@@ -9,6 +9,7 @@
 extern crate lazy_static;
 extern crate libc;
 extern crate net_sys;
+extern crate serde;
 extern crate sys_util;
 
 mod mac;

net_util/src/mac.rs

@@ -1,5 +1,8 @@
 use std::result::Result;
 
+use serde::de::{Deserialize, Deserializer, Error};
+use serde::ser::{Serialize, Serializer};
+
 pub const MAC_ADDR_LEN: usize = 6;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -21,6 +24,9 @@ impl MacAddr {
         }
 
         for i in 0..MAC_ADDR_LEN {
+            if v[i].len() != 2 {
+                return Err(s.as_ref());
+            }
             bytes[i] = u8::from_str_radix(v[i], 16).map_err(|_| s.as_ref())?;
         }
 
@@ -40,27 +46,62 @@ impl MacAddr {
     }
 }
 
+impl Serialize for MacAddr {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for MacAddr {
+    fn deserialize<D>(deserializer: D) -> Result<MacAddr, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        MacAddr::parse_str(&s).map_err(|_| D::Error::custom("The provided MAC address is invalid."))
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    extern crate serde_json;
+
     use super::*;
 
     #[test]
     fn test_mac_addr() {
         // too long
         assert!(MacAddr::parse_str("aa:aa:aa:aa:aa:aa:aa").is_err());
+
         // invalid hex
         assert!(MacAddr::parse_str("aa:aa:aa:aa:aa:ax").is_err());
 
+        // single digit mac address component should be invalid
+        assert!(MacAddr::parse_str("aa:aa:aa:aa:aa:b").is_err());
+
+        // components with more than two digits should also be invalid
+        assert!(MacAddr::parse_str("aa:aa:aa:aa:aa:bbb").is_err());
+
         let mac = MacAddr::parse_str("12:34:56:78:9a:BC").unwrap();
 
         println!("parsed MAC address: {}", mac.to_string());
 
         let bytes = mac.get_bytes();
-        assert_eq!(bytes[0], 0x12);
-        assert_eq!(bytes[1], 0x34);
-        assert_eq!(bytes[2], 0x56);
-        assert_eq!(bytes[3], 0x78);
-        assert_eq!(bytes[4], 0x9a);
-        assert_eq!(bytes[5], 0xbc);
+        assert_eq!(bytes, [0x12u8, 0x34, 0x56, 0x78, 0x9a, 0xbc]);
+    }
+
+    #[test]
+    fn test_mac_addr_serialization_and_deserialization() {
+        let mac: MacAddr =
+            serde_json::from_str("\"12:34:56:78:9a:bc\"").expect("MacAddr deserialization failed.");
+
+        let bytes = mac.get_bytes();
+        assert_eq!(bytes, [0x12u8, 0x34, 0x56, 0x78, 0x9a, 0xbc]);
+
+        let s = serde_json::to_string(&mac).expect("MacAddr serialization failed.");
+        assert_eq!(s, "\"12:34:56:78:9a:bc\"");
     }
 }