Tauri 2.0 Native Dependencies Using C/C++ Libraries

// FFI (Foreign Function Interface) Overview

// C types in Rust:
// C type          | Rust type
// ----------------|------------------
// char            | c_char / i8
// unsigned char   | c_uchar / u8
// short           | c_short / i16
// unsigned short  | c_ushort / u16
// int             | c_int / i32
// unsigned int    | c_uint / u32
// long            | c_long
// unsigned long   | c_ulong
// long long       | c_longlong / i64
// float           | f32
// double          | f64
// void*           | *mut c_void
// const char*     | *const c_char
// size_t          | usize

// Basic FFI example
// C library: mylib.h
/*
#ifndef MYLIB_H
#define MYLIB_H

int add(int a, int b);
double multiply(double a, double b);
void print_hello(const char* name);

#endif
*/

// Rust FFI bindings
use std::os::raw::{c_char, c_int, c_double};

extern "C" {
    fn add(a: c_int, b: c_int) -> c_int;
    fn multiply(a: c_double, b: c_double) -> c_double;
    fn print_hello(name: *const c_char);
}

// Safe Rust wrapper
pub fn safe_add(a: i32, b: i32) -> i32 {
    unsafe {
        add(a, b)
    }
}

pub fn safe_multiply(a: f64, b: f64) -> f64 {
    unsafe {
        multiply(a, b)
    }
}

pub fn safe_print_hello(name: &str) {
    use std::ffi::CString;
    
    let c_name = CString::new(name).expect("CString conversion failed");
    
    unsafe {
        print_hello(c_name.as_ptr());
    }
}

// String handling in FFI
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

// Rust string to C string
fn rust_to_c_string(s: &str) -> *mut c_char {
    let c_string = CString::new(s).expect("CString conversion failed");
    c_string.into_raw()  // Transfer ownership to C
}

// C string to Rust string
unsafe fn c_to_rust_string(ptr: *const c_char) -> String {
    let c_str = CStr::from_ptr(ptr);
    c_str.to_string_lossy().into_owned()
}

// Free C string (called from C)
#[no_mangle]
pub extern "C" fn free_rust_string(ptr: *mut c_char) {
    if !ptr.is_null() {
        unsafe {
            let _ = CString::from_raw(ptr);
            // CString dropped here, memory freed
        }
    }
}

// Array/slice handling
extern "C" {
    fn process_array(arr: *const c_int, len: usize) -> c_int;
}

fn safe_process_array(arr: &[i32]) -> i32 {
    unsafe {
        process_array(arr.as_ptr(), arr.len())
    }
}

// Struct passing
#[repr(C)]  // Use C memory layout
pub struct Point {
    pub x: f64,
    pub y: f64,
}

extern "C" {
    fn distance(p1: *const Point, p2: *const Point) -> c_double;
}

pub fn safe_distance(p1: &Point, p2: &Point) -> f64 {
    unsafe {
        distance(p1 as *const Point, p2 as *const Point)
    }
}

// Callback functions
type Callback = extern "C" fn(c_int) -> c_int;

extern "C" {
    fn register_callback(cb: Callback);
    fn call_callback(value: c_int) -> c_int;
}

extern "C" fn my_callback(value: c_int) -> c_int {
    println!("Callback called with: {}", value);
    value * 2
}

pub fn setup_callback() {
    unsafe {
        register_callback(my_callback);
    }
}

// Error handling across FFI
#[repr(C)]
pub struct Result {
    pub success: bool,
    pub value: c_int,
    pub error_message: *const c_char,
}

extern "C" {
    fn fallible_operation(input: c_int) -> Result;
}

pub fn safe_fallible_operation(input: i32) -> std::result::Result<i32, String> {
    unsafe {
        let result = fallible_operation(input);
        
        if result.success {
            Ok(result.value)
        } else {
            let error = c_to_rust_string(result.error_message);
            Err(error)
        }
    }
}

// Memory management rules:
// 1. Who allocates, who frees?
// 2. Use Box::into_raw() to transfer ownership to C
// 3. Use Box::from_raw() to reclaim ownership from C
// 4. Never access freed memory
// 5. Ensure proper cleanup on panic

// Cargo.toml
[build-dependencies]
bindgen = "0.69"

