stdbuf: fix cross-compilation

Partial fix for #6591

The code contained a workaround to enforce that libstdbuf was compiled before stdbuf:
it was declaring libstdbuf as a build-dependency of stdbuf. This broke cross-compilation,
because build-dependencies were compiled for the host architecture, and not for the target architecture.

Changes:

1. Removed cpp/cpp_build dependencies:

The cpp, cpp_build, and related dependencies were removed.
The build system no longer uses the C++-based approach for building libstdbuf, because cross-compiling c++ in a build.rs file
would have added a lot of complexity.

2. Build libstdbuf as a separate Rust crate using Cargo, to make cross-compilation work.
In the future, "bindeps" could be used to simplify the code, however this is available only in cargo nightly
at the moment.
The ctor crate is now used to provide constructor attributes for initialization.

3. Remove "feat_require_crate_cpp" which is not needed any more, since stdbuf was the only utility using the cpp crate.

4. Switched from C++/cpp macro-based initialization to using the Rust ctor crate for library initialization.
Provided Rust implementations for getting stdin, stdout, and stderr pointers.

Tests:

This commit fixes this test:
cross test --target aarch64-unknown-linux-gnu --features stdbuf test_stdbuf::test_setvbuf_resolution -- --nocapture

Signed-off-by: Etienne Cordonnier <[email protected]>

Author: Ecordonnier

Cargo.lock

@@ -36,6 +36,8 @@ expensive_tests = []
 test_risky_names = []
 # * only build `uudoc` when `--feature uudoc` is activated
 uudoc = ["zip", "dep:uuhelp_parser"]
+## Optional feature for stdbuf
+# "use-external-stdbuf" == use an external libstdbuf.so for stdbuf instead of embedding it
 ## features
 # "feat_acl" == enable support for ACLs (access control lists; by using`--features feat_acl`)
 # NOTE:
