gix-pack: delta application is a fallible operation

Author: bradlarsen

gix-pack/src/cache/delta/traverse/mod.rs

@@ -41,6 +41,8 @@ pub enum Error {
     },
     #[error("Failed to spawn thread when switching to work-stealing mode")]
     SpawnThread(#[from] std::io::Error),
+    #[error(transparent)]
+    Delta(#[from] crate::data::delta::Error),
 }
 
 /// Additional context passed to the `inspect_object(…)` function of the [`Tree::traverse()`] method.

gix-pack/src/cache/delta/traverse/resolve.rs

@@ -188,7 +188,7 @@ where
             header_ofs += consumed;
 
             fully_resolved_delta_bytes.resize(result_size as usize, 0);
-            data::delta::apply(&base_bytes, fully_resolved_delta_bytes, &delta_bytes[header_ofs..]);
+            data::delta::apply(&base_bytes, fully_resolved_delta_bytes, &delta_bytes[header_ofs..])?;
 
             // FIXME: this actually invalidates the "pack_offset()" computation, which is not obvious to consumers
             //        at all
@@ -367,7 +367,7 @@ where
                                         &base_bytes,
                                         &mut fully_resolved_delta_bytes,
                                         &delta_bytes[header_ofs..],
-                                    );
+                                    )?;
 
                                     // FIXME: this actually invalidates the "pack_offset()" computation, which is not obvious to consumers
                                     //        at all

gix-pack/src/data/delta.rs

@@ -1,3 +1,15 @@
+/// Returned by [`Tree::traverse()`]
+#[derive(thiserror::Error, Debug)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error("Encountered unsupported command code: 0")]
+    UnsupportedCommandCode,
+    #[error("Delta copy from base: byte slices must match")]
+    DeltaCopyBaseSliceMismatch,
+    #[error("Delta copy data: byte slices must match")]
+    DeltaCopyDataSliceMismatch,
+}
+
 /// Given the decompressed pack delta `d`, decode a size in bytes (either the base object size or the result object size)
 /// Equivalent to [this canonical git function](https://github.com/git/git/blob/311531c9de557d25ac087c1637818bd2aad6eb3a/delta.h#L89)
 pub fn decode_header_size(d: &[u8]) -> (u64, usize) {
@@ -15,7 +27,7 @@ pub fn decode_header_size(d: &[u8]) -> (u64, usize) {
     (size, consumed)
 }
 
-pub fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) {
+pub fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> Result<(), Error> {
     let mut i = 0;
     while let Some(cmd) = data.get(i) {
         i += 1;
@@ -55,16 +67,18 @@ pub fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) {
                 }
                 let ofs = ofs as usize;
                 std::io::Write::write(&mut target, &base[ofs..ofs + size as usize])
-                    .expect("delta copy from base: byte slices must match");
+                    .map_err(|_e| Error::DeltaCopyBaseSliceMismatch)?;
             }
-            0 => panic!("encountered unsupported command code: 0"),
+            0 => return Err(Error::UnsupportedCommandCode),
             size => {
                 std::io::Write::write(&mut target, &data[i..i + *size as usize])
-                    .expect("delta copy data: slice sizes to match up");
+                    .map_err(|_e| Error::DeltaCopyDataSliceMismatch)?;
                 i += *size as usize;
             }
         }
     }
     assert_eq!(i, data.len());
     assert_eq!(target.len(), 0);
+
+    Ok(())
 }

gix-pack/src/data/file/decode/entry.rs

@@ -374,7 +374,7 @@ impl File {
             if delta_idx + 1 == chain_len {
                 last_result_size = Some(result_size);
             }
-            delta::apply(&source_buf[..base_size], &mut target_buf[..result_size], data);
+            delta::apply(&source_buf[..base_size], &mut target_buf[..result_size], data)?;
             // use the target as source for the next delta
             std::mem::swap(&mut source_buf, &mut target_buf);
         }

gix-pack/src/data/file/decode/mod.rs

@@ -19,6 +19,8 @@ pub enum Error {
     EntryType(#[from] crate::data::entry::decode::Error),
     #[error("Entry too large to fit in memory")]
     OutOfMemory,
+    #[error(transparent)]
+    Delta(#[from] crate::data::delta::Error),
 }
 
 impl From<TryReserveError> for Error {