feat: support shrinking and growing properties

This expands FdtPropertyMut::set_value with:
- shrinking the values by padding with NOPs
- expanding the values if there is a sufficient number of null bytes or
  NOPs after the original value

Author: m4tx

src/error.rs

@@ -113,4 +113,8 @@ pub enum PropertyError {
 /// An error that can occur when mutating a device tree.
 #[derive(Clone, Debug, Eq, Error, PartialEq)]
 #[non_exhaustive]
-pub enum FdtMutError {}
+pub enum FdtMutError {
+    /// Shifting data is required, but not supported.
+    #[error("shifting data is required, but not supported")]
+    ShiftingRequired,
+}

src/fdt_mut/property.rs

@@ -14,7 +14,7 @@ use zerocopy::{FromBytes, big_endian};
 use crate::Property;
 use crate::error::FdtMutError;
 use crate::fdt::property::InnerPropIter;
-use crate::fdt::{FDT_TAGSIZE, Fdt, FdtProperty};
+use crate::fdt::{FDT_NOP, FDT_TAGSIZE, Fdt, FdtProperty};
 
 /// A mutable property of a device tree node.
 #[derive(Debug)]
@@ -58,9 +58,7 @@ impl FdtPropertyMut<'_> {
         let old_padded = Fdt::align_tag_offset(self.len);
         let new_padded = Fdt::align_tag_offset(new_value.len());
 
-        if new_padded != old_padded {
-            todo!("the new value requires shifting data, which is not yet supported");
-        }
+        self.ensure_new_length_fits(old_padded, new_padded)?;
 
         // Update the length in the FDT property header
         let (len_bytes, _) =
@@ -82,11 +80,49 @@ impl FdtPropertyMut<'_> {
             self.data[self.value_offset + i] = 0;
         }
 
+        self.pad_with_nops(old_padded, new_padded);
+
         self.len = new_value.len();
 
         Ok(())
     }
 
+    fn ensure_new_length_fits(
+        &mut self,
+        old_padded: usize,
+        new_padded: usize,
+    ) -> Result<(), FdtMutError> {
+        if new_padded > old_padded {
+            let needed_bytes = new_padded - old_padded;
+
+            let mut offset = self.value_offset + old_padded;
+            for _ in 0..(needed_bytes / FDT_TAGSIZE) {
+                if offset + FDT_TAGSIZE > self.data.len() {
+                    return Err(FdtMutError::ShiftingRequired);
+                }
+
+                let tag_bytes = &self.data[offset..offset + FDT_TAGSIZE];
+                if tag_bytes != FDT_NOP.to_be_bytes() {
+                    return Err(FdtMutError::ShiftingRequired);
+                }
+
+                offset += FDT_TAGSIZE;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn pad_with_nops(&mut self, old_padded: usize, new_padded: usize) {
+        if new_padded < old_padded {
+            let mut offset = self.value_offset + new_padded;
+            while offset < self.value_offset + old_padded {
+                self.data[offset..offset + FDT_TAGSIZE].copy_from_slice(&FDT_NOP.to_be_bytes());
+                offset += FDT_TAGSIZE;
+            }
+        }
+    }
+
     /// Returns the value of this property.
     #[must_use]
     pub fn value(&self) -> &[u8] {

tests/fdt_mut.rs

@@ -6,6 +6,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use dtoolkit::error::FdtMutError;
 use dtoolkit::fdt::Fdt;
 use dtoolkit::fdt_mut::FdtMut;
 use dtoolkit::{Node, Property};
@@ -31,3 +32,50 @@ fn modify_property_in_place() {
     let prop = node.property("str-prop").unwrap();
     assert_eq!(prop.as_str().unwrap(), "hello there");
 }
+
+#[test]
+fn modify_property_shrink_and_grow() {
+    let dtb = include_bytes!("dtb/test_props.dtb");
+    let mut data = dtb.to_vec();
+
+    let mut fdt_mut = FdtMut::new(&mut data).unwrap();
+    let mut node_mut = fdt_mut.find_node_mut("/test-props").unwrap();
+    let mut prop_mut = node_mut.property_mut("str-prop").unwrap();
+
+    let orig_val = b"hello world\0";
+    assert_eq!(prop_mut.value(), orig_val);
+
+    // Shrink the value
+    let short_val = b"hi\0";
+    prop_mut.set_value(short_val).unwrap();
+    assert_eq!(prop_mut.value(), short_val);
+
+    // Check it correctly parses back
+    let fdt = Fdt::new(&data).unwrap();
+    let node = fdt.find_node("/test-props").unwrap();
+    let prop = node.property("str-prop").unwrap();
+    assert_eq!(prop.as_str().unwrap(), "hi");
+
+    // Now grow it back, since the space is now NOPs
+    let mut fdt_mut = FdtMut::new(&mut data).unwrap();
+    let mut node_mut = fdt_mut.find_node_mut("/test-props").unwrap();
+    let mut prop_mut = node_mut.property_mut("str-prop").unwrap();
+
+    let medium_val = b"hello\0";
+    prop_mut.set_value(medium_val).unwrap();
+    assert_eq!(prop_mut.value(), medium_val);
+
+    let fdt = Fdt::new(&data).unwrap();
+    let node = fdt.find_node("/test-props").unwrap();
+    let prop = node.property("str-prop").unwrap();
+    assert_eq!(prop.as_str().unwrap(), "hello");
+
+    // Growing beyond the original space should fail because there are no NOPs
+    let mut fdt_mut = FdtMut::new(&mut data).unwrap();
+    let mut node_mut = fdt_mut.find_node_mut("/test-props").unwrap();
+    let mut prop_mut = node_mut.property_mut("str-prop").unwrap();
+
+    let long_val = b"this is too long\0";
+    let err = prop_mut.set_value(long_val).unwrap_err();
+    assert_eq!(err, FdtMutError::ShiftingRequired);
+}