@@ -158,7 +160,6 @@ feat_os_macos = [
 feat_os_unix = [
   "feat_Tier1",
   #
-  "feat_require_crate_cpp",
   "feat_require_unix",
   "feat_require_unix_utmpx",
   "feat_require_unix_hostid",
@@ -185,8 +186,6 @@ feat_os_unix_android = [
 #
 # ** NOTE: these `feat_require_...` sets should be minimized as much as possible to encourage cross-platform availability of utilities
 #
-# "feat_require_crate_cpp" == set of utilities requiring the `cpp` crate (which fail to compile on several platforms; as of 2020-04-23)
-feat_require_crate_cpp = ["stdbuf"]
 # "feat_require_unix" == set of utilities requiring support which is only available on unix platforms (as of 2020-04-23)
 feat_require_unix = [
   "chgrp",
@@ -220,8 +219,6 @@ feat_require_selinux = ["chcon", "runcon"]
 feat_os_unix_fuchsia = [
   "feat_common_core",
   #
-  "feat_require_crate_cpp",
-  #
   "chgrp",
   "chmod",
   "chown",
@@ -289,6 +286,7 @@ clap_mangen = "0.2"
 compare = "0.1.0"
 coz = { version = "0.1.3" }
 crossterm = "0.29.0"
+ctor = "0.4.1"
 ctrlc = { version = "3.4.4", features = ["termination"] }
 dns-lookup = { version = "2.0.4" }
 exacl = "0.12.0"
@@ -517,7 +515,6 @@ uucore = { workspace = true, features = [
 walkdir = { workspace = true }
 hex-literal = "1.0.0"
 rstest = { workspace = true }
-ctor = "0.4.1"
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
 procfs = { version = "0.17", default-features = false }

Cargo.toml

@@ -19,12 +19,10 @@ path = "src/stdbuf.rs"
 
 [dependencies]
 clap = { workspace = true }
+libstdbuf = { package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
 tempfile = { workspace = true }
 uucore = { workspace = true, features = ["parser"] }
 
-[build-dependencies]
-libstdbuf = { version = "0.0.30", package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
-
 [[bin]]
 name = "stdbuf"
 path = "src/main.rs"

src/uu/stdbuf/Cargo.toml

@@ -5,9 +5,9 @@
 // spell-checker:ignore (ToDO) dylib libstdbuf deps liblibstdbuf
 
 use std::env;
-use std::env::current_exe;
 use std::fs;
 use std::path::Path;
+use std::process::Command;
 
 #[cfg(not(any(target_vendor = "apple", target_os = "windows")))]
 mod platform {
@@ -25,25 +25,103 @@ mod platform {
 }
 
 fn main() {
-    let current_exe = current_exe().unwrap();
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=src/libstdbuf/src/libstdbuf.rs");
 
-    let out_dir_string = env::var("OUT_DIR").unwrap();
-    let out_dir = Path::new(&out_dir_string);
+    let out_dir = env::var("OUT_DIR").expect("OUT_DIR not set");
+    let target = env::var("TARGET").unwrap_or_else(|_| "unknown".to_string());
 
-    let deps_dir = current_exe.ancestors().nth(3).unwrap().join("deps");
-    dbg!(&deps_dir);
+    // Create a separate build directory for libstdbuf to avoid conflicts
+    let build_dir = Path::new(&out_dir).join("libstdbuf-build");
+    fs::create_dir_all(&build_dir).expect("Failed to create build directory");
 
-    let libstdbuf = deps_dir
-        .read_dir()
-        .unwrap()
-        .flatten()
-        .find(|entry| {
-            let n = entry.file_name();
-            let name = n.to_string_lossy();
+    // Get the cargo executable
+    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
 
-            name.starts_with("liblibstdbuf") && name.ends_with(platform::DYLIB_EXT)
-        })
-        .expect("unable to find libstdbuf");
+    // Build libstdbuf as a separate process with its own target directory
+    // to avoid interference with the main build
+    let mut cmd = Command::new(&cargo);
+    cmd.current_dir(Path::new("src/libstdbuf")).args([
+        "build",
+        "--target-dir",
+        build_dir.to_str().unwrap(),
+    ]);
 
-    fs::copy(libstdbuf.path(), out_dir.join("libstdbuf.so")).unwrap();
+    // Pass the target architecture if we're cross-compiling
+    if !target.is_empty() && target != "unknown" {
+        cmd.arg("--target").arg(&target);
+    }
+
+    let status = cmd.status().expect("Failed to build libstdbuf");
+
+    if !status.success() {
+        panic!("Failed to build libstdbuf");
+    }
+
+    // Copy the built library to OUT_DIR for include_bytes! to find
+    let lib_name = format!("liblibstdbuf{}", platform::DYLIB_EXT);
+    let dest_path = Path::new(&out_dir).join(format!("libstdbuf{}", platform::DYLIB_EXT));
+
+    // Check multiple possible locations for the built library
+    let possible_paths = if !target.is_empty() && target != "unknown" {
+        vec![
+            build_dir.join("debug").join(&target).join(&lib_name),
+            build_dir.join(&target).join("debug").join(&lib_name),
+            build_dir
+                .join(&target)
+                .join("debug")
+                .join("deps")
+                .join(&lib_name),
+            build_dir
+                .join(&target)
+                .join("debug")
+                .join(format!("lib{}", lib_name)),
+        ]
+    } else {
+        vec![
+            build_dir.join("debug").join(&lib_name),
+            build_dir.join("debug").join("deps").join(&lib_name),
+        ]
+    };
+
+    // Try to find the library in any of the possible locations
+    let mut found = false;
+    for source_path in &possible_paths {
+        if source_path.exists() {
+            fs::copy(source_path, &dest_path).expect("Failed to copy libstdbuf library");
+            found = true;
+            break;
+        }
+    }
+
+    if !found {
+        // Try to find any .so files to help with debugging
+        find_libs(&build_dir, &platform::DYLIB_EXT);
+
+        // Fail the build with helpful error message
+        panic!(
+            "Could not find built libstdbuf library. Searched in: {:?}.",
+            possible_paths
+        );
+    }
+}
+
+// Helper function to recursively find library files
+fn find_libs(dir: &Path, ext: &str) {
+    if !dir.exists() || !dir.is_dir() {
+        return;
+    }
+
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.filter_map(Result::ok) {
+            let path = entry.path();
+            if path.is_dir() {
+                find_libs(&path, ext);
+            } else if let Some(extension) = path.extension() {
+                if extension == ext.trim_start_matches('.') {
+                    println!("Found library: {}", path.display());
+                }
+            }
+        }
+    }
 }

src/uu/stdbuf/build.rs

@@ -13,14 +13,8 @@ edition.workspace = true
 [lib]
 name = "libstdbuf"
 path = "src/libstdbuf.rs"
-crate-type = [
-  "cdylib",
-  "rlib",
-] # XXX: note: the rlib is just to prevent Cargo from spitting out a warning
+crate-type = ["cdylib"]
 
 [dependencies]
-cpp = "0.5.10"
 libc = { workspace = true }
-
-[build-dependencies]
-cpp_build = "0.5.10"
+ctor = { workspace = true }

src/uu/stdbuf/src/libstdbuf/Cargo.toml

@@ -4,8 +4,24 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (ToDO) libstdbuf
 
-use cpp_build::Config;
+use std::env;
 
 fn main() {
-    Config::new().pic(true).build("src/libstdbuf.rs");
+    // Get and print target information for debugging
+    let target = env::var("TARGET").unwrap_or_else(|_| "unknown".to_string());
+    println!("Building libstdbuf for target triple: {}", target);
+
+    if let Ok(target_arch) = env::var("CARGO_CFG_TARGET_ARCH") {
+        println!("Building for target architecture: {}", target_arch);
+    }
+
+    // Make sure we're building position-independent code for use with LD_PRELOAD
+    println!("cargo:rustc-link-arg=-fPIC");
+
+    // Ensure the library doesn't have any undefined symbols
+    println!("cargo:rustc-link-arg=-z");
+    println!("cargo:rustc-link-arg=defs");
+
+    // Rebuild if the libstdbuf.rs file changes
+    println!("cargo:rerun-if-changed=src/libstdbuf.rs");
 }

src/uu/stdbuf/src/libstdbuf/build.rs

@@ -2,34 +2,41 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (ToDO) IOFBF IOLBF IONBF cstdio setvbuf
+// spell-checker:ignore (ToDO) IOFBF IOLBF IONBF setvbuf
 
-use cpp::cpp;
+use ctor::ctor;
 use libc::{_IOFBF, _IOLBF, _IONBF, FILE, c_char, c_int, fileno, size_t};
 use std::env;
 use std::ptr;
 
-cpp! {{
-    #include <cstdio>
-
-    extern "C" {
-        void __stdbuf(void);
+// This runs automatically when the library is loaded via LD_PRELOAD
+#[ctor]
+fn init() {
+    unsafe { __stdbuf() };
+}
 
-        void __attribute((constructor))
-        __stdbuf_init(void) {
-            __stdbuf();
-        }
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn __stdbuf_get_stdin() -> *mut FILE {
+    unsafe extern "C" {
+        static mut stdin: *mut FILE;
+    }
+    unsafe { stdin }
+}
 
-        FILE *__stdbuf_get_stdin() { return stdin; }
-        FILE *__stdbuf_get_stdout() { return stdout; }
-        FILE *__stdbuf_get_stderr() { return stderr; }
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn __stdbuf_get_stdout() -> *mut FILE {
+    unsafe extern "C" {
+        static mut stdout: *mut FILE;
     }
-}}
+    unsafe { stdout }
+}
 
-unsafe extern "C" {
-    fn __stdbuf_get_stdin() -> *mut FILE;
-    fn __stdbuf_get_stdout() -> *mut FILE;
-    fn __stdbuf_get_stderr() -> *mut FILE;
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn __stdbuf_get_stderr() -> *mut FILE {
+    unsafe extern "C" {
+        static mut stderr: *mut FILE;
+    }
+    unsafe { stderr }
 }
 
 fn set_buffer(stream: *mut FILE, value: &str) {
@@ -60,17 +67,25 @@ fn set_buffer(stream: *mut FILE, value: &str) {
     }
 }
 
-/// # Safety
-/// ToDO ... (safety note)
+/// Main function that gets called when the library is loaded to adjust buffering
+///
+/// This function is meant to be called automatically when the library is loaded
+/// via LD_PRELOAD. It accesses stdio handles and modifies their buffering.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn __stdbuf() {
     if let Ok(val) = env::var("_STDBUF_E") {
-        set_buffer(unsafe { __stdbuf_get_stderr() }, &val);
+        unsafe {
+            set_buffer(__stdbuf_get_stderr(), &val);
+        }
     }
     if let Ok(val) = env::var("_STDBUF_I") {
-        set_buffer(unsafe { __stdbuf_get_stdin() }, &val);
+        unsafe {
+            set_buffer(__stdbuf_get_stdin(), &val);
+        }
     }
     if let Ok(val) = env::var("_STDBUF_O") {
-        set_buffer(unsafe { __stdbuf_get_stdout() }, &val);
+        unsafe {
+            set_buffer(__stdbuf_get_stdout(), &val);
+        }
     }
 }

src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs

@@ -133,6 +133,15 @@ fn get_preload_env(tmp_dir: &TempDir) -> UResult<(String, PathBuf)> {
     let (preload, extension) = preload_strings()?;
     let inject_path = tmp_dir.path().join("libstdbuf").with_extension(extension);
 
+    // Check if the library was properly embedded (not empty)
+    if STDBUF_INJECT.is_empty() {
+        return Err(USimpleError::new(
+            1,
+            "libstdbuf.so is empty or missing. This may happen during cross-compilation.\n\
+             Please ensure the build completed successfully and libstdbuf.so is present.",
+        ));
+    }
+
     let mut file = File::create(&inject_path)?;
     file.write_all(STDBUF_INJECT)?;