Remove the dependency on hex (#820)

Author: jessebraham

Cargo.lock

@@ -41,7 +41,6 @@ directories     = { version = "5.0.1", optional = true }
 env_logger      = { version = "0.11.6", optional = true }
 esp-idf-part    = "0.5.0"
 flate2          = "1.0.35"
-hex             = { version = "0.4.3", features = ["serde"] }
 indicatif       = { version = "0.17.9", optional = true }
 log             = "0.4.22"
 md-5            = "0.10.6"

espflash/Cargo.toml

@@ -32,31 +32,32 @@ pub struct Connection {
 #[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct UsbDevice {
     /// USB Vendor ID
-    #[serde(serialize_with = "parse_u16_hex", deserialize_with = "parse_hex_u16")]
+    #[serde(
+        serialize_with = "serialize_u16_to_hex",
+        deserialize_with = "deserialize_hex_to_u16"
+    )]
     pub vid: u16,
     /// USB Product ID
-    #[serde(serialize_with = "parse_u16_hex", deserialize_with = "parse_hex_u16")]
+    #[serde(
+        serialize_with = "serialize_u16_to_hex",
+        deserialize_with = "deserialize_hex_to_u16"
+    )]
     pub pid: u16,
 }
 
-fn parse_hex_u16<'de, D>(deserializer: D) -> Result<u16, D::Error>
+fn deserialize_hex_to_u16<'de, D>(deserializer: D) -> Result<u16, D::Error>
 where
     D: serde::Deserializer<'de>,
 {
-    let s = String::deserialize(deserializer)?;
-    let bytes = hex::decode(if s.len() % 2 == 1 {
-        format!("0{}", s)
-    } else {
-        s
-    })
-    .map_err(serde::de::Error::custom)?;
-    let padding = vec![0; 2_usize.saturating_sub(bytes.len())];
-    let vec = [&padding[..], &bytes[..]].concat();
-    let decimal = u16::from_be_bytes(vec.try_into().unwrap());
-    Ok(decimal)
+    let hex = String::deserialize(deserializer)?.to_lowercase();
+    let hex = hex.trim_start_matches("0x");
+
+    let int = u16::from_str_radix(hex, 16).map_err(serde::de::Error::custom)?;
+
+    Ok(int)
 }
 
-fn parse_u16_hex<S>(decimal: &u16, serializer: S) -> Result<S::Ok, S::Error>
+fn serialize_u16_to_hex<S>(decimal: &u16, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: serde::Serializer,
 {
@@ -172,12 +173,15 @@ mod tests {
 
     #[derive(Debug, Deserialize, Serialize)]
     struct TestData {
-        #[serde(serialize_with = "parse_u16_hex", deserialize_with = "parse_hex_u16")]
+        #[serde(
+            serialize_with = "serialize_u16_to_hex",
+            deserialize_with = "deserialize_hex_to_u16"
+        )]
         value: u16,
     }
 
     #[test]
-    fn test_parse_hex_u16() {
+    fn test_deserialize_hex_to_u16() {
         // Test no padding
         let result: Result<TestData, _> = toml::from_str(r#"value = "aaaa""#);
         assert_eq!(result.unwrap().value, 0xaaaa);
@@ -208,7 +212,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_u16_hex() {
+    fn test_serialize_u16_to_hex() {
         // Valid hexadecimal input with 1 digit
         let result: Result<TestData, _> = toml::from_str(r#"value = "1""#);
         assert_eq!(result.unwrap().value, 0x1);

espflash/src/cli/config.rs

@@ -4,7 +4,6 @@ use std::{borrow::Cow, io::Write, iter::once, mem::size_of};
 
 use bytemuck::{bytes_of, from_bytes, Pod, Zeroable};
 use esp_idf_part::{AppType, DataType, Partition, PartitionTable, SubType, Type};
-use log::debug;
 use sha2::{Digest, Sha256};
 use xmas_elf::ElfFile;
 
@@ -181,10 +180,10 @@ impl<'a> IdfBootloaderFormat<'a> {
         let mut hasher = Sha256::new();
         hasher.update(&bootloader[..bootloader_sha_start]);
         let hash = hasher.finalize();
-        debug!(
+        log::debug!(
             "Updating bootloader SHA256 from {} to {}",
-            hex::encode(&bootloader[bootloader_sha_start..bootloader_sha_end]),
-            hex::encode(hash)
+            encode_hex(&bootloader[bootloader_sha_start..bootloader_sha_end]),
+            encode_hex(hash)
         );
         bootloader.to_mut()[bootloader_sha_start..bootloader_sha_end].copy_from_slice(&hash);
 
@@ -481,6 +480,21 @@ fn update_checksum(data: &[u8], mut checksum: u8) -> u8 {
     checksum
 }
 
+fn encode_hex<T>(data: T) -> String
+where
+    T: AsRef<[u8]>,
+{
+    const HEX_CHARS: &[u8] = b"0123456789abcdef";
+
+    let mut s = String::new();
+    for byte in data.as_ref() {
+        s.push(HEX_CHARS[(byte >> 4) as usize] as char);
+        s.push(HEX_CHARS[(byte & 0x0F) as usize] as char);
+    }
+
+    s
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -498,4 +512,13 @@ mod tests {
             .unwrap();
         assert_eq!(header.flash_config, 0x5F);
     }
+
+    #[test]
+    fn test_encode_hex() {
+        assert_eq!(encode_hex(&[0u8]), "00");
+        assert_eq!(encode_hex(&[10u8]), "0a");
+        assert_eq!(encode_hex(&[255u8]), "ff");
+
+        assert_eq!(encode_hex(&[222u8, 202, 251, 173]), "decafbad");
+    }
 }