change!: adjust error return types to handle collision detection

This does mean a lot of churn across the tree, but the change is
usually just an adjustment to variants of an existing error type,
so I expect that most downstream users will require little to no
adaption for this change.

Author: emilazy

gix-commitgraph/src/file/verify.rs

@@ -45,6 +45,8 @@ pub mod checksum {
     #[derive(thiserror::Error, Debug)]
     #[allow(missing_docs)]
     pub enum Error {
+        #[error("failed to hash commit graph file")]
+        Hasher(#[from] gix_hash::hasher::Error),
         #[error(transparent)]
         Verify(#[from] gix_hash::verify::Error),
     }

gix-filter/src/ident.rs

@@ -48,6 +48,8 @@ pub mod apply {
     pub enum Error {
         #[error("Could not allocate buffer")]
         OutOfMemory(#[from] std::collections::TryReserveError),
+        #[error("Could not hash blob")]
+        Hasher(#[from] gix_hash::hasher::Error),
     }
 }
 

gix-hash/src/hasher/io.rs

@@ -6,6 +6,8 @@ use crate::{hasher, Hasher};
 pub enum Error {
     #[error(transparent)]
     Io(#[from] std::io::Error),
+    #[error("Failed to hash data")]
+    Hasher(#[from] hasher::Error),
 }
 
 /// Compute the hash of `kind` for the bytes in the file at `path`, hashing only the first `num_bytes_from_start`

gix-index/src/decode/mod.rs

@@ -16,6 +16,8 @@ mod error {
     pub enum Error {
         #[error(transparent)]
         Header(#[from] decode::header::Error),
+        #[error("Could not hash index data")]
+        Hasher(#[from] gix_hash::hasher::Error),
         #[error("Could not parse entry at index {index}")]
         Entry { index: u32 },
         #[error("Mandatory extension wasn't implemented or malformed.")]
@@ -64,7 +66,7 @@ impl State {
     ) -> Result<(Self, Option<gix_hash::ObjectId>), Error> {
         let _span = gix_features::trace::detail!("gix_index::State::from_bytes()", options = ?_options);
         let (version, num_entries, post_header_data) = header::decode(data, object_hash)?;
-        let start_of_extensions = extension::end_of_index_entry::decode(data, object_hash);
+        let start_of_extensions = extension::end_of_index_entry::decode(data, object_hash)?;
 
         let mut num_threads = gix_features::parallel::num_threads(thread_limit);
         let path_backing_buffer_size = entries::estimate_path_storage_requirements_in_bytes(

gix-index/src/extension/end_of_index_entry/decode.rs

@@ -13,27 +13,27 @@ use crate::{
 /// stored prior to this one to assure they are correct.
 ///
 /// If the checksum wasn't matched, we will ignore this extension entirely.
-pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Option<usize> {
+pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Option<usize>, gix_hash::hasher::Error> {
     let hash_len = object_hash.len_in_bytes();
     if data.len() < MIN_SIZE_WITH_HEADER + hash_len {
-        return None;
+        return Ok(None);
     }
 
     let start_of_eoie = data.len() - MIN_SIZE_WITH_HEADER - hash_len;
     let ext_data = &data[start_of_eoie..data.len() - hash_len];
 
     let (signature, ext_size, ext_data) = extension::decode::header(ext_data);
     if signature != SIGNATURE || ext_size as usize != MIN_SIZE {
-        return None;
+        return Ok(None);
     }
 
     let (offset, checksum) = ext_data.split_at(4);
     let offset = from_be_u32(offset) as usize;
     let Ok(checksum) = gix_hash::oid::try_from_bytes(checksum) else {
-        return None;
+        return Ok(None);
     };
     if offset < header::SIZE || offset > start_of_eoie || checksum.kind() != gix_hash::Kind::Sha1 {
-        return None;
+        return Ok(None);
     }
 
     let mut hasher = gix_hash::hasher(gix_hash::Kind::Sha1);
@@ -45,12 +45,12 @@ pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Option<usize> {
     }
 
     if hasher.finalize().verify(checksum).is_err() {
-        return None;
+        return Ok(None);
     }
     // The last-to-this chunk ends where ours starts
     if last_chunk.map_or(true, |s| s.as_ptr_range().end != (&data[start_of_eoie]) as *const _) {
-        return None;
+        return Ok(None);
     }
 
-    Some(offset)
+    Ok(Some(offset))
 }

gix-index/src/extension/end_of_index_entry/write.rs

@@ -11,7 +11,7 @@ pub fn write_to(
     hash_kind: gix_hash::Kind,
     offset_to_extensions: u32,
     prior_extensions: impl IntoIterator<Item = (Signature, u32)>,
-) -> Result<(), std::io::Error> {
+) -> Result<(), gix_hash::hasher::io::Error> {
     out.write_all(&SIGNATURE)?;
     let extension_size: u32 = 4 + hash_kind.len_in_bytes() as u32;
     out.write_all(&extension_size.to_be_bytes())?;

gix-index/src/file/init.rs

@@ -86,6 +86,7 @@ impl File {
                     )
                     .map_err(|err| match err {
                         hasher::io::Error::Io(err) => Error::Io(err),
+                        hasher::io::Error::Hasher(err) => Error::Decode(err.into()),
                     })?
                     .verify(&expected)
                     .map_err(decode::Error::from)?;

gix-object/src/data.rs

@@ -55,6 +55,8 @@ pub mod verify {
     #[derive(Debug, thiserror::Error)]
     #[allow(missing_docs)]
     pub enum Error {
+        #[error("Failed to hash object")]
+        Hasher(#[from] gix_hash::hasher::Error),
         #[error(transparent)]
         Verify(#[from] gix_hash::verify::Error),
     }

gix-odb/src/store_impls/loose/verify.rs

@@ -19,6 +19,13 @@ pub mod integrity {
             kind: gix_object::Kind,
             id: gix_hash::ObjectId,
         },
+        #[error("{kind} object {expected} could not be hashed")]
+        ObjectHasher {
+            #[source]
+            source: gix_hash::hasher::Error,
+            kind: gix_object::Kind,
+            expected: gix_hash::ObjectId,
+        },
         #[error("{kind} object wasn't re-encoded without change")]
         ObjectEncodeMismatch {
             #[source]

gix-pack/src/verify.rs

@@ -11,6 +11,8 @@ pub mod checksum {
     pub enum Error {
         #[error("Interrupted by user")]
         Interrupted,
+        #[error("Failed to hash data")]
+        Hasher(#[from] gix_hash::hasher::Error),
         #[error(transparent)]
         Verify(#[from] gix_hash::verify::Error),
     }