// build.rs - Build script for generating bindings
use std::env;
use std::path::PathBuf;

fn main() {
    // Tell cargo to look for libraries in specific directory
    println!("cargo:rustc-link-search=/usr/local/lib");
    
    // Link to the C library
    println!("cargo:rustc-link-lib=mylib");
    
    // Tell cargo to invalidate the built crate whenever the wrapper changes
    println!("cargo:rerun-if-changed=wrapper.h");
    
    // Generate bindings
    let bindings = bindgen::Builder::default()
        // Input header file
        .header("wrapper.h")
        // Add include paths
        .clang_arg("-I/usr/local/include")
        // Tell bindgen which types/functions to generate bindings for
        .allowlist_function("mylib_.*")
        .allowlist_type("MyStruct")
        .allowlist_var("MY_CONSTANT")
        // Block certain types
        .blocklist_type("internal_type")
        // Generate comments from C headers
        .generate_comments(true)
        // Use Rust naming conventions
        .rustified_enum(".*")
        // Layout tests to verify struct layouts match
        .layout_tests(true)
        // Generate bindings
        .generate()
        .expect("Unable to generate bindings");
    
    // Write bindings to file
    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}

// wrapper.h - C header wrapper
/*
#include <mylib.h>

// Additional helper functions if needed
*/

// src/lib.rs - Include generated bindings
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

// Create safe wrappers around generated bindings
pub mod safe {
    use super::*;
    use std::ffi::{CStr, CString};
    use std::os::raw::c_char;
    
    pub struct MyLibrary {
        handle: *mut mylib_context_t,
    }
    
    impl MyLibrary {
        pub fn new() -> Result<Self, String> {
            unsafe {
                let handle = mylib_init();
                if handle.is_null() {
                    return Err("Failed to initialize library".to_string());
                }
                Ok(Self { handle })
            }
        }
        
        pub fn process(&self, data: &str) -> Result<String, String> {
            let c_data = CString::new(data)
                .map_err(|e| format!("Invalid string: {}", e))?;
            
            unsafe {
                let result_ptr = mylib_process(self.handle, c_data.as_ptr());
                
                if result_ptr.is_null() {
                    return Err("Processing failed".to_string());
                }
                
                let result = CStr::from_ptr(result_ptr)
                    .to_string_lossy()
                    .into_owned();
                
                // Free C string
                mylib_free_string(result_ptr);
                
                Ok(result)
            }
        }
    }
    
    impl Drop for MyLibrary {
        fn drop(&mut self) {
            unsafe {
                if !self.handle.is_null() {
                    mylib_cleanup(self.handle);
                }
            }
        }
    }
}

// Advanced bindgen configuration
fn main() {
    let bindings = bindgen::Builder::default()
        .header("wrapper.h")
        
        // Custom type mappings
        .type_alias("my_size_t", "usize")
        
        // Opaque types (don't generate internals)
        .opaque_type("internal_context")
        
        // Derive traits
        .derive_debug(true)
        .derive_default(true)
        .derive_eq(true)
        .derive_partialeq(true)
        
        // Enum handling
        .rustified_enum("MyEnum")
        .constified_enum_module("MyFlags")
        
        // Function name prefix
        .prepend_enum_name(false)
        
        // Raw lines (add custom code)
        .raw_line("use std::os::raw::c_void;")
        
        // Formatting
        .rustfmt_bindings(true)
        
        // Generate
        .generate()
        .expect("Unable to generate bindings");
    
    // Write bindings
    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}

// Real-world example: OpenCV bindings
fn build_opencv_bindings() {
    let opencv_include = "/usr/local/include/opencv4";
    
    println!("cargo:rustc-link-search=/usr/local/lib");
    println!("cargo:rustc-link-lib=opencv_core");
    println!("cargo:rustc-link-lib=opencv_imgproc");
    println!("cargo:rustc-link-lib=opencv_highgui");
    
    let bindings = bindgen::Builder::default()
        .header("opencv_wrapper.h")
        .clang_arg(format!("-I{}", opencv_include))
        .allowlist_function("cv.*")
        .allowlist_type("cv::.*")
        .enable_cxx_namespaces()
        .generate()
        .expect("Unable to generate OpenCV bindings");
    
    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("opencv_bindings.rs"))
        .expect("Couldn't write bindings!");
}

