Rust Bindgen & Miri: Bridging C Libraries and Catching Undefined Behavior Before It Catches You

my-snappy/
├── build.rs          ← generates bindings at build time
├── Cargo.toml
├── src/
│   └── lib.rs        ← safe Rust wrapper
├── wrapper.h         ← thin C header that includes snappy.h
└── libsnappy.a       ← pre-compiled static library

[package]
name = "my-snappy"
version = "0.1.0"
edition = "2021"

[build-dependencies]
bindgen = "0.70"

[dependencies]

use std::path::PathBuf;

fn main() {
    // Tell cargo to re-run this script if the header changes
    println!("cargo:rerun-if-changed=wrapper.h");

    // Link against the static snappy library
    println!("cargo:rustc-link-lib=static=snappy");
    println!("cargo:rustc-link-search=native=.");

    let bindings = bindgen::Builder::default()
        .header("wrapper.h")
        // Only generate bindings for symbols with the 'snappy_' prefix
        .allowlist_function("snappy_.*")
        .allowlist_type("snappy_.*")
        // Generate derive(Debug, PartialEq) where possible
        .derive_debug(true)
        .derive_partialeq(true)
        // Tell bindgen to use core instead of std (for no_std crates)
        // .use_core()
        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
        .generate()
        .expect("Unable to generate bindings");

    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}

// Pull in the generated bindings
#[allow(non_upper_case_globals, non_camel_case_types, dead_code)]
mod ffi {
    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
}

use ffi::snappy_status;

#[derive(Debug, thiserror::Error)]
pub enum SnappyError {
    #[error("invalid input data")]
    InvalidInput,
    #[error("output buffer too small")]
    BufferTooSmall,
}

/// Compress bytes using Snappy. Returns the compressed data.
pub fn compress(input: &[u8]) -> Vec<u8> {
    let max_len = unsafe { ffi::snappy_max_compressed_length(input.len()) };
    let mut output = vec![0u8; max_len];
    let mut output_len = max_len;

    let status = unsafe {
        ffi::snappy_compress(
            input.as_ptr() as *const i8,
            input.len(),
            output.as_mut_ptr() as *mut i8,
            &mut output_len,
        )
    };

    assert_eq!(status, snappy_status::SNAPPY_OK);
    output.truncate(output_len);
    output
}

/// Decompress Snappy-compressed bytes.
pub fn decompress(input: &[u8], max_output: usize) -> Result<Vec<u8>, SnappyError> {
    let mut output = vec![0u8; max_output];
    let mut output_len = max_output;

    let status = unsafe {
        ffi::snappy_uncompress(
            input.as_ptr() as *const i8,
            input.len(),
            output.as_mut_ptr() as *mut i8,
            &mut output_len,
        )
    };

    match status {
        snappy_status::SNAPPY_OK => {
            output.truncate(output_len);
            Ok(output)
        }
        snappy_status::SNAPPY_INVALID_INPUT => Err(SnappyError::InvalidInput),
        snappy_status::SNAPPY_BUFFER_TOO_SMALL => Err(SnappyError::BufferTooSmall),
        _ => unreachable!(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn roundtrip() {
        let original = b"hello world, hello world, hello world!";
        let compressed = compress(original);
        let decompressed = decompress(&compressed, original.len() * 2).unwrap();
        assert_eq!(decompressed, original);
    }
}