Add powershell detection

Author: Jake-Shadle

Cargo.lock

@@ -55,6 +55,8 @@ home = "0.5"
 ignore = "0.4"
 # Dependency graphing
 krates = { version = "0.17.1", features = ["metadata"] }
+# Parent process retrieval
+libc = "0.2"
 # Logging macros
 log = "0.4"
 # Better heap allocator over system one (usually)

Cargo.toml

@@ -0,0 +1,21 @@
+output = "win_bindings.rs"
+binds = [
+    "MAX_PATH",
+    "NtQueryInformationProcess",
+    "OpenProcess",
+    "ProcessBasicInformation",
+    "ProcessImageFileName",
+    "PROCESS_BASIC_INFORMATION",
+    "PROCESS_QUERY_INFORMATION",
+    "STATUS_SUCCESS",
+    "UNICODE_STRING",
+]
+
+[bind-mode]
+mode = "minwin"
+
+[bind-mode.config]
+enum-style = "minwin"
+fix-naming = true
+use-rust-casing = true
+linking-style = "raw-dylib"

src/bindings.toml

@@ -170,6 +170,15 @@ pub fn cmd(args: Args, color: crate::Color) -> anyhow::Result<()> {
         "handlebars template(s) must be specified when using handlebars output format"
     );
 
