Add Windows process listing command

Author: caomengxuan666

Cargo.lock

@@ -125,6 +125,7 @@ uptime = { package = "uu_uptime", path = "deps/coreutils/src/uu/uptime" }
 findutils = { package = "findutils", path = "deps/findutils" }
 grep = { package = "uu_grep", path = "deps/grep" }
 ntfind = { package = "find", path = "deps/ntfind" }
+ps = { package = "uu_ps", path = "deps/ntps" }
 
 # For registry access in main.rs
 [dependencies.windows-sys]

Cargo.toml

@@ -66,6 +66,7 @@ Legend: ✅ ships and works · ⚠️ ships but conflicts with a built-in · 
 | `mkdir`    |  ⚠️  |       ⚠️        | |
 | `more`     |  🛑  |       🛑        | Conflicts with the built-in DOS command (consider `edit` as an alternative) |
 | `mv`       |  ✅  |       ⚠️        | |
+| `ps`       |  ✅  |       ⚠️        | Windows-native process listing |
 | `pwd`      |  ✅  |       ⚠️        | |
 | `rm`       |  ✅  |       ⚠️        | |
 | `rmdir`    |  ⚠️  |       ⚠️        | |

README.md

@@ -0,0 +1,16 @@
+[package]
+name = "uu_ps"
+edition = "2024"
+license = "MIT"
+repository = "https://github.com/microsoft/coreutils"
+rust-version = "1.88.0"
+version = "0.1.0"
+publish = false
+
+[dependencies]
+clap = { version = "4.5", features = ["wrap_help", "cargo", "color"] }
+uucore = { path = "../coreutils/src/uucore" }
+windows-sys = { version = "*", features = [
+    "Win32_Foundation",
+    "Win32_System_Diagnostics_ToolHelp",
+] }

deps/ntps/Cargo.toml

@@ -0,0 +1,137 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use std::ffi::OsString;
+use std::io::{self, Write};
+use std::mem::{size_of, zeroed};
+use std::os::windows::ffi::OsStringExt as _;
+
+use clap::{Arg, ArgAction, Command};
+use uucore::Args;
+use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
+use windows_sys::Win32::System::Diagnostics::ToolHelp::{
+    CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
+};
+
+pub fn uumain<T: Args>(args: T) -> i32 {
+    let matches = match uu_app().try_get_matches_from(args) {
+        Ok(matches) => matches,
+        Err(err) => {
+            let _ = err.print();
+            return err.exit_code();
+        }
+    };
+
+    let _ = matches;
+
+    match list_processes() {
+        Ok(processes) => print_processes(&processes),
+        Err(err) => {
+            let _ = writeln!(io::stderr(), "ps: {err}");
+            1
+        }
+    }
+}
+
+pub fn uu_app() -> Command {
+    Command::new("ps")
+        .version(env!("CARGO_PKG_VERSION"))
+        .about("List running processes")
+        .arg(
+            Arg::new("all")
+                .short('A')
+                .action(ArgAction::SetTrue)
+                .help("List all processes"),
+        )
+        .arg(
+            Arg::new("every")
+                .short('e')
+                .action(ArgAction::SetTrue)
+                .help("List all processes"),
+        )
+}
+
+#[derive(Debug, Eq, PartialEq)]
+struct ProcessInfo {
+    pid: u32,
+    ppid: u32,
+    name: String,
+}
+
+fn list_processes() -> io::Result<Vec<ProcessInfo>> {
+    let snapshot = unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) };
+    if snapshot == INVALID_HANDLE_VALUE {
+        return Err(io::Error::last_os_error());
+    }
+
+    let mut entry: PROCESSENTRY32W = unsafe { zeroed() };
+    entry.dwSize = size_of::<PROCESSENTRY32W>() as u32;
+
+    let mut processes = Vec::new();
+
+    let mut ok = unsafe { Process32FirstW(snapshot, &mut entry) != 0 };
+    while ok {
+        processes.push(ProcessInfo {
+            pid: entry.th32ProcessID,
+            ppid: entry.th32ParentProcessID,
+            name: process_name(&entry.szExeFile),
+        });
+        ok = unsafe { Process32NextW(snapshot, &mut entry) != 0 };
+    }
+
+    unsafe {
+        CloseHandle(snapshot);
+    }
+
+    processes.sort_by_key(|process| process.pid);
+    Ok(processes)
+}
+
+fn print_processes(processes: &[ProcessInfo]) -> i32 {
+    let mut out = io::stdout().lock();
+
+    if writeln!(out, "{:>8} {:>8} COMMAND", "PID", "PPID").is_err() {
+        return 1;
+    }
+
+    for process in processes {
+        if writeln!(
+            out,
+            "{:>8} {:>8} {}",
+            process.pid, process.ppid, process.name
+        )
+        .is_err()
+        {
+            return 1;
+        }
+    }
+
+    0
+}
+
+fn process_name(buffer: &[u16]) -> String {
+    let len = buffer.iter().position(|&ch| ch == 0).unwrap_or(buffer.len());
+    OsString::from_wide(&buffer[..len])
+        .to_string_lossy()
+        .into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn trims_process_name_at_nul() {
+        let mut buffer = [0u16; 260];
+        let name: Vec<u16> = "example.exe".encode_utf16().collect();
+        buffer[..name.len()].copy_from_slice(&name);
+
+        assert_eq!(process_name(&buffer), "example.exe");
+    }
+
+    #[test]
+    fn accepts_common_all_process_flags() {
+        assert!(uu_app().try_get_matches_from(["ps", "-A"]).is_ok());
+        assert!(uu_app().try_get_matches_from(["ps", "-e"]).is_ok());
+    }
+}