Merge branch 'main' into sort/sort-debug-warn.sh

Author: mattsu2020

.github/workflows/GnuTests.yml

@@ -2,7 +2,7 @@ name: GnuTests
 
 # spell-checker:ignore (abbrev/names) CodeCov gnulib GnuTests Swatinem
 # spell-checker:ignore (jargon) submodules devel
-# spell-checker:ignore (libs/utils) autopoint chksum dpkg getenforce getlimits gperf lcov libexpect limactl pyinotify setenforce shopt texinfo valgrind libattr libcap taiki-e
+# spell-checker:ignore (libs/utils) autopoint chksum dpkg getenforce getlimits gperf lcov libexpect limactl pyinotify setenforce shopt texinfo valgrind libattr libcap taiki-e zstd cpio
 # spell-checker:ignore (options) Ccodegen Coverflow Cpanic Zpanic
 # spell-checker:ignore (people) Dawid Dziurla * dawidd dtolnay
 # spell-checker:ignore (vars) FILESET SUBDIRS XPASS
@@ -31,6 +31,7 @@ env:
   TEST_STTY_FULL_SUMMARY_FILE: 'gnu-stty-full-result.json'
   TEST_SELINUX_FULL_SUMMARY_FILE: 'selinux-gnu-full-result.json'
   TEST_SELINUX_ROOT_FULL_SUMMARY_FILE: 'selinux-root-gnu-full-result.json'
+  TEST_SMACK_FULL_SUMMARY_FILE: 'smack-gnu-full-result.json'
 
 jobs:
   native:
@@ -318,8 +319,52 @@ jobs:
           gnu/tests-selinux/*.log
           gnu/tests-selinux/*/*.log.gz
 
+  smack:
+    name: Run GNU tests (SMACK)
+    runs-on: ubuntu-24.04
+    steps:
+    - name: Checkout code (uutils)
+      uses: actions/checkout@v6
+      with:
+        path: 'uutils'
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: rustfmt
+    - uses: Swatinem/rust-cache@v2
+      with:
+        workspaces: "./uutils -> target"
+    - name: Checkout code (GNU coreutils)
+      run: (mkdir -p gnu && cd gnu && bash ../uutils/util/fetch-gnu.sh)
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y qemu-system-x86 zstd cpio
+    - name: Run GNU SMACK tests
+      run: |
+        cd uutils
+        bash util/run-gnu-tests-smack-ci.sh "$GITHUB_WORKSPACE/gnu" "$GITHUB_WORKSPACE/gnu/tests-smack"
+    - name: Extract testing info into JSON
+      run: |
+        python3 uutils/util/gnu-json-result.py gnu/tests-smack > ${{ env.TEST_SMACK_FULL_SUMMARY_FILE }}
+    - name: Upload SMACK json results
+      uses: actions/upload-artifact@v5
+      with:
+        name: smack-gnu-full-result
+        path: ${{ env.TEST_SMACK_FULL_SUMMARY_FILE }}
+    - name: Compress SMACK test logs
+      run: gzip gnu/tests-smack/*/*.log 2>/dev/null || true
+    - name: Upload SMACK test logs
+      uses: actions/upload-artifact@v5
+      with:
+        name: smack-test-logs
+        path: |
+          gnu/tests-smack/*.log
+          gnu/tests-smack/*/*.log.gz
+
   aggregate:
-    needs: [native, selinux]
+    needs: [native, selinux, smack]
     permissions:
       actions: read  # for dawidd6/action-download-artifact to query and download artifacts
       contents: read  # for actions/checkout to fetch code
@@ -384,6 +429,12 @@ jobs:
         name: selinux-root-gnu-full-result
         path: results
         merge-multiple: true
+    - name: Download smack json results
+      uses: actions/download-artifact@v7
+      with:
+        name: smack-gnu-full-result
+        path: results
+        merge-multiple: true
     - name: Extract/summarize testing info
       id: summary
       shell: bash