+    // Check if the parent process is powershell, if it is, assume that it will
+    // screw up the output https://github.com/EmbarkStudios/cargo-about/issues/198
+    // and inform the user about the -o, --output-file option
+    let redirect_stdout =
+        args.output_file.is_none() || args.output_file.as_deref() == Some(Path::new("-"));
+    if redirect_stdout {
+        anyhow::ensure!(!cargo_about::is_powershell_parent(), "cargo-about should not redirect its output in powershell, please use the -o, --output-file option to redirect to a file to avoid powershell encoding issues");
+    }
+
     rayon::scope(|s| {
         s.spawn(|_| {
             log::info!("gathering crates for {manifest_path}");
@@ -289,13 +298,11 @@ pub fn cmd(args: Args, color: crate::Color) -> anyhow::Result<()> {
         serde_json::to_string(&input)?
     };
 
-    match args.output_file.as_ref() {
-        None => println!("{output}"),
-        Some(path) if path == Path::new("-") => println!("{output}"),
-        Some(path) => {
-            std::fs::write(path, output)
-                .with_context(|| format!("output file {path} could not be written"))?;
-        }
+    if let Some(path) = &args.output_file.filter(|_| !redirect_stdout) {
+        std::fs::write(path, output)
+            .with_context(|| format!("output file {path} could not be written"))?;
+    } else {
+        println!("{output}");
     }
 
     Ok(())

src/cargo-about/generate.rs

@@ -216,3 +216,107 @@ pub fn validate_sha256(buffer: &str, expected: &str) -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[cfg(target_family = "unix")]
+#[allow(unsafe_code)]
+pub fn is_powershell_parent() -> bool {
+    if !cfg!(target_os = "linux") {
+        // Making the assumption that no one on MacOS or any of the *BSDs uses powershell...
+        return false;
+    }
+
+    // SAFETY: no invariants to uphold
+    let parent_id = unsafe { libc::getppid() };
+    let Ok(cmd) = std::fs::read_to_string(format!("/proc/{parent_id}/cmdline")) else {
+        return false;
+    };
+
+    let Some(proc) = cmd
+        .split('\0')
+        .nth(0)
+        .and_then(|path| path.split('/').last())
+    else {
+        return false;
+    };
+    dbg!(proc) == "pwsh"
+}
+
+#[cfg(target_family = "windows")]
+mod win_bindings;
+
+#[cfg(target_family = "windows")]
+#[allow(unsafe_code)]
+pub fn is_powershell_parent() -> bool {
+    use std::os::windows::ffi::OsStringExt as _;
+    use win_bindings::*;
+
+    unsafe {
+        let mut basic_info = std::mem::MaybeUninit::<ProcessBasicInformation>::uninit();
+        let mut length = 0;
+        if nt_query_information_process(
+            -1, /* NtCurrentProcess */
+            Processinfoclass::ProcessBasicInformation,
+            basic_info.as_mut_ptr().cast(),
+            std::mem::size_of::<ProcessBasicInformation>() as _,
+            &mut length,
+        ) != StatusSuccess
+        {
+            return false;
+        }
+
+        if length != std::mem::size_of::<ProcessBasicInformation>() as u32 {
+            return false;
+        }
+
+        let basic_info = basic_info.assume_init();
+
+        // The API for this is extremely irritating, the struct and string buffer
+        // need to be the same :/
+        let mut file_name = [0u16; MaxPath as usize + std::mem::size_of::<UnicodeString>() / 2];
+        {
+            let ustr = &mut *file_name.as_mut_ptr().cast::<UnicodeString>();
+            ustr.length = 0;
+            ustr.maximum_length = MaxPath as _;
+            ustr.buffer = file_name
+                .as_mut_ptr()
+                .byte_offset(std::mem::size_of::<UnicodeString>() as _);
+        }
+
+        if nt_query_information_process(
+            basic_info.inherited_from_unique_process_id as _,
+            Processinfoclass::ProcessImageFileName,
+            file_name.as_mut_ptr().cast(),
+            (file_name.len() * 2) as _,
+            &mut length,
+        ) != StatusSuccess
+        {
+            return false;
+        }
+
+        let ustr = &*file_name.as_ptr().cast::<UnicodeString>();
+        let os = std::ffi::OsString::from_wide(
+            &file_name[std::mem::size_of::<UnicodeString>() * 2
+                ..std::mem::size_of::<UnicodeString>() * 2 + ustr.length as usize],
+        );
+
+        let path = os.to_string_lossy();
+
+        dbg!(&path);
+        false
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    #[ignore = "call when actually run from powershell"]
+    fn is_powershell_true() {
+        assert!(super::is_powershell_parent());
+    }
+
+    #[test]
+    #[ignore = "call when not actually run from powershell"]
+    fn is_powershell_false() {
+        assert!(!super::is_powershell_parent());
+    }
+}

src/lib.rs

@@ -0,0 +1,98 @@
+//! Bindings generated by `minwin` 0.1.0
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    clippy::upper_case_acronyms
+)]
+#[link(name = "kernel32", kind = "raw-dylib")]
+extern "system" {
+    #[link_name = "OpenProcess"]
+    pub fn open_process(
+        desired_access: ProcessAccessRights::Enum,
+        inherit_handle: Bool,
+        process_id: u32,
+    ) -> Handle;
+}
+#[link(name = "ntdll", kind = "raw-dylib")]
+extern "system" {
+    #[link_name = "NtQueryInformationProcess"]
+    pub fn nt_query_information_process(
+        process_handle: Handle,
+        process_information_class: Processinfoclass::Enum,
+        process_information: *mut ::core::ffi::c_void,
+        process_information_length: u32,
+        return_length: *mut u32,
+    ) -> Ntstatus;
+}
+pub const MaxPath: u32 = 260;
+pub type Bool = i32;
+pub type Handle = isize;
+#[repr(C)]
+pub struct ListEntry {
+    pub flink: *mut ListEntry,
+    pub blink: *mut ListEntry,
+}
+pub type Ntstatus = i32;
+pub const StatusSuccess: Ntstatus = 0;
+#[repr(C)]
+pub struct Peb {
+    pub reserved1: [u8; 2],
+    pub being_debugged: u8,
+    pub reserved2: [u8; 1],
+    pub reserved3: [*mut ::core::ffi::c_void; 2],
+    pub ldr: *mut PebLdrData,
+    pub process_parameters: *mut RtlUserProcessParameters,
+    pub reserved4: [*mut ::core::ffi::c_void; 3],
+    pub atl_thunk_s_list_ptr: *mut ::core::ffi::c_void,
+    pub reserved5: *mut ::core::ffi::c_void,
+    pub reserved6: u32,
+    pub reserved7: *mut ::core::ffi::c_void,
+    pub reserved8: u32,
+    pub atl_thunk_s_list_ptr32: u32,
+    pub reserved9: [*mut ::core::ffi::c_void; 45],
+    pub reserved10: [u8; 96],
+    pub post_process_init_routine: PpsPostProcessInitRoutine,
+    pub reserved11: [u8; 128],
+    pub reserved12: [*mut ::core::ffi::c_void; 1],
+    pub session_id: u32,
+}
+#[repr(C)]
+pub struct PebLdrData {
+    pub reserved1: [u8; 8],
+    pub reserved2: [*mut ::core::ffi::c_void; 3],
+    pub in_memory_order_module_list: ListEntry,
+}
+pub type PpsPostProcessInitRoutine = ::core::option::Option<unsafe extern "system" fn()>;
+pub mod ProcessAccessRights {
+    pub type Enum = u32;
+    pub const ProcessQueryInformation: Enum = 1024;
+}
+#[repr(C)]
+pub struct ProcessBasicInformation {
+    pub exit_status: Ntstatus,
+    pub peb_base_address: *mut Peb,
+    pub affinity_mask: usize,
+    pub base_priority: i32,
+    pub unique_process_id: usize,
+    pub inherited_from_unique_process_id: usize,
+}
+pub mod Processinfoclass {
+    pub type Enum = i32;
+    pub const ProcessBasicInformation: Enum = 0;
+    pub const ProcessImageFileName: Enum = 27;
+}
+pub type Pwstr = *mut u16;
+#[repr(C)]
+pub struct RtlUserProcessParameters {
+    pub reserved1: [u8; 16],
+    pub reserved2: [*mut ::core::ffi::c_void; 10],
+    pub image_path_name: UnicodeString,
+    pub command_line: UnicodeString,
+}
+#[repr(C)]
+pub struct UnicodeString {
+    pub length: u16,
+    pub maximum_length: u16,
+    pub buffer: Pwstr,
+}