Update EfiVar printing

    * Define "verbose" variable printing
    * Define "decimal" variable printing

Author: nvinson

src/lib/efivar/efivar_display.rs

@@ -0,0 +1,66 @@
+use std::fmt;
+use types::{EfiVariable, EfiVariableAttribute};
+
+pub struct Verbose<'a>(pub &'a EfiVariable<'a>);
+pub struct Decimal<'a>(pub &'a EfiVariable<'a>);
+
+impl fmt::Display for Decimal<'_> {
+    fn fmt(&self, f:&mut fmt::Formatter<'_>) -> fmt::Result {
+        for (i, b) in self.0.data.iter().enumerate() {
+            if (i > 0) && (i % 16 == 0) {
+                f.write_str("  ")?;
+            }
+            if i % 16 < 8 {
+                f.write_str(&format!("{} ", b))?;
+            } else {
+                f.write_str(&format!(" {}", b))?;
+            }
+        }
+        return Ok(());
+    }
+}
+
+impl fmt::Display for Verbose<'_> {
+    fn fmt(&self, f:&mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("GUID: {}\n", self.0.guid))?;
+        f.write_str(&format!("Name: \"{}\"\n", self.0.name))?;
+        f.write_str("Attributes:\n")?;
+        let mut sorted_attrs:Vec<&EfiVariableAttribute> =
+            self.0.attributes.clone().into_iter().collect();
+        sorted_attrs.sort_unstable_by(|a1, a2| <u32>::from(*a1).cmp(&<u32>::from(*a2)));
+        for a in sorted_attrs.iter() {
+            f.write_str(&format!("\t{}\n", String::from(*a)))?;
+        }
+
+        f.write_str("Value:\n")?;
+        for i in (0..self.0.data.len()).step_by(16) {
+            f.write_str(&format!("{:08x}  ", i))?;
+
+            let mut decode:[u8; 16] = [0; 16];
+            let mut line_iter = self.0.data.iter().skip(i);
+            for j in i..i + 16 {
+                match line_iter.next() {
+                    Some(c) => {
+                        if (0x20 < *c) && (*c < 0x7e) {
+                            decode[j - i] = u32::from(*c) as u8;
+                        } else {
+                            decode[j - i] = u32::from('.') as u8;
+                        }
+                        if j < i + 8 {
+                            f.write_str(&format!("{:02x} ", u8::from(*c)))?;
+                        } else {
+                            f.write_str(&format!(" {:02x}", u8::from(*c)))?;
+                        }
+                    }
+                    None => {
+                        decode[j - i] = u32::from(' ') as u8;
+                        f.write_str("   ")?;
+                    }
+                };
+            }
+            f.write_str(&format!("  |{}|\n", std::str::from_utf8(&decode).unwrap()))?;
+        }
+        f.write_str(&format!("{:08x}\n", self.0.data.len()))?;
+        return Ok(());
+    }
+}

src/lib/efivar/mod.rs

@@ -1,16 +1,17 @@
 pub mod types;
+pub mod efivar_display;
 
-pub mod attributes {
+pub mod efi_variable_attributes {
     use types::EfiVariableAttribute;
 
     pub static NON_VOLATILE:EfiVariableAttribute
-        = EfiVariableAttribute::init("Non Volatile", 0x1);
+        = EfiVariableAttribute::init("Non-Volatile", 0x1);
 
     pub static BOOTSERVICE_ACCESS:EfiVariableAttribute
-        = EfiVariableAttribute::init("Bootservice Access", 0x2);
+        = EfiVariableAttribute::init("Boot Service Access", 0x2);
 
     pub static RUNTIME_ACCESS:EfiVariableAttribute
-        = EfiVariableAttribute::init("Runtime Access", 0x4);
+        = EfiVariableAttribute::init("Runtime Service Access", 0x4);
 
     pub static HARDWARE_ERROR_RECORD:EfiVariableAttribute
         = EfiVariableAttribute::init("Hardware Error Record", 0x8);

src/lib/efivar/types/efi_guid.rs

@@ -100,7 +100,6 @@ macro_rules! from_bytes {
 
 from_bytes!(i8, u8);
 
-
 impl FromStr for EfiGuid {
     type Err = EfiGuidError;
 
@@ -137,3 +136,11 @@ impl FromStr for EfiGuid {
         });
     }
 }
+
+impl TryFrom<&str> for EfiGuid {
+    type Error = EfiGuidError;
+
+    fn try_from(value: &str) -> Result<Self, EfiGuidError> {
+        return value.parse::<Self>();
+    }
+}

src/lib/efivar/types/efi_variable.rs

@@ -1,32 +1,10 @@
-use std::fmt;
-
-pub use super::efi_guid::EfiGuid;
-pub use super::efi_variable_attribute::EfiVariableAttribute;
+use std::collections::HashSet;
+use super::efi_guid::EfiGuid;
+use super::efi_variable_attribute::EfiVariableAttribute;
 
 pub struct EfiVariable<'a> {
-    pub attributes: Vec<&'a EfiVariableAttribute>,
+    pub attributes: HashSet<&'a EfiVariableAttribute>,
     pub guid: EfiGuid,
-    pub name: &'a str,
+    pub name: Box<str>,
     pub data: Vec<u8>,
 }
-
-impl fmt::Display for EfiVariable<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&format!("EfiVariable {{ attributes: ["))?;
-        for a in self.attributes.iter() {
-            f.write_str(&format!("{}", *a)[..])?;
-        }
-        f.write_str(&format!("], guid: \"{}\", name: \"{}\", data: [", self.guid, self.name)[..])?;
-        if self.data.len() > 0 {
-            f.write_str(&format!("{:02x}", self.data[0])[..])?;
-        }
-        if self.data.len() > 1 {
-            for b in self.data[1..].iter() {
-                f.write_str(&format!(" {:02x}", *b)[..])?;
-            };
-        }
-        f.write_str("] }}")?;
-
-        return Ok(());
-    }
-}

src/lib/efivar/types/efi_variable_attribute.rs

@@ -20,7 +20,7 @@ macro_rules! EfiVariableAttribute_field_value_maps {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Hash, Eq, PartialEq)]
 pub struct EfiVariableAttribute {
     name: &'static str,
     value: u64,