Support custom crc parameters

libcrc_fast.h

@@ -50,6 +50,21 @@ typedef struct CrcFastDigestHandle {
   struct CrcFastDigest *_0;
 } CrcFastDigestHandle;
 
+/**
+ * Custom CRC parameters
+ */
+typedef struct CrcFastParams {
+  enum CrcFastAlgorithm algorithm;
+  uint8_t width;
+  uint64_t poly;
+  uint64_t init;
+  bool refin;
+  bool refout;
+  uint64_t xorout;
+  uint64_t check;
+  uint64_t keys[23];
+} CrcFastParams;
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -59,6 +74,11 @@ extern "C" {
  */
 struct CrcFastDigestHandle *crc_fast_digest_new(enum CrcFastAlgorithm algorithm);
 
+/**
+ * Creates a new Digest to compute CRC checksums using custom parameters
+ */
+struct CrcFastDigestHandle *crc_fast_digest_new_with_params(struct CrcFastParams params);
+
 /**
  * Updates the Digest with data
  */
@@ -100,13 +120,27 @@ uint64_t crc_fast_digest_get_amount(struct CrcFastDigestHandle *handle);
  */
 uint64_t crc_fast_checksum(enum CrcFastAlgorithm algorithm, const char *data, uintptr_t len);
 
+/**
+ * Helper method to calculate a CRC checksum directly for data using custom parameters
+ */
+uint64_t crc_fast_checksum_with_params(struct CrcFastParams params,
+                                       const char *data,
+                                       uintptr_t len);
+
 /**
  * Helper method to just calculate a CRC checksum directly for a file using algorithm
  */
 uint64_t crc_fast_checksum_file(enum CrcFastAlgorithm algorithm,
                                 const uint8_t *path_ptr,
                                 uintptr_t path_len);
 
+/**
+ * Helper method to calculate a CRC checksum directly for a file using custom parameters
+ */
+uint64_t crc_fast_checksum_file_with_params(struct CrcFastParams params,
+                                            const uint8_t *path_ptr,
+                                            uintptr_t path_len);
+
 /**
  * Combine two CRC checksums using algorithm
  */

src/ffi.rs

@@ -4,14 +4,15 @@
 //!
 //! This module provides a C-compatible interface for the Rust library, allowing
 //! C programs to use the library's functionality.
 
 #![cfg(any(target_arch = "aarch64", target_arch = "x86_64", target_arch = "x86"))]
 
 use crate::CrcAlgorithm;
 use crate::{get_calculator_target, Digest};
 use std::ffi::CStr;
 use std::os::raw::c_char;
 use std::slice;
+use crate::structs::CrcParams;
 
 /// A handle to the Digest object
 #[repr(C)]
@@ -68,6 +69,38 @@
     }
 }
 
+/// Custom CRC parameters
+#[repr(C)]
+pub struct CrcFastParams {
+    pub algorithm: CrcFastAlgorithm,
+    pub width: u8,
+    pub poly: u64,
+    pub init: u64,
+    pub refin: bool,
+    pub refout: bool,
+    pub xorout: u64,
+    pub check: u64,
+    pub keys: [u64; 23],
+}
+
+// Convert from FFI struct to internal struct
+impl From<CrcFastParams> for CrcParams {
+    fn from(value: CrcFastParams) -> Self {
+        CrcParams {
+            algorithm: value.algorithm.into(),
+            name: "custom", // C interface doesn't need the name field
+            width: value.width,
+            poly: value.poly,
+            init: value.init,
+            refin: value.refin,
+            refout: value.refout,
+            xorout: value.xorout,
+            check: value.check,
+            keys: value.keys,
+        }
+    }
+}
+
 /// Creates a new Digest to compute CRC checksums using algorithm
 #[no_mangle]
 pub extern "C" fn crc_fast_digest_new(algorithm: CrcFastAlgorithm) -> *mut CrcFastDigestHandle {
@@ -75,7 +108,15 @@
     let handle = Box::new(CrcFastDigestHandle(Box::into_raw(digest)));
     Box::into_raw(handle)
 }
 
+/// Creates a new Digest to compute CRC checksums using custom parameters
+#[no_mangle]
+pub extern "C" fn crc_fast_digest_new_with_params(params: CrcFastParams) -> *mut CrcFastDigestHandle {
+    let digest = Box::new(Digest::new_with_params(params.into()));
+    let handle = Box::new(CrcFastDigestHandle(Box::into_raw(digest)));
+    Box::into_raw(handle)
+}
+
 /// Updates the Digest with data
 #[no_mangle]
 pub extern "C" fn crc_fast_digest_update(
@@ -197,6 +238,23 @@
     }
 }
 
+/// Helper method to calculate a CRC checksum directly for data using custom parameters
+#[no_mangle]
+pub extern "C" fn crc_fast_checksum_with_params(
+    params: CrcFastParams,
+    data: *const c_char,
+    len: usize,
+) -> u64 {
+    if data.is_null() {
+        return 0;
+    }
+    unsafe {
+        #[allow(clippy::unnecessary_cast)]
+        let bytes = slice::from_raw_parts(data as *const u8, len);
+        crate::checksum_with_params(params.into(), bytes)
+    }
+}
+
 /// Helper method to just calculate a CRC checksum directly for a file using algorithm
 #[no_mangle]
 pub extern "C" fn crc_fast_checksum_file(
@@ -218,6 +276,27 @@
     }
 }
 
+/// Helper method to calculate a CRC checksum directly for a file using custom parameters
+#[no_mangle]
+pub extern "C" fn crc_fast_checksum_file_with_params(
+    params: CrcFastParams,
+    path_ptr: *const u8,
+    path_len: usize,
+) -> u64 {
+    if path_ptr.is_null() {
+        return 0;
+    }
+
+    unsafe {
+        crate::checksum_file_with_params(
+            params.into(),
+            &convert_to_string(path_ptr, path_len),
+            None,
+        )
+            .unwrap_or(0) // Return 0 on error instead of panicking
+    }
+}
+
 /// Combine two CRC checksums using algorithm
 #[no_mangle]
 pub extern "C" fn crc_fast_checksum_combine(