fix(#504): Add BusyBox ar compatibility with ranlib fallback

Fixes compilation failures when using BusyBox ar on Windows (and other
platforms with non-GNU ar implementations).

BusyBox's ar doesn't support the -s flag for symbol table generation.
This change adds graceful fallback behavior:
1. Try ar s first (works with GNU ar and most implementations)
2. If ar s fails, fall back to ranlib (equivalent functionality)
3. If ranlib fails/unavailable, continue without symbol tables
   (acceptable as symbol tables are an optimization, not a requirement)

Includes comprehensive cross-platform test coverage that verifies the
fallback mechanism works correctly.

Fixes #504

Author: naoNao89

src/lib.rs

@@ -2688,7 +2688,26 @@ impl Build {
             // NOTE: We add `s` even if flags were passed using $ARFLAGS/ar_flag, because `s`
             // here represents a _mode_, not an arbitrary flag. Further discussion of this choice
             // can be seen in https://github.com/rust-lang/cc-rs/pull/763.
-            run(ar.arg("s").arg(dst), &self.cargo_output)?;
+
+            // Try ar s first (works with GNU ar and most standard implementations)
+            let ar_result = run(ar.arg("s").arg(dst), &self.cargo_output);
+
+            // If ar s fails (e.g., BusyBox ar doesn't support -s flag), fall back to ranlib.
+            // See https://github.com/rust-lang/cc-rs/issues/504
+            if ar_result.is_err() {
+                // ranlib is equivalent to ar s
+                match self.try_get_ranlib() {
+                    Ok(mut ranlib) => {
+                        // Ignore ranlib errors - symbol tables are recommended but not always required.
+                        // Many linkers work fine without explicit symbol tables.
+                        let _ = run(ranlib.arg(dst), &self.cargo_output);
+                    }
+                    Err(_) => {
+                        // No ranlib available - continue without symbol table generation.
+                        // This is acceptable as symbol tables are an optimization, not a requirement.
+                    }
+                }
+            }
         }
 
         Ok(())

tests/busybox_ar_fallback.rs

@@ -0,0 +1,122 @@
+//! Test for issue #504: BusyBox ar compatibility
+//! BusyBox ar doesn't support the `-s` flag, so we need to fall back to ranlib
+
+#![allow(clippy::disallowed_methods)]
+
+use crate::support::Test;
+
+mod support;
+
+#[test]
+fn busybox_ar_fallback() {
+    // Use standard test setup with proper cc-shim
+    let test = Test::gnu();
+
+    // Override ar with a BusyBox-like version that fails on -s flag
+    // But still creates the archive file for other operations
+    let ar_script = if cfg!(windows) {
+        r#"@echo off
+REM Check for -s flag - fail if present
+for %%a in (%*) do (
+    if "%%a"=="s" (
+        echo BusyBox ar: unknown option -- s >&2
+        exit /b 1
+    )
+)
+
+REM Create the archive file (last argument is typically the output file)
+REM Get last argument
+set "LAST_ARG="
+for %%a in (%*) do set "LAST_ARG=%%a"
+REM Create an empty file to simulate archive creation
+if not "%LAST_ARG%"=="" type nul > "%LAST_ARG%"
+exit /b 0
+"#
+    } else {
+        r#"#!/bin/sh
+# Check for -s flag - fail if present
+for arg in "$@"; do
+    if [ "$arg" = "s" ]; then
+        echo "BusyBox ar: unknown option -- s" >&2
+        exit 1
+    fi
+done
+
+# Create the archive file (last argument is typically the output file)
+# Get the last argument
+for arg in "$@"; do
+    LAST_ARG="$arg"
+done
+# Create an empty file to simulate archive creation
+if [ -n "$LAST_ARG" ]; then
+    touch "$LAST_ARG"
+fi
+exit 0
+"#
+    };
+
+    // Overwrite the shimmed ar with our BusyBox-like version
+    let ar_name = format!("ar{}", std::env::consts::EXE_SUFFIX);
+    let ar_path = test.td.path().join(&ar_name);
+    std::fs::write(&ar_path, ar_script).unwrap();
+
+    #[cfg(unix)]
+    {
+        use std::fs;
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(&ar_path).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&ar_path, perms).unwrap();
+    }
+
+    // Create a mock ranlib that records it was called
+    let ranlib_script = if cfg!(windows) {
+        format!(
+            r#"@echo off
+echo ranlib-called >> "{}\ranlib-calls.txt"
+exit /b 0
+"#,
+            test.td.path().display()
+        )
+    } else {
+        format!(
+            r#"#!/bin/sh
+echo "ranlib-called" >> "{}/ranlib-calls.txt"
+exit 0
+"#,
+            test.td.path().display()
+        )
+    };
+
+    let ranlib_name = format!("ranlib{}", std::env::consts::EXE_SUFFIX);
+    let ranlib_path = test.td.path().join(&ranlib_name);
+    std::fs::write(&ranlib_path, ranlib_script).unwrap();
+
+    #[cfg(unix)]
+    {
+        use std::fs;
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(&ranlib_path).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&ranlib_path, perms).unwrap();
+    }
+
+    // Build with the BusyBox-like ar
+    // This should succeed even though ar -s fails, because it falls back to ranlib
+    test.gcc().file("foo.c").compile("foo");
+
+    // Verify ranlib was called (fallback worked)
+    let ranlib_calls = test.td.path().join("ranlib-calls.txt");
+    assert!(
+        ranlib_calls.exists(),
+        "ranlib should have been called as fallback when ar -s failed"
+    );
+
+    // Verify the contents show ranlib was invoked
+    let content = std::fs::read_to_string(&ranlib_calls).expect("Failed to read ranlib-calls.txt");
+    assert!(
+        content.contains("ranlib-called"),
+        "ranlib-calls.txt should contain 'ranlib-called', but contains: {}",
+        content
+    );
+}

tests/support/mod.rs

@@ -60,7 +60,7 @@ impl Test {
 
     pub fn gnu() -> Test {
         let t = Test::new();
-        t.shim("cc").shim("c++").shim("ar");
+        t.shim("cc").shim("c++").shim("ar").shim("ranlib");
         t
     }
 
@@ -81,7 +81,7 @@ impl Test {
 
     pub fn clang() -> Test {
         let t = Test::new();
-        t.shim("clang").shim("clang++").shim("ar");
+        t.shim("clang").shim("clang++").shim("ar").shim("ranlib");
         t
     }