crun-sys 0.1.0

Rust FFI bindings for libcrun (OCI container runtime, Linux only)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! build.rs for crun-sys
//!
//! Generates Rust FFI bindings for libcrun using bindgen.
//! Requires libcrun development headers and pkg-config.
//!
//! NOTE: libcrun is Linux-only. On non-Linux platforms,
//! this build script does nothing (stub module provided).

fn main() {
    // libcrun is Linux-only (uses cgroups, namespaces, seccomp)
    #[cfg(not(target_os = "linux"))]
    {
        println!("cargo:warning=libcrun is Linux-only, building stub module");
        return;
    }

    #[cfg(target_os = "linux")]
    linux_build();
}

#[cfg(target_os = "linux")]
fn linux_build() {
    use std::env;
    use std::path::PathBuf;

    // Locate libcrun via pkg-config
    let libcrun = match pkg_config::Config::new()
        .atleast_version("1.8")
        .probe("libcrun")
    {
        Ok(lib) => lib,
        Err(e) => {
            println!("cargo:warning=pkg-config failed to find libcrun: {}", e);
            println!("cargo:warning=Falling back to system defaults...");
            
            // Fallback: link directly
            println!("cargo:rustc-link-lib=crun");
            println!("cargo:rustc-link-lib=yajl");
            println!("cargo:rustc-link-lib=seccomp");
            println!("cargo:rustc-link-lib=cap");
            
            // Try common include paths
            let include_paths = vec![
                "/usr/include",
                "/usr/local/include",
            ];
            
            let mut builder = bindgen::Builder::default()
                .header("wrapper.h")
                .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
                .allowlist_function("libcrun_.*")
                .allowlist_function("crun_.*")
                .allowlist_type("libcrun_.*")
                .allowlist_type("crun_.*")
                .allowlist_type("runtime_spec_schema_.*")
                .allowlist_var("LIBCRUN_.*")
                .generate_comments(true)
                .derive_debug(true)
                .derive_default(true)
                .size_t_is_usize(true);
            
            for path in &include_paths {
                builder = builder.clang_arg(format!("-I{}", path));
            }
            
            let bindings = builder
                .generate()
                .expect("Unable to generate 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!");
            
            println!("cargo:rerun-if-changed=wrapper.h");
            return;
        }
    };

    // Link libcrun and its dependencies
    for lib in &libcrun.libs {
        println!("cargo:rustc-link-lib={}", lib);
    }
    for path in &libcrun.link_paths {
        println!("cargo:rustc-link-search=native={}", path.display());
    }

    // Generate bindings with bindgen
    let mut builder = bindgen::Builder::default()
        .header("wrapper.h")
        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
        // Allowlist libcrun functions
        .allowlist_function("libcrun_.*")
        .allowlist_function("crun_.*")
        // Allowlist libcrun types
        .allowlist_type("libcrun_.*")
        .allowlist_type("crun_.*")
        .allowlist_type("runtime_spec_schema_.*")
        // Allowlist constants
        .allowlist_var("LIBCRUN_.*")
        // Options
        .generate_comments(true)
        .derive_debug(true)
        .derive_default(true)
        .size_t_is_usize(true);

    // Add include paths from pkg-config
    for path in &libcrun.include_paths {
        builder = builder.clang_arg(format!("-I{}", path.display()));
    }

    let bindings = builder
        .generate()
        .expect("Unable to generate bindings for libcrun");

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

    // Rerun if wrapper or environment changes
    println!("cargo:rerun-if-changed=wrapper.h");
    println!("cargo:rerun-if-env-changed=PKG_CONFIG_PATH");
    println!("cargo:rerun-if-env-changed=LIBRARY_PATH");
    println!("cargo:rerun-if-env-changed=C_INCLUDE_PATH");
}