kreuzberg 4.0.0.rc2 → 4.0.0

data/vendor/kreuzberg-ffi/src/mime.rs

@@ -0,0 +1,329 @@
+//! MIME type detection and validation functions.
+//!
+//! This module provides FFI functions for:
+//! - Detecting MIME types from file paths, bytes, or content
+//! - Validating MIME types against supported formats
+//! - Getting file extensions for MIME types
+
+use crate::ffi_panic_guard;
+use crate::helpers::{clear_last_error, set_last_error, string_to_c_string};
+use std::ffi::CStr;
+use std::os::raw::c_char;
+use std::ptr;
+
+/// Detect MIME type from a file path.
+///
+/// # Safety
+///
+/// - `file_path` must be a valid null-terminated C string
+/// - The returned string must be freed with `kreuzberg_free_string`
+/// - Returns NULL on error (check `kreuzberg_last_error`)
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn kreuzberg_detect_mime_type(file_path: *const c_char, check_exists: bool) -> *mut c_char {
+    ffi_panic_guard!("kreuzberg_detect_mime_type", {
+        clear_last_error();
+
+        if file_path.is_null() {
+            set_last_error("file_path cannot be NULL".to_string());
+            return ptr::null_mut();
+        }
+
+        let path_str = match unsafe { CStr::from_ptr(file_path) }.to_str() {
+            Ok(s) => s,
+            Err(e) => {
+                set_last_error(format!("Invalid UTF-8 in file path: {}", e));
+                return ptr::null_mut();
+            }
+        };
+
+        match kreuzberg::core::mime::detect_mime_type(path_str, check_exists) {
+            Ok(mime) => match string_to_c_string(mime) {
+                Ok(ptr) => ptr,
+                Err(e) => {
+                    set_last_error(e);
+                    ptr::null_mut()
+                }
+            },
+            Err(e) => {
+                set_last_error(e.to_string());
+                ptr::null_mut()
+            }
+        }
+    })
+}
+
+/// Validate that a MIME type is supported by Kreuzberg.
+///
+/// # Safety
+///
+/// - `mime_type` must be a valid null-terminated C string
+/// - The returned string must be freed with `kreuzberg_free_string`
+/// - Returns NULL on error (check `kreuzberg_last_error`)
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn kreuzberg_validate_mime_type(mime_type: *const c_char) -> *mut c_char {
+    ffi_panic_guard!("kreuzberg_validate_mime_type", {
+        clear_last_error();
+
+        if mime_type.is_null() {
+            set_last_error("mime_type cannot be NULL".to_string());
+            return ptr::null_mut();
+        }
+
+        let mime_type_str = match unsafe { CStr::from_ptr(mime_type) }.to_str() {
+            Ok(s) => s,
+            Err(e) => {
+                set_last_error(format!("Invalid UTF-8 in mime_type: {}", e));
+                return ptr::null_mut();
+            }
+        };
+
+        match kreuzberg::validate_mime_type(mime_type_str) {
+            Ok(validated) => match string_to_c_string(validated) {
+                Ok(ptr) => ptr,
+                Err(e) => {
+                    set_last_error(e);
+                    ptr::null_mut()
+                }
+            },
+            Err(e) => {
+                set_last_error(e.to_string());
+                ptr::null_mut()
+            }
+        }
+    })
+}
+
+/// Detect MIME type from raw bytes.
+///
+/// # Safety
+///
+/// - `bytes` must point to a valid buffer of at least `len` bytes
+/// - The returned string must be freed with `kreuzberg_free_string`
+/// - Returns NULL on error (check `kreuzberg_last_error`)
+///
+/// # Example (C)
+///
+/// ```c
+/// uint8_t data[512];
+/// // ... read data ...
+/// char* mime = kreuzberg_detect_mime_type_from_bytes(data, 512);
+/// if (mime != NULL) {
+///     printf("Detected MIME type: %s\n", mime);
+///     kreuzberg_free_string(mime);
+/// }
+/// ```
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn kreuzberg_detect_mime_type_from_bytes(bytes: *const u8, len: usize) -> *mut c_char {
+    ffi_panic_guard!("kreuzberg_detect_mime_type_from_bytes", {
+        clear_last_error();
+
+        if bytes.is_null() {
+            set_last_error("bytes cannot be NULL".to_string());
+            return ptr::null_mut();
+        }
+
+        let slice = unsafe { std::slice::from_raw_parts(bytes, len) };
+
+        match kreuzberg::core::mime::detect_mime_type_from_bytes(slice) {
+            Ok(mime) => match string_to_c_string(mime) {
+                Ok(ptr) => ptr,
+                Err(e) => {
+                    set_last_error(e);
+                    ptr::null_mut()
+                }
+            },
+            Err(e) => {
+                set_last_error(e.to_string());
+                ptr::null_mut()
+            }
+        }
+    })
+}
+
+/// Detect MIME type from file path (checks extension and reads file content).
+///
+/// # Safety
+///
+/// - `file_path` must be a valid null-terminated C string
+/// - The returned string must be freed with `kreuzberg_free_string`
+/// - Returns NULL on error (check `kreuzberg_last_error`)
+///
+/// # Example (C)
+///
+/// ```c
+/// char* mime = kreuzberg_detect_mime_type_from_path("document.pdf");
+/// if (mime == NULL) {
+///     const char* error = kreuzberg_last_error();
+///     printf("Failed to detect MIME type: %s\n", error);
+/// } else {
+///     printf("MIME type: %s\n", mime);
+///     kreuzberg_free_string(mime);
+/// }
+/// ```
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn kreuzberg_detect_mime_type_from_path(file_path: *const c_char) -> *mut c_char {
+    ffi_panic_guard!("kreuzberg_detect_mime_type_from_path", {
+        clear_last_error();
+
+        if file_path.is_null() {
+            set_last_error("file_path cannot be NULL".to_string());
+            return ptr::null_mut();
+        }
+
+        let path_str = match unsafe { CStr::from_ptr(file_path) }.to_str() {
+            Ok(s) => s,
+            Err(e) => {
+                set_last_error(format!("Invalid UTF-8 in file path: {}", e));
+                return ptr::null_mut();
+            }
+        };
+
+        match kreuzberg::core::mime::detect_mime_type(path_str, true) {
+            Ok(mime) => match string_to_c_string(mime) {
+                Ok(ptr) => ptr,
+                Err(e) => {
+                    set_last_error(e);
+                    ptr::null_mut()
+                }
+            },
+            Err(e) => {
+                set_last_error(e.to_string());
+                ptr::null_mut()
+            }
+        }
+    })
+}
+
+/// Get file extensions for a MIME type.
+///
+/// Returns a JSON array of file extensions (e.g., ["pdf"] for "application/pdf").
+///
+/// # Safety
+///
+/// - `mime_type` must be a valid null-terminated C string
+/// - The returned string must be freed with `kreuzberg_free_string`
+/// - Returns NULL on error (check `kreuzberg_last_error`)
+///
+/// # Example (C)
+///
+/// ```c
+/// char* extensions = kreuzberg_get_extensions_for_mime("application/pdf");
+/// if (extensions != NULL) {
+///     printf("Extensions: %s\n", extensions);
+///     kreuzberg_free_string(extensions);
+/// }
+/// ```
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn kreuzberg_get_extensions_for_mime(mime_type: *const c_char) -> *mut c_char {
+    ffi_panic_guard!("kreuzberg_get_extensions_for_mime", {
+        clear_last_error();
+
+        if mime_type.is_null() {
+            set_last_error("mime_type cannot be NULL".to_string());
+            return ptr::null_mut();
+        }
+
+        let mime_str = match unsafe { CStr::from_ptr(mime_type) }.to_str() {
+            Ok(s) => s,
+            Err(e) => {
+                set_last_error(format!("Invalid UTF-8 in MIME type: {}", e));
+                return ptr::null_mut();
+            }
+        };
+
+        match kreuzberg::core::mime::get_extensions_for_mime(mime_str) {
+            Ok(extensions) => match serde_json::to_string(&extensions) {
+                Ok(json) => match string_to_c_string(json) {
+                    Ok(ptr) => ptr,
+                    Err(e) => {
+                        set_last_error(e);
+                        ptr::null_mut()
+                    }
+                },
+                Err(e) => {
+                    set_last_error(format!("Failed to serialize extensions: {}", e));
+                    ptr::null_mut()
+                }
+            },
+            Err(e) => {
+                set_last_error(e.to_string());
+                ptr::null_mut()
+            }
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::CString;
+
+    #[test]
+    fn test_detect_mime_type_null_path() {
+        let result = unsafe { kreuzberg_detect_mime_type(ptr::null(), false) };
+        assert!(result.is_null());
+    }
+
+    #[test]
+    fn test_validate_mime_type_null() {
+        let result = unsafe { kreuzberg_validate_mime_type(ptr::null()) };
+        assert!(result.is_null());
+    }
+
+    #[test]
+    fn test_detect_mime_type_from_bytes_null() {
+        let result = unsafe { kreuzberg_detect_mime_type_from_bytes(ptr::null(), 0) };
+        assert!(result.is_null());
+    }
+
+    #[test]
+    fn test_detect_mime_type_from_path_null() {
+        let result = unsafe { kreuzberg_detect_mime_type_from_path(ptr::null()) };
+        assert!(result.is_null());
+    }
+
+    #[test]
+    fn test_get_extensions_for_mime_null() {
+        let result = unsafe { kreuzberg_get_extensions_for_mime(ptr::null()) };
+        assert!(result.is_null());
+    }
+
+    #[test]
+    fn test_validate_mime_type_valid() {
+        let mime = CString::new("application/pdf").unwrap();
+        let result = unsafe { kreuzberg_validate_mime_type(mime.as_ptr()) };
+        assert!(!result.is_null());
+        unsafe {
+            crate::kreuzberg_free_string(result);
+        }
+    }
+
+    #[test]
+    fn test_detect_mime_type_from_bytes_pdf() {
+        // PDF magic bytes: %PDF-
+        let pdf_bytes = b"%PDF-1.4\n";
+        let result = unsafe { kreuzberg_detect_mime_type_from_bytes(pdf_bytes.as_ptr(), pdf_bytes.len()) };
+        assert!(!result.is_null());
+
+        let mime_str = unsafe { CStr::from_ptr(result).to_str().unwrap() };
+        assert_eq!(mime_str, "application/pdf");
+
+        unsafe {
+            crate::kreuzberg_free_string(result);
+        }
+    }
+
+    #[test]
+    fn test_get_extensions_for_mime_pdf() {
+        let mime = CString::new("application/pdf").unwrap();
+        let result = unsafe { kreuzberg_get_extensions_for_mime(mime.as_ptr()) };
+        assert!(!result.is_null());
+
+        let extensions_str = unsafe { CStr::from_ptr(result).to_str().unwrap() };
+        assert!(extensions_str.contains("pdf"));
+
+        unsafe {
+            crate::kreuzberg_free_string(result);
+        }
+    }
+}

data/vendor/kreuzberg-ffi/src/panic_shield.rs

@@ -0,0 +1,265 @@
+use kreuzberg::panic_context::PanicContext;
+use std::cell::RefCell;
+
+/// Structured error that includes both the error message and optional panic context.
+#[derive(Debug, Clone)]
+pub struct StructuredError {
+    /// The error message
+    pub message: String,
+    /// Optional panic context if this error originated from a panic
+    pub panic_context: Option<PanicContext>,
+    /// Error code for programmatic error handling
+    pub code: ErrorCode,
+}
+
+/// Error codes for different types of errors.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(i32)]
+pub enum ErrorCode {
+    /// No error
+    Success = 0,
+    /// Generic error
+    GenericError = 1,
+    /// Panic was caught
+    Panic = 2,
+    /// Invalid argument
+    InvalidArgument = 3,
+    /// IO error
+    IoError = 4,
+    /// Parsing error
+    ParsingError = 5,
+    /// OCR error
+    OcrError = 6,
+    /// Missing dependency
+    MissingDependency = 7,
+}
+
+impl StructuredError {
+    /// Creates a new StructuredError from a panic context.
+    pub fn from_panic(context: PanicContext) -> Self {
+        Self {
+            message: context.format(),
+            panic_context: Some(context),
+            code: ErrorCode::Panic,
+        }
+    }
+
+    /// Creates a new StructuredError from a regular error message.
+    pub fn from_message(message: String, code: ErrorCode) -> Self {
+        Self {
+            message,
+            panic_context: None,
+            code,
+        }
+    }
+
+    /// Returns the full error message including panic context if available.
+    pub fn full_message(&self) -> String {
+        if let Some(ref ctx) = self.panic_context {
+            format!("{} (at {}:{}:{})", self.message, ctx.file, ctx.line, ctx.function)
+        } else {
+            self.message.clone()
+        }
+    }
+}
+
+thread_local! {
+    static LAST_STRUCTURED_ERROR: RefCell<Option<StructuredError>> = const { RefCell::new(None) };
+}
+
+/// Sets the last structured error.
+pub fn set_structured_error(error: StructuredError) {
+    LAST_STRUCTURED_ERROR.with(|last| *last.borrow_mut() = Some(error));
+}
+
+/// Gets the last structured error message (for compatibility with existing code).
+pub fn get_last_error_message() -> Option<String> {
+    LAST_STRUCTURED_ERROR.with(|last| last.borrow().as_ref().map(|e| e.full_message()))
+}
+
+/// Gets the last error code.
+pub fn get_last_error_code() -> ErrorCode {
+    LAST_STRUCTURED_ERROR.with(|last| last.borrow().as_ref().map(|e| e.code).unwrap_or(ErrorCode::Success))
+}
+
+/// Gets the last panic context if the last error was a panic.
+pub fn get_last_panic_context() -> Option<PanicContext> {
+    LAST_STRUCTURED_ERROR.with(|last| last.borrow().as_ref().and_then(|e| e.panic_context.clone()))
+}
+
+/// Clears the last structured error.
+pub fn clear_structured_error() {
+    LAST_STRUCTURED_ERROR.with(|last| *last.borrow_mut() = None);
+}
+
+/// Macro to wrap FFI functions with panic catching.
+///
+/// This macro catches panics at FFI boundaries and converts them to structured errors.
+/// It captures file, line, and function information for better error reporting.
+///
+/// # Usage
+///
+/// ```rust,ignore
+/// #[no_mangle]
+/// pub extern "C" fn my_ffi_function(arg: *const c_char) -> *mut ExtractionResult {
+///     ffi_panic_guard!("my_ffi_function", {
+///         // Your FFI function body here
+///         // Return the result normally
+///     })
+/// }
+/// ```
+///
+/// For bool-returning functions:
+///
+/// ```rust,ignore
+/// #[no_mangle]
+/// pub extern "C" fn my_bool_function(arg: *const c_char) -> bool {
+///     ffi_panic_guard_bool!("my_bool_function", {
+///         // Your FFI function body here
+///         // Return true or false normally
+///     })
+/// }
+/// ```
+///
+/// The macro will:
+/// - Catch any panics that occur in the wrapped code
+/// - Create a PanicContext with file/line/function information
+/// - Store the structured error in thread-local storage
+/// - Return a null pointer (for pointer-returning functions) or false (for bool-returning functions) to indicate failure
+#[macro_export]
+macro_rules! ffi_panic_guard {
+    ($function_name:expr, $body:expr) => {{
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
+            Ok(result) => result,
+            Err(panic_info) => {
+                let context =
+                    kreuzberg::panic_context::PanicContext::new(file!(), line!(), $function_name, panic_info.as_ref());
+                $crate::panic_shield::set_structured_error($crate::panic_shield::StructuredError::from_panic(context));
+                std::ptr::null_mut()
+            }
+        }
+    }};
+}
+
+/// Macro to wrap FFI functions that return bool with panic catching.
+///
+/// This variant of ffi_panic_guard returns false on panic (suitable for bool-returning functions).
+#[macro_export]
+macro_rules! ffi_panic_guard_bool {
+    ($function_name:expr, $body:expr) => {{
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
+            Ok(result) => result,
+            Err(panic_info) => {
+                let context =
+                    kreuzberg::panic_context::PanicContext::new(file!(), line!(), $function_name, panic_info.as_ref());
+                $crate::panic_shield::set_structured_error($crate::panic_shield::StructuredError::from_panic(context));
+                false
+            }
+        }
+    }};
+}
+
+/// Macro to wrap FFI functions that return i32 with panic catching.
+///
+/// This variant of ffi_panic_guard returns -1 on panic (suitable for i32-returning functions).
+#[macro_export]
+macro_rules! ffi_panic_guard_i32 {
+    ($function_name:expr, $body:expr) => {{
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
+            Ok(result) => result,
+            Err(panic_info) => {
+                let context =
+                    kreuzberg::panic_context::PanicContext::new(file!(), line!(), $function_name, panic_info.as_ref());
+                $crate::panic_shield::set_structured_error($crate::panic_shield::StructuredError::from_panic(context));
+                -1
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_structured_error_from_panic() {
+        let panic_msg = "test panic".to_string();
+        let ctx = PanicContext::new("test.rs", 42, "test_fn", &panic_msg);
+        let err = StructuredError::from_panic(ctx);
+
+        assert_eq!(err.code, ErrorCode::Panic);
+        assert!(err.panic_context.is_some());
+        assert!(err.message.contains("test panic"));
+    }
+
+    #[test]
+    fn test_structured_error_from_message() {
+        let err = StructuredError::from_message("test error".to_string(), ErrorCode::GenericError);
+
+        assert_eq!(err.code, ErrorCode::GenericError);
+        assert!(err.panic_context.is_none());
+        assert_eq!(err.message, "test error");
+    }
+
+    #[test]
+    fn test_error_storage() {
+        clear_structured_error();
+        assert!(get_last_error_message().is_none());
+
+        let err = StructuredError::from_message("test".to_string(), ErrorCode::IoError);
+        set_structured_error(err);
+
+        assert_eq!(get_last_error_message(), Some("test".to_string()));
+        assert_eq!(get_last_error_code(), ErrorCode::IoError);
+
+        clear_structured_error();
+        assert!(get_last_error_message().is_none());
+    }
+
+    #[test]
+    fn test_panic_context_extraction() {
+        clear_structured_error();
+
+        let panic_msg = "panic message".to_string();
+        let ctx = PanicContext::new("file.rs", 10, "func", &panic_msg);
+        let err = StructuredError::from_panic(ctx);
+        set_structured_error(err);
+
+        let retrieved_ctx = get_last_panic_context();
+        assert!(retrieved_ctx.is_some());
+
+        let ctx = retrieved_ctx.unwrap();
+        assert_eq!(ctx.file, "file.rs");
+        assert_eq!(ctx.line, 10);
+        assert_eq!(ctx.function, "func");
+    }
+
+    #[test]
+    fn test_ffi_panic_guard_success() {
+        let result = crate::ffi_panic_guard!("test_success", { Box::into_raw(Box::new(42)) });
+        assert!(!result.is_null());
+        unsafe {
+            assert_eq!(*result, 42);
+            let _ = Box::from_raw(result);
+        }
+    }
+
+    #[test]
+    fn test_ffi_panic_guard_panic() {
+        clear_structured_error();
+
+        let result: *mut i32 = crate::ffi_panic_guard!("test_panic", {
+            panic!("intentional panic");
+            #[allow(unreachable_code)]
+            Box::into_raw(Box::new(42))
+        });
+
+        assert!(result.is_null());
+        assert!(get_last_error_message().is_some());
+        assert_eq!(get_last_error_code(), ErrorCode::Panic);
+
+        let msg = get_last_error_message().unwrap();
+        assert!(msg.contains("intentional panic"));
+        assert!(msg.contains("test_panic"));
+    }
+}