Merge pull request #2059 from bradlarsen/main

gix-pack: delta application is a fallible operation

Author: Byron

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::apply::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,6 +1,21 @@
+///
+pub mod apply {
+    /// Returned when failing to apply deltas.
+    #[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) {
+pub(crate) fn decode_header_size(d: &[u8]) -> (u64, usize) {
     let mut i = 0;
     let mut size = 0u64;
     let mut consumed = 0;
@@ -15,7 +30,7 @@ pub fn decode_header_size(d: &[u8]) -> (u64, usize) {
     (size, consumed)
 }
 
-pub fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) {
+pub(crate) fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> Result<(), apply::Error> {
     let mut i = 0;
     while let Some(cmd) = data.get(i) {
         i += 1;
@@ -55,16 +70,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| apply::Error::DeltaCopyBaseSliceMismatch)?;
             }
-            0 => panic!("encountered unsupported command code: 0"),
+            0 => return Err(apply::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| apply::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::apply::Error),
 }
 
 impl From<TryReserveError> for Error {

gix-pack/src/data/mod.rs

@@ -128,4 +128,5 @@ impl File {
     }
 }
 
-pub(crate) mod delta;
+///
+pub mod delta;