@@ -394,8 +445,8 @@ jobs:
         path_UUTILS='uutils'
 
         json_count=$(ls -l results/*.json | wc -l)
-        if [[ "$json_count" -ne 5 ]]; then
-          echo "::error ::Failed to download all results json files (expected 4 files, found $json_count); failing early"
+        if [[ "$json_count" -ne 6 ]]; then
+          echo "::error ::Failed to download all results json files (expected 6 files, found $json_count); failing early"
           ls -lR results || true
           exit 1
         fi

CONTRIBUTING.md

@@ -87,6 +87,7 @@ are some tips for writing good issues:
   - What platform are you on?
 - Provide a way to reliably reproduce the issue.
 - Be as specific as possible!
+- Please provide the output with LANG=C, except for locale-related bugs.
 
 ### Writing Documentation
 

Cargo.lock

@@ -65,6 +65,10 @@ feat_selinux = [
   "selinux",
   "stat/selinux",
 ]
+# "feat_smack" == enable support for SMACK Security Context (by using `--features feat_smack`)
+# NOTE:
+# * Running a uutils compiled with `feat_smack` requires a SMACK enabled Kernel at run time.
+feat_smack = ["ls/smack"]
 ##
 ## feature sets
 ## (common/core and Tier1) feature sets

Cargo.toml

@@ -32,14 +32,6 @@ options might be missing or different behavior might be experienced.
 We provide prebuilt binaries at https://github.com/uutils/coreutils/releases/latest .
 It is recommended to install from main branch if you install from source.
 
-To install it:
-
-```shell
-cargo install --git https://github.com/uutils/coreutils coreutils
-# cargo install --git https://github.com/uutils/coreutils uu_true # for one util only
-~/.cargo/bin/coreutils
-```
-
 </div>
 
 <!-- markdownlint-disable-next-line MD026 -->

README.md

@@ -29,12 +29,23 @@ cfg_langinfo! {
     use std::ffi::CStr;
     use std::sync::OnceLock;
     use nix::libc;
+
+    #[cfg(test)]
+    use std::sync::Mutex;
 }
 
 cfg_langinfo! {
     /// Cached locale date/time format string
     static DEFAULT_FORMAT_CACHE: OnceLock<&'static str> = OnceLock::new();
 
+    /// Mutex to serialize setlocale() calls during tests.
+    ///
+    /// setlocale() is process-global, so parallel tests that call it can
+    /// interfere with each other. This mutex ensures only one test accesses
+    /// locale functions at a time.
+    #[cfg(test)]
+    static LOCALE_MUTEX: Mutex<()> = Mutex::new(());
+
     /// Returns the default date format string for the current locale.
     ///
     /// The format respects locale preferences for time display (12-hour vs 24-hour),
@@ -55,6 +66,11 @@ cfg_langinfo! {
 
     /// Retrieves the date/time format string from the system locale
     fn get_locale_format_string() -> Option<String> {
+        // In tests, acquire mutex to prevent race conditions with setlocale()
+        // which is process-global and not thread-safe
+        #[cfg(test)]
+        let _lock = LOCALE_MUTEX.lock().unwrap();
+
         unsafe {
             // Set locale from environment variables
             libc::setlocale(libc::LC_TIME, c"".as_ptr());
@@ -158,11 +174,24 @@ mod tests {
 
         #[test]
         fn test_c_locale_format() {
-            // Save original locale
+            // Acquire mutex to prevent interference with other tests
+            let _lock = LOCALE_MUTEX.lock().unwrap();
+
+            // Save original locale (both environment and process locale)
             let original_lc_all = std::env::var("LC_ALL").ok();
             let original_lc_time = std::env::var("LC_TIME").ok();
             let original_lang = std::env::var("LANG").ok();
 
+            // Save current process locale
+            let original_process_locale = unsafe {
+                let ptr = libc::setlocale(libc::LC_TIME, std::ptr::null());
+                if ptr.is_null() {
+                    None
+                } else {
+                    CStr::from_ptr(ptr).to_str().ok().map(|s| s.to_string())
+                }
+            };
+
             unsafe {
                 // Set C locale
                 std::env::set_var("LC_ALL", "C");
@@ -177,7 +206,7 @@ mod tests {
                 if d_t_fmt_ptr.is_null() {
                     None
                 } else {
-                    std::ffi::CStr::from_ptr(d_t_fmt_ptr).to_str().ok()
+                    CStr::from_ptr(d_t_fmt_ptr).to_str().ok()
                 }
             };
 
@@ -190,7 +219,7 @@ mod tests {
                 assert!(uses_24_hour, "C locale should use 24-hour format, got: {locale_format}");
             }
 
-            // Restore original locale
+            // Restore original environment variables
             unsafe {
                 if let Some(val) = original_lc_all {
                     std::env::set_var("LC_ALL", val);
@@ -208,6 +237,17 @@ mod tests {
                     std::env::remove_var("LANG");
                 }
             }
+
+            // Restore original process locale
+            unsafe {
+                if let Some(locale) = original_process_locale {
+                    let c_locale = std::ffi::CString::new(locale).unwrap();
+                    libc::setlocale(libc::LC_TIME, c_locale.as_ptr());
+                } else {
+                    // Restore from environment
+                    libc::setlocale(libc::LC_TIME, c"".as_ptr());
+                }
+            }
         }
 
         #[test]

src/uu/date/src/locale.rs

@@ -701,9 +701,24 @@ impl EnvAppData {
         #[cfg(unix)]
         {
             let mut signal_action_log = SignalActionLog::default();
-            apply_default_signal(&opts.default_signal, &mut signal_action_log)?;
-            apply_ignore_signal(&opts.ignore_signal, &mut signal_action_log)?;
-            apply_block_signal(&opts.block_signal, &mut signal_action_log)?;
+            apply_signal_action(
+                &opts.default_signal,
+                &mut signal_action_log,
+                SignalActionKind::Default,
+                reset_signal,
+            )?;
+            apply_signal_action(
+                &opts.ignore_signal,
+                &mut signal_action_log,
+                SignalActionKind::Ignore,
+                ignore_signal,
+            )?;
+            apply_signal_action(
+                &opts.block_signal,
+                &mut signal_action_log,
+                SignalActionKind::Block,
+                block_signal,
+            )?;
             if opts.list_signal_handling {
                 list_signal_handling(&signal_action_log);
             }
@@ -990,19 +1005,29 @@ fn apply_specified_env_vars(opts: &Options<'_>) {
 }
 
 #[cfg(unix)]
-fn apply_default_signal(request: &SignalRequest, log: &mut SignalActionLog) -> UResult<()> {
+fn apply_signal_action<F>(
+    request: &SignalRequest,
+    log: &mut SignalActionLog,
+    action_kind: SignalActionKind,
+    signal_fn: F,
+) -> UResult<()>
+where
+    F: Fn(Signal) -> UResult<()>,
+{
     request.for_each_signal(|sig_value, explicit| {
         // On some platforms ALL_SIGNALS may contain values that are not valid in libc.
         // Skip those invalid ones and continue (GNU env also ignores undefined signals).
         let Ok(sig) = signal_from_value(sig_value) else {
             return Ok(());
         };
-        reset_signal(sig)?;
-        log.record(sig_value, SignalActionKind::Default, explicit);
+        signal_fn(sig)?;
+        log.record(sig_value, action_kind, explicit);
 
         // Set environment variable to communicate to Rust child processes
         // that SIGPIPE should be default (not ignored)
-        if sig_value == nix::libc::SIGPIPE as usize {
+        if matches!(action_kind, SignalActionKind::Default)
+            && sig_value == nix::libc::SIGPIPE as usize
+        {
             unsafe {
                 std::env::set_var("RUST_SIGPIPE", "default");
             }
@@ -1012,30 +1037,6 @@ fn apply_default_signal(request: &SignalRequest, log: &mut SignalActionLog) -> U
     })
 }
 
-#[cfg(unix)]
-fn apply_ignore_signal(request: &SignalRequest, log: &mut SignalActionLog) -> UResult<()> {
-    request.for_each_signal(|sig_value, explicit| {
-        let Ok(sig) = signal_from_value(sig_value) else {
-            return Ok(());
-        };
-        ignore_signal(sig)?;
-        log.record(sig_value, SignalActionKind::Ignore, explicit);
-        Ok(())
-    })
-}
-
-#[cfg(unix)]
-fn apply_block_signal(request: &SignalRequest, log: &mut SignalActionLog) -> UResult<()> {
-    request.for_each_signal(|sig_value, explicit| {
-        let Ok(sig) = signal_from_value(sig_value) else {
-            return Ok(());
-        };
-        block_signal(sig)?;
-        log.record(sig_value, SignalActionKind::Block, explicit);
-        Ok(())
-    })
-}
-
 #[cfg(unix)]
 fn ignore_signal(sig: Signal) -> UResult<()> {
     // SAFETY: This is safe because we write the handler for each signal only once, and therefore "the current handler is the default", as the documentation requires it.

src/uu/env/src/env.rs

@@ -60,3 +60,4 @@ harness = false
 
 [features]
 feat_selinux = ["selinux", "uucore/selinux"]
+smack = ["uucore/smack"]

src/uu/ls/Cargo.toml

@@ -124,3 +124,13 @@ ls-invalid-columns-width = ignoring invalid width in environment variable COLUMN
 ls-invalid-ignore-pattern = Invalid pattern for ignore: {$pattern}
 ls-invalid-hide-pattern = Invalid pattern for hide: {$pattern}
 ls-total = total {$size}
+
+# Security context warnings
+ls-warning-failed-to-get-security-context = failed to get security context of: {$path}
+ls-warning-getting-security-context = getting security context of: {$path}: {$error}
+
+# SMACK error messages (used by uucore::smack when called from ls)
+smack-error-not-enabled = SMACK is not enabled on this system
+smack-error-label-retrieval-failure = failed to get SMACK label: { $error }
+smack-error-label-set-failure = failed to set SMACK label to '{ $context }': { $error }
+smack-error-no-label-set = no SMACK label set