get working prototype

Author: cmazakas

.github/workflows/ci.yml

@@ -315,7 +315,7 @@ jobs:
       - name: Install liburing-rs build dependencies
         shell: alpine.sh --root {0}
         run: |
-          apk add --no-cache curl clang;
+          apk add --no-cache curl clang rust-bindgen;
 
       - name: Install Rust
         shell: alpine.sh {0}

Cargo.toml

@@ -10,6 +10,7 @@ readme = "liburing-rs/README.md"
 keywords = ["io_uring", "liburing", "linux"]
 categories = ["asynchronous", "network-programming", "filesystem"]
 documentation = "https://man.archlinux.org/listing/extra/liburing/"
+
 include = [
   "/src/arch",
   "/src/*.c",
@@ -42,6 +43,7 @@ path = "liburing-rs/tests/main.rs"
 
 [features]
 sanitizers = []
+bindgen-cli = []
 
 [target.'cfg(unix)'.build-dependencies]
 bindgen = "0.71.1"

liburing-rs/build.rs

@@ -68,20 +68,64 @@ fn main()
 
     println!("completed `make library` call");
 
-    let bindings = bindgen::Builder::default().clang_arg(format!("-I{}/src/include",
-                                                                 out_path.to_str().unwrap()))
-                                              .clang_arg("-std=gnu11")
-                                              .header("liburing-rs/include/liburing_wrapper.h")
-                                              .anon_fields_prefix("__liburing_anon_")
-                                              .prepend_enum_name(false)
-                                              .derive_default(true)
-                                              .generate()
-                                              .expect("Unable to generate bindings");
-
-    // Write the bindings to the $OUT_DIR/bindings.rs file.
-
-    bindings.write_to_file(out_path.join("liburing_bindings.rs"))
-            .expect("Couldn't write bindings!");
+    if cfg!(feature = "bindgen-cli") {
+        let bindgen_cmd = match env::var("BINDGEN_PATH") {
+            Ok(s) => s,
+            Err(_) => String::from("bindgen"),
+        };
+
+        // I hate this hack for getting the rustc version to pass to bindgen, and maybe there's a better way.
+        let output = std::process::Command::new("rustc").arg("--version")
+                                                        .output()
+                                                        .expect("Failed to run rustc");
+
+        // ❯ rustc --version
+        // rustc 1.90.0 (1159e78c4 2025-09-14)
+        // ❯ rustc +nightly --version
+        // rustc 1.92.0-nightly (4da69dfff 2025-10-01)
+        let rustc_version = String::from_utf8(output.stdout).unwrap();
+        let parts: Vec<&str> = rustc_version.split_whitespace().collect();
+        let rustc_version = parts[1];
+
+        let rustc_version = rustc_version.split("-").next().unwrap();
+
+        let r = std::process::Command::new(&bindgen_cmd).args(["liburing-rs/include/liburing_wrapper.h",
+                                                       "--anon-fields-prefix",
+                                                       "__liburing_anon_",
+                                                       "--no-prepend-enum-name",
+                                                       "--with-derive-default",
+                                                       "--rust-edition", "2024",
+                                                       "--rust-target", rustc_version,
+                                                       "--output",
+                                                       out_path.join("liburing_bindings.rs")
+                                                               .to_str()
+                                                               .unwrap(),
+                                                       "--",
+                                                       "-std=gnu11",
+                                                       &format!("-I{}/src/include",
+                                                                out_path.to_str().unwrap()),
+                                                       ])
+                                                .output()
+                                                .unwrap();
+
+        std::io::stderr().write_all(&r.stderr).unwrap();
+        assert!(r.status.success());
+    } else {
+        let bindings = bindgen::Builder::default().clang_arg(format!("-I{}/src/include",
+                                                                     out_path.to_str().unwrap()))
+                                                  .clang_arg("-std=gnu11")
+                                                  .header("liburing-rs/include/liburing_wrapper.h")
+                                                  .anon_fields_prefix("__liburing_anon_")
+                                                  .prepend_enum_name(false)
+                                                  .derive_default(true)
+                                                  .generate()
+                                                  .expect("Unable to generate bindings");
+
+        // Write the bindings to the $OUT_DIR/bindings.rs file.
+
+        bindings.write_to_file(out_path.join("liburing_bindings.rs"))
+                .expect("Couldn't write bindings!");
+    }
 
     println!("generated bindings");