[library/std pal::safaos process]: fix Command::output giving empty output always, and a bug fix related to File::duplicate

Author: safiworks

library/std/src/sys/pal/safaos/pipe.rs

@@ -60,8 +60,6 @@ impl AnonPipe {
 /// FIXME: This is a temporary implementation I have no idea what an AnonPipe is forgive my naiveness
 /// BUT I NEED IT FOR [`crate::sys::process::Command::output`]
 pub fn read2(p1: AnonPipe, v1: &mut Vec<u8>, p2: AnonPipe, v2: &mut Vec<u8>) -> io::Result<()> {
-    let mut p1 = &p1.into_raw();
-    let mut p2 = &p2.into_raw();
     p1.read_to_end(v1)?;
     p2.read_to_end(v2)?;
     Ok(())

library/std/src/sys/pal/safaos/process.rs

@@ -28,6 +28,7 @@ pub struct Command {
     stderr: Option<Stdio>,
 }
 
+#[derive(Debug)]
 // passed back to std::process with the pipes connected to the child, if any
 // were requested
 pub struct StdioPipes {
@@ -70,13 +71,13 @@ impl Stdio {
         match self {
             Stdio::Inherit => None,
             Stdio::InheritStdout => {
-                Some(AnonPipe::from_fd(unsafe { FileDesc::from_raw(sysmeta_stdout()) }))
+                Some(AnonPipe::from_fd(unsafe { FileDesc::from_raw_dup(sysmeta_stdout()) }))
             }
             Stdio::InheritStderr => {
-                Some(AnonPipe::from_fd(unsafe { FileDesc::from_raw(sysmeta_stderr()) }))
+                Some(AnonPipe::from_fd(unsafe { FileDesc::from_raw_dup(sysmeta_stderr()) }))
             }
             Stdio::InheritStdin => {
-                Some(AnonPipe::from_fd(unsafe { FileDesc::from_raw(sysmeta_stdin()) }))
+                Some(AnonPipe::from_fd(unsafe { FileDesc::from_raw_dup(sysmeta_stdin()) }))
             }
             Stdio::Null => None,
             Stdio::InheritFile(fd) => Some(AnonPipe::from_fd(fd)),
@@ -182,8 +183,20 @@ impl Command {
     }
 
     pub fn output(&mut self) -> io::Result<(ExitStatus, Vec<u8>, Vec<u8>)> {
-        let (proc, pipes) = self.spawn(Stdio::Inherit, false)?;
-        crate::sys_common::process::wait_with_output(proc, pipes)
+        let (mut proc, mut pipes) = self.spawn(Stdio::Inherit, false)?;
+        let status = proc.wait()?;
+        drop(pipes.stdin.take());
+
+        let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
+        // TODO: properly add Pipes
+        if let Some(out) = pipes.stdout.take() {
+            out.read_to_end(&mut stdout)?;
+        }
+
+        if let Some(err) = pipes.stderr.take() {
+            err.read_to_end(&mut stderr)?;
+        }
+        Ok((status, stdout, stderr))
     }
 }
 

library/std/src/sys/pal/safaos/resources.rs

@@ -1,4 +1,5 @@
 use core::cell::UnsafeCell;
+use core::mem::ManuallyDrop;
 
 use crate::io::{self, SeekFrom};
 use crate::sys::fs::FileAttr;
@@ -81,13 +82,25 @@ impl Drop for FileResource {
     }
 }
 
+impl Clone for FileResource {
+    fn clone(&self) -> Self {
+        Self(syscalls::dup(self.0).unwrap())
+    }
+}
+
 // FIXME: make seek_at a mutex?
 #[derive(Debug)]
 pub(crate) struct FileDesc {
     fd: FileResource,
     seek_at: UnsafeCell<isize>,
 }
 
+impl Clone for FileDesc {
+    fn clone(&self) -> Self {
+        unsafe { Self { fd: self.fd.clone(), seek_at: UnsafeCell::new(*self.seek_at.get()) } }
+    }
+}
+
 impl PartialEq for FileDesc {
     fn eq(&self, other: &Self) -> bool {
         self.fd == other.fd
@@ -98,10 +111,20 @@ unsafe impl Send for FileDesc {}
 unsafe impl Sync for FileDesc {}
 
 impl FileDesc {
+    /// converts a raw resource id into a FileDesc
+    /// this is unsafe because the resource id is not checked for validity
     pub unsafe fn from_raw(ri: usize) -> Self {
         Self { fd: FileResource(ri), seek_at: UnsafeCell::new(0) }
     }
 
+    /// duplicates a raw resource id into a FileDesc
+    /// this is unsafe because the resource id is not checked for validity
+    /// the returned FileDesc is a duplicate of the original with a different resource id and therefore doesn't take ownership of the resource
+    pub unsafe fn from_raw_dup(ri: usize) -> Self {
+        let fd = unsafe { ManuallyDrop::new(Self::from_raw(ri)) };
+        ManuallyDrop::into_inner(fd.clone())
+    }
+
     pub(crate) fn fd(&self) -> usize {
         self.fd.0
     }