// Cargo.toml
[build-dependencies]
cc = "1.0"

// build.rs - Compile C code
fn main() {
    cc::Build::new()
        .file("src/native/mylib.c")
        .compile("mylib");
}

// src/native/mylib.c
#include <stdio.h>
#include <string.h>

int add(int a, int b) {
    return a + b;
}

void process_string(const char* input, char* output, int max_len) {
    snprintf(output, max_len, "Processed: %s", input);
}

// src/lib.rs - Use compiled C code
use std::os::raw::{c_char, c_int};
use std::ffi::{CStr, CString};

extern "C" {
    fn add(a: c_int, b: c_int) -> c_int;
    fn process_string(input: *const c_char, output: *mut c_char, max_len: c_int);
}

pub fn safe_add(a: i32, b: i32) -> i32 {
    unsafe { add(a, b) }
}

pub fn safe_process_string(input: &str) -> String {
    let c_input = CString::new(input).expect("CString conversion failed");
    let mut buffer = vec![0u8; 1024];
    
    unsafe {
        process_string(
            c_input.as_ptr(),
            buffer.as_mut_ptr() as *mut c_char,
            buffer.len() as c_int
        );
        
        CStr::from_ptr(buffer.as_ptr() as *const c_char)
            .to_string_lossy()
            .into_owned()
    }
}

// Advanced cc configuration
fn main() {
    cc::Build::new()
        // Source files
        .file("src/native/module1.c")
        .file("src/native/module2.c")
        
        // Include directories
        .include("src/native/include")
        .include("/usr/local/include")
        
        // Compiler flags
        .flag("-Wall")
        .flag("-O3")
        
        // Defines
        .define("MY_DEFINE", "1")
        .define("DEBUG", None)
        
        // C standard
        .std("c11")
        
        // Optimization level
        .opt_level(3)
        
        // Debug info
        .debug(true)
        
        // Warnings
        .warnings(true)
        .warnings_into_errors(false)
        
        // Static/shared library
        .static_flag(true)
        
        // Compile
        .compile("mynativelib");
}

// Compiling C++ code
fn main() {
    cc::Build::new()
        .cpp(true)  // Enable C++ mode
        .file("src/native/module.cpp")
        .flag("-std=c++17")
        .compile("mycpplib");
}

// Conditional compilation
fn main() {
    let mut build = cc::Build::new();
    
    build
        .file("src/native/common.c")
        .include("src/native/include");
    
    // Platform-specific files
    if cfg!(target_os = "windows") {
        build.file("src/native/windows.c");
    } else if cfg!(target_os = "macos") {
        build.file("src/native/macos.c");
    } else if cfg!(target_os = "linux") {
        build.file("src/native/linux.c");
    }
    
    build.compile("platform_lib");
}

// Multiple libraries
fn main() {
    // Compile first library
    cc::Build::new()
        .file("src/native/lib1.c")
        .compile("lib1");
    
    // Compile second library
    cc::Build::new()
        .file("src/native/lib2.c")
        .compile("lib2");
}

// With pkg-config
fn main() {
    // Find library using pkg-config
    let library = pkg_config::Config::new()
        .probe("openssl")
        .unwrap();
    
    let mut build = cc::Build::new();
    
    build.file("src/native/ssl_wrapper.c");
    
    // Add include paths from pkg-config
    for path in &library.include_paths {
        build.include(path);
    }
    
    build.compile("ssl_wrapper");
}

// Real-world example: Image processing library
fn main() {
    // Link system libraries
    println!("cargo:rustc-link-lib=dylib=png");
    println!("cargo:rustc-link-lib=dylib=jpeg");
    
    // Compile wrapper code
    cc::Build::new()
        .file("src/native/image_wrapper.c")
        .include("/usr/local/include")
        .flag("-O3")
        .flag("-Wall")
        .compile("image_wrapper");
    
    // Generate bindings
    let bindings = bindgen::Builder::default()
        .header("src/native/image_wrapper.h")
        .generate()
        .expect("Unable to generate bindings");
    
    let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}

// Linking system libraries in build.rs

fn main() {
    // Dynamic linking (shared library)
    println!("cargo:rustc-link-lib=dylib=sqlite3");
    
    // Static linking
    println!("cargo:rustc-link-lib=static=mystaticlib");
    
    // Framework (macOS)
    println!("cargo:rustc-link-lib=framework=CoreFoundation");
    
    // Library search path
    println!("cargo:rustc-link-search=/usr/local/lib");
    println!("cargo:rustc-link-search=native=/opt/lib");
}

// Using pkg-config
// Cargo.toml
[build-dependencies]
pkg-config = "0.3"

// build.rs
fn main() {
    pkg_config::Config::new()
        .probe("sqlite3")
        .unwrap();
}

// Platform-specific linking
fn main() {
    if cfg!(target_os = "windows") {
        println!("cargo:rustc-link-lib=dylib=user32");
        println!("cargo:rustc-link-lib=dylib=gdi32");
    } else if cfg!(target_os = "macos") {
        println!("cargo:rustc-link-lib=framework=CoreFoundation");
        println!("cargo:rustc-link-lib=framework=Security");
    } else if cfg!(target_os = "linux") {
        println!("cargo:rustc-link-lib=dylib=X11");
        println!("cargo:rustc-link-lib=dylib=pthread");
    }
}

// Example: SQLite integration
// build.rs
fn main() {
    // Try pkg-config first
    if pkg_config::Config::new().probe("sqlite3").is_err() {
        // Fallback to manual linking
        println!("cargo:rustc-link-lib=sqlite3");
        
        if cfg!(target_os = "windows") {
            println!("cargo:rustc-link-search=C:/sqlite");
        } else {
            println!("cargo:rustc-link-search=/usr/local/lib");
        }
    }
}

// src/database.rs
use std::os::raw::{c_char, c_int};
use std::ffi::{CStr, CString};

#[repr(C)]
struct sqlite3 {
    _private: [u8; 0],
}

#[repr(C)]
struct sqlite3_stmt {
    _private: [u8; 0],
}

extern "C" {
    fn sqlite3_open(
        filename: *const c_char,
        ppdb: *mut *mut sqlite3
    ) -> c_int;
    
    fn sqlite3_close(db: *mut sqlite3) -> c_int;
    
    fn sqlite3_exec(
        db: *mut sqlite3,
        sql: *const c_char,
        callback: Option<extern "C" fn(*mut c_void, c_int, *mut *mut c_char, *mut *mut c_char) -> c_int>,
        arg: *mut c_void,
        errmsg: *mut *mut c_char
    ) -> c_int;
    
    fn sqlite3_free(ptr: *mut c_void);
}

pub struct Database {
    db: *mut sqlite3,
}

impl Database {
    pub fn open(path: &str) -> Result<Self, String> {
        let c_path = CString::new(path)
            .map_err(|e| format!("Invalid path: {}", e))?;
        
        let mut db: *mut sqlite3 = std::ptr::null_mut();
        
        unsafe {
            let rc = sqlite3_open(c_path.as_ptr(), &mut db);
            
            if rc != 0 {
                if !db.is_null() {
                    sqlite3_close(db);
                }
                return Err(format!("Failed to open database: {}", rc));
            }
        }
        
        Ok(Self { db })
    }
    
    pub fn execute(&self, sql: &str) -> Result<(), String> {
        let c_sql = CString::new(sql)
            .map_err(|e| format!("Invalid SQL: {}", e))?;
        
        let mut errmsg: *mut c_char = std::ptr::null_mut();
        
        unsafe {
            let rc = sqlite3_exec(
                self.db,
                c_sql.as_ptr(),
                None,
                std::ptr::null_mut(),
                &mut errmsg
            );
            
            if rc != 0 {
                let error = if !errmsg.is_null() {
                    let err_str = CStr::from_ptr(errmsg)
                        .to_string_lossy()
                        .into_owned();
                    sqlite3_free(errmsg as *mut c_void);
                    err_str
                } else {
                    format!("Unknown error: {}", rc)
                };
                
                return Err(error);
            }
        }
        
        Ok(())
    }
}

impl Drop for Database {
    fn drop(&mut self) {
        unsafe {
            if !self.db.is_null() {
                sqlite3_close(self.db);
            }
        }
    }
}

// Tauri command using native library
#[tauri::command]
fn query_database(path: String, sql: String) -> Result<(), String> {
    let db = Database::open(&path)?;
    db.execute(&sql)?;
    Ok(())
}