Move std::run off of std::io

This changes the implementation to instead use rt::io::native::process as well
as an example of using those bindings.

1 files changed, 65 insertions, 769 deletions

diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index 074c232e149..38fb597f296 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -12,19 +12,14 @@
 
 #[allow(missing_doc)];
 
-use c_str::ToCStr;
-use cast;
-use clone::Clone;
-use comm::{stream, SharedChan, GenericChan, GenericPort};
-use io;
-use libc::{pid_t, c_void, c_int};
+use cell::Cell;
+use comm::{stream, SharedChan};
+use libc::{pid_t, c_int};
 use libc;
-use option::{Some, None};
-use os;
 use prelude::*;
-use ptr;
+use rt::io::native::process;
+use rt::io;
 use task;
-use vec::ImmutableVector;
 
 /**
  * A value representing a child process.
@@ -34,28 +29,7 @@ use vec::ImmutableVector;
  * for the process to terminate.
  */
 pub struct Process {
-
-    /// The unique id of the process (this should never be negative).
-    priv pid: pid_t,
-
-    /**
-     * A handle to the process - on unix this will always be NULL, but on
-     * windows it will be a HANDLE to the process, which will prevent the
-     * pid being re-used until the handle is closed.
-     */
-    priv handle: *(),
-
-    /// Some(fd), or None when stdin is being redirected from a fd not created by Process::new.
-    priv input: Option<c_int>,
-
-    /// Some(file), or None when stdout is being redirected to a fd not created by Process::new.
-    priv output: Option<*libc::FILE>,
-
-    /// Some(file), or None when stderr is being redirected to a fd not created by Process::new.
-    priv error: Option<*libc::FILE>,
-
-    /// None until finish() is called.
-    priv exit_code: Option<int>,
+    priv inner: process::Process,
 }
 
 /// Options that can be given when starting a Process.
@@ -147,178 +121,50 @@ impl Process {
      * * options - Options to configure the environment of the process,
      *             the working directory and the standard IO streams.
      */
-    pub fn new(prog: &str, args: &[~str],
-               options: ProcessOptions)
-               -> Process {
-        #[fixed_stack_segment]; #[inline(never)];
-
-        let (in_pipe, in_fd) = match options.in_fd {
-            None => {
-                let pipe = os::pipe();
-                (Some(pipe), pipe.input)
-            },
-            Some(fd) => (None, fd)
-        };
-        let (out_pipe, out_fd) = match options.out_fd {
-            None => {
-                let pipe = os::pipe();
-                (Some(pipe), pipe.out)
-            },
-            Some(fd) => (None, fd)
-        };
-        let (err_pipe, err_fd) = match options.err_fd {
-            None => {
-                let pipe = os::pipe();
-                (Some(pipe), pipe.out)
-            },
-            Some(fd) => (None, fd)
-        };
-
-        let res = spawn_process_os(prog, args, options.env.clone(), options.dir,
-                                   in_fd, out_fd, err_fd);
-
-        unsafe {
-            for pipe in in_pipe.iter() { libc::close(pipe.input); }
-            for pipe in out_pipe.iter() { libc::close(pipe.out); }
-            for pipe in err_pipe.iter() { libc::close(pipe.out); }
-        }
-
-        Process {
-            pid: res.pid,
-            handle: res.handle,
-            input: in_pipe.map(|pipe| pipe.out),
-            output: out_pipe.map(|pipe| os::fdopen(pipe.input)),
-            error: err_pipe.map(|pipe| os::fdopen(pipe.input)),
-            exit_code: None,
-        }
+    pub fn new(prog: &str, args: &[~str], options: ProcessOptions) -> Process {
+        let ProcessOptions { env, dir, in_fd, out_fd, err_fd } = options;
+        let inner = process::Process::new(prog, args, env, dir,
+                                          in_fd, out_fd, err_fd);
+        Process { inner: inner }
     }
 
     /// Returns the unique id of the process
-    pub fn get_id(&self) -> pid_t { self.pid }
-
-    fn input_fd(&mut self) -> c_int {
-        match self.input {
-            Some(fd) => fd,
-            None => fail2!("This Process's stdin was redirected to an \
-                           existing file descriptor.")
-        }
-    }
-
-    fn output_file(&mut self) -> *libc::FILE {
-        match self.output {
-            Some(file) => file,
-            None => fail2!("This Process's stdout was redirected to an \
-                           existing file descriptor.")
-        }
-    }
-
-    fn error_file(&mut self) -> *libc::FILE {
-        match self.error {
-            Some(file) => file,
-            None => fail2!("This Process's stderr was redirected to an \
-                           existing file descriptor.")
-        }
-    }
-
-    /**
-     * Returns whether this process is reading its stdin from an existing file
-     * descriptor rather than a pipe that was created specifically for this
-     * process.
-     *
-     * If this method returns true then self.input() will fail.
-     */
-    pub fn input_redirected(&self) -> bool {
-        self.input.is_none()
-    }
-
-    /**
-     * Returns whether this process is writing its stdout to an existing file
-     * descriptor rather than a pipe that was created specifically for this
-     * process.
-     *
-     * If this method returns true then self.output() will fail.
-     */
-    pub fn output_redirected(&self) -> bool {
-        self.output.is_none()
-    }
-
-    /**
-     * Returns whether this process is writing its stderr to an existing file
-     * descriptor rather than a pipe that was created specifically for this
-     * process.
-     *
-     * If this method returns true then self.error() will fail.
-     */
-    pub fn error_redirected(&self) -> bool {
-        self.error.is_none()
-    }
+    pub fn get_id(&self) -> pid_t { self.inner.id() }
 
     /**
      * Returns an io::Writer that can be used to write to this Process's stdin.
      *
-     * Fails if this Process's stdin was redirected to an existing file descriptor.
+     * Fails if there is no stdin available (it's already been removed by
+     * take_input)
      */
-    pub fn input(&mut self) -> @io::Writer {
-        // FIXME: the Writer can still be used after self is destroyed: #2625
-       io::fd_writer(self.input_fd(), false)
-    }
+    pub fn input<'a>(&'a mut self) -> &'a mut io::Writer { self.inner.input() }
 
     /**
      * Returns an io::Reader that can be used to read from this Process's stdout.
      *
-     * Fails if this Process's stdout was redirected to an existing file descriptor.
+     * Fails if there is no stdout available (it's already been removed by
+     * take_output)
      */
-    pub fn output(&mut self) -> @io::Reader {
-        // FIXME: the Reader can still be used after self is destroyed: #2625
-        io::FILE_reader(self.output_file(), false)
-    }
+    pub fn output<'a>(&'a mut self) -> &'a mut io::Reader { self.inner.output() }
 
     /**
      * Returns an io::Reader that can be used to read from this Process's stderr.
      *
-     * Fails if this Process's stderr was redirected to an existing file descriptor.
+     * Fails if there is no stderr available (it's already been removed by
+     * take_error)
      */
-    pub fn error(&mut self) -> @io::Reader {
-        // FIXME: the Reader can still be used after self is destroyed: #2625
-        io::FILE_reader(self.error_file(), false)
-    }
+    pub fn error<'a>(&'a mut self) -> &'a mut io::Reader { self.inner.error() }
 
     /**
      * Closes the handle to the child process's stdin.
-     *
-     * If this process is reading its stdin from an existing file descriptor, then this
-     * method does nothing.
      */
     pub fn close_input(&mut self) {
-        #[fixed_stack_segment]; #[inline(never)];
-        match self.input {
-            Some(-1) | None => (),
-            Some(fd) => {
-                unsafe {
-                    libc::close(fd);
-                }
-                self.input = Some(-1);
-            }
-        }
+        self.inner.take_input();
     }
 
     fn close_outputs(&mut self) {
-        #[fixed_stack_segment]; #[inline(never)];
-        fclose_and_null(&mut self.output);
-        fclose_and_null(&mut self.error);
-
-        fn fclose_and_null(f_opt: &mut Option<*libc::FILE>) {
-            #[allow(cstack)]; // fixed_stack_segment declared on enclosing fn
-            match *f_opt {
-                Some(f) if !f.is_null() => {
-                    unsafe {
-                        libc::fclose(f);
-                        *f_opt = Some(0 as *libc::FILE);
-                    }
-                },
-                _ => ()
-            }
-        }
+        self.inner.take_output();
+        self.inner.take_error();
     }
 
     /**
@@ -327,29 +173,35 @@ impl Process {
      *
      * If the child has already been finished then the exit code is returned.
      */
-    pub fn finish(&mut self) -> int {
-        for &code in self.exit_code.iter() {
-            return code;
-        }
-        self.close_input();
-        let code = waitpid(self.pid);
-        self.exit_code = Some(code);
-        return code;
-    }
+    pub fn finish(&mut self) -> int { self.inner.wait() }
 
     /**
-     * Closes the handle to stdin, waits for the child process to terminate, and reads
-     * and returns all remaining output of stdout and stderr, along with the exit code.
+     * Closes the handle to stdin, waits for the child process to terminate, and
+     * reads and returns all remaining output of stdout and stderr, along with
+     * the exit code.
      *
-     * If the child has already been finished then the exit code and any remaining
-     * unread output of stdout and stderr will be returned.
+     * If the child has already been finished then the exit code and any
+     * remaining unread output of stdout and stderr will be returned.
      *
-     * This method will fail if the child process's stdout or stderr streams were
-     * redirected to existing file descriptors.
+     * This method will fail if the child process's stdout or stderr streams
+     * were redirected to existing file descriptors.
      */
     pub fn finish_with_output(&mut self) -> ProcessOutput {
-        let output_file = self.output_file();
-        let error_file = self.error_file();
+        self.inner.take_input(); // close stdin
+        let output = Cell::new(self.inner.take_output());
+        let error = Cell::new(self.inner.take_error());
+
+        fn read_everything(r: &mut io::Reader) -> ~[u8] {
+            let mut ret = ~[];
+            let mut buf = [0, ..1024];
+            loop {
+                match r.read(buf) {
+                    Some(n) => { ret.push_all(buf.slice_to(n)); }
+                    None => break
+                }
+            }
+            return ret;
+        }
 
         // Spawn two entire schedulers to read both stdout and sterr
         // in parallel so we don't deadlock while blocking on one
@@ -359,12 +211,16 @@ impl Process {
         let ch = SharedChan::new(ch);
         let ch_clone = ch.clone();
         do task::spawn_sched(task::SingleThreaded) {
-            let errput = io::FILE_reader(error_file, false);
-            ch.send((2, errput.read_whole_stream()));
+            match error.take() {
+                Some(ref mut e) => ch.send((2, read_everything(*e))),
+                None => ch.send((2, ~[]))
+            }
         }
         do task::spawn_sched(task::SingleThreaded) {
-            let output = io::FILE_reader(output_file, false);
-            ch_clone.send((1, output.read_whole_stream()));
+            match output.take() {
+                Some(ref mut e) => ch_clone.send((1, read_everything(*e))),
+                None => ch_clone.send((1, ~[]))
+            }
         }
 
         let status = self.finish();
@@ -382,40 +238,6 @@ impl Process {
                               error: errs};
     }
 
-    fn destroy_internal(&mut self, force: bool) {
-        // if the process has finished, and therefore had waitpid called,
-        // and we kill it, then on unix we might ending up killing a
-        // newer process that happens to have the same (re-used) id
-        if self.exit_code.is_none() {
-            killpid(self.pid, force);
-            self.finish();
-        }
-
-        #[cfg(windows)]
-        fn killpid(pid: pid_t, _force: bool) {
-            #[fixed_stack_segment]; #[inline(never)];
-            unsafe {
-                libc::funcs::extra::kernel32::TerminateProcess(
-                    cast::transmute(pid), 1);
-            }
-        }
-
-        #[cfg(unix)]
-        fn killpid(pid: pid_t, force: bool) {
-            #[fixed_stack_segment]; #[inline(never)];
-
-            let signal = if force {
-                libc::consts::os::posix88::SIGKILL
-            } else {
-                libc::consts::os::posix88::SIGTERM
-            };
-
-            unsafe {
-                libc::funcs::posix88::signal::kill(pid, signal as c_int);
-            }
-        }
-    }
-
     /**
      * Terminates the process, giving it a chance to clean itself up if
      * this is supported by the operating system.
@@ -423,7 +245,10 @@ impl Process {
      * On Posix OSs SIGTERM will be sent to the process. On Win32
      * TerminateProcess(..) will be called.
      */
-    pub fn destroy(&mut self) { self.destroy_internal(false); }
+    pub fn destroy(&mut self) {
+        self.inner.signal(io::process::PleaseExitSignal);
+        self.finish();
+    }
 
     /**
      * Terminates the process as soon as possible without giving it a
@@ -432,386 +257,12 @@ impl Process {
      * On Posix OSs SIGKILL will be sent to the process. On Win32
      * TerminateProcess(..) will be called.
      */
-    pub fn force_destroy(&mut self) { self.destroy_internal(true); }
-}
-
-impl Drop for Process {
-    fn drop(&mut self) {
+    pub fn force_destroy(&mut self) {
+        self.inner.signal(io::process::MustDieSignal);
         self.finish();
-        self.close_outputs();
-        free_handle(self.handle);
     }
 }
 
-struct SpawnProcessResult {
-    pid: pid_t,
-    handle: *(),
-}
-
-#[cfg(windows)]
-fn spawn_process_os(prog: &str, args: &[~str],
-                    env: Option<~[(~str, ~str)]>,
-                    dir: Option<&Path>,
-                    in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
-    #[fixed_stack_segment]; #[inline(never)];
-
-    use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
-    use libc::consts::os::extra::{
-        TRUE, FALSE,
-        STARTF_USESTDHANDLES,
-        INVALID_HANDLE_VALUE,
-        DUPLICATE_SAME_ACCESS
-    };
-    use libc::funcs::extra::kernel32::{
-        GetCurrentProcess,
-        DuplicateHandle,
-        CloseHandle,
-        CreateProcessA
-    };
-    use libc::funcs::extra::msvcrt::get_osfhandle;
-
-    use sys;
-
-    unsafe {
-
-        let mut si = zeroed_startupinfo();
-        si.cb = sys::size_of::<STARTUPINFO>() as DWORD;
-        si.dwFlags = STARTF_USESTDHANDLES;
-
-        let cur_proc = GetCurrentProcess();
-
-        let orig_std_in = get_osfhandle(in_fd) as HANDLE;
-        if orig_std_in == INVALID_HANDLE_VALUE as HANDLE {
-            fail2!("failure in get_osfhandle: {}", os::last_os_error());
-        }
-        if DuplicateHandle(cur_proc, orig_std_in, cur_proc, &mut si.hStdInput,
-                           0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
-            fail2!("failure in DuplicateHandle: {}", os::last_os_error());
-        }
-
-        let orig_std_out = get_osfhandle(out_fd) as HANDLE;
-        if orig_std_out == INVALID_HANDLE_VALUE as HANDLE {
-            fail2!("failure in get_osfhandle: {}", os::last_os_error());
-        }
-        if DuplicateHandle(cur_proc, orig_std_out, cur_proc, &mut si.hStdOutput,
-                           0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
-            fail2!("failure in DuplicateHandle: {}", os::last_os_error());
-        }
-
-        let orig_std_err = get_osfhandle(err_fd) as HANDLE;
-        if orig_std_err == INVALID_HANDLE_VALUE as HANDLE {
-            fail2!("failure in get_osfhandle: {}", os::last_os_error());
-        }
-        if DuplicateHandle(cur_proc, orig_std_err, cur_proc, &mut si.hStdError,
-                           0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
-            fail2!("failure in DuplicateHandle: {}", os::last_os_error());
-        }
-
-        let cmd = make_command_line(prog, args);
-        let mut pi = zeroed_process_information();
-        let mut create_err = None;
-
-        do with_envp(env) |envp| {
-            do with_dirp(dir) |dirp| {
-                do cmd.with_c_str |cmdp| {
-                    let created = CreateProcessA(ptr::null(), cast::transmute(cmdp),
-                                                 ptr::mut_null(), ptr::mut_null(), TRUE,
-                                                 0, envp, dirp, &mut si, &mut pi);
-                    if created == FALSE {
-                        create_err = Some(os::last_os_error());
-                    }
-                }
-            }
-        }
-
-        CloseHandle(si.hStdInput);
-        CloseHandle(si.hStdOutput);
-        CloseHandle(si.hStdError);
-
-        for msg in create_err.iter() {
-            fail2!("failure in CreateProcess: {}", *msg);
-        }
-
-        // We close the thread handle because we don't care about keeping the thread id valid,
-        // and we aren't keeping the thread handle around to be able to close it later. We don't
-        // close the process handle however because we want the process id to stay valid at least
-        // until the calling code closes the process handle.
-        CloseHandle(pi.hThread);
-
-        SpawnProcessResult {
-            pid: pi.dwProcessId as pid_t,
-            handle: pi.hProcess as *()
-        }
-    }
-}
-
-#[cfg(windows)]
-fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO {
-    libc::types::os::arch::extra::STARTUPINFO {
-        cb: 0,
-        lpReserved: ptr::mut_null(),
-        lpDesktop: ptr::mut_null(),
-        lpTitle: ptr::mut_null(),
-        dwX: 0,
-        dwY: 0,
-        dwXSize: 0,
-        dwYSize: 0,
-        dwXCountChars: 0,
-        dwYCountCharts: 0,
-        dwFillAttribute: 0,
-        dwFlags: 0,
-        wShowWindow: 0,
-        cbReserved2: 0,
-        lpReserved2: ptr::mut_null(),
-        hStdInput: ptr::mut_null(),
-        hStdOutput: ptr::mut_null(),
-        hStdError: ptr::mut_null()
-    }
-}
-
-#[cfg(windows)]
-fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMATION {
-    libc::types::os::arch::extra::PROCESS_INFORMATION {
-        hProcess: ptr::mut_null(),
-        hThread: ptr::mut_null(),
-        dwProcessId: 0,
-        dwThreadId: 0
-    }
-}
-
-// FIXME: this is only pub so it can be tested (see issue #4536)
-#[cfg(windows)]
-pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
-    let mut cmd = ~"";
-    append_arg(&mut cmd, prog);
-    for arg in args.iter() {
-        cmd.push_char(' ');
-        append_arg(&mut cmd, *arg);
-    }
-    return cmd;
-
-    fn append_arg(cmd: &mut ~str, arg: &str) {
-        let quote = arg.iter().any(|c| c == ' ' || c == '\t');
-        if quote {
-            cmd.push_char('"');
-        }
-        for i in range(0u, arg.len()) {
-            append_char_at(cmd, arg, i);
-        }
-        if quote {
-            cmd.push_char('"');
-        }
-    }
-
-    fn append_char_at(cmd: &mut ~str, arg: &str, i: uint) {
-        match arg[i] as char {
-            '"' => {
-                // Escape quotes.
-                cmd.push_str("\\\"");
-            }
-            '\\' => {
-                if backslash_run_ends_in_quote(arg, i) {
-                    // Double all backslashes that are in runs before quotes.
-                    cmd.push_str("\\\\");
-                } else {
-                    // Pass other backslashes through unescaped.
-                    cmd.push_char('\\');
-                }
-            }
-            c => {
-                cmd.push_char(c);
-            }
-        }
-    }
-
-    fn backslash_run_ends_in_quote(s: &str, mut i: uint) -> bool {
-        while i < s.len() && s[i] as char == '\\' {
-            i += 1;
-        }
-        return i < s.len() && s[i] as char == '"';
-    }
-}
-
-#[cfg(unix)]
-fn spawn_process_os(prog: &str, args: &[~str],
-                    env: Option<~[(~str, ~str)]>,
-                    dir: Option<&Path>,
-                    in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
-    #[fixed_stack_segment]; #[inline(never)];
-
-    use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
-    use libc::funcs::bsd44::getdtablesize;
-
-    mod rustrt {
-        #[abi = "cdecl"]
-        extern {
-            pub fn rust_unset_sigprocmask();
-        }
-    }
-
-    #[cfg(windows)]
-    unsafe fn set_environ(_envp: *c_void) {}
-    #[cfg(target_os = "macos")]
-    unsafe fn set_environ(envp: *c_void) {
-        externfn!(fn _NSGetEnviron() -> *mut *c_void);
-
-        *_NSGetEnviron() = envp;
-    }
-    #[cfg(not(target_os = "macos"), not(windows))]
-    unsafe fn set_environ(envp: *c_void) {
-        extern {
-            static mut environ: *c_void;
-        }
-        environ = envp;
-    }
-
-    unsafe {
-
-        let pid = fork();
-        if pid < 0 {
-            fail2!("failure in fork: {}", os::last_os_error());
-        } else if pid > 0 {
-            return SpawnProcessResult {pid: pid, handle: ptr::null()};
-        }
-
-        rustrt::rust_unset_sigprocmask();
-
-        if dup2(in_fd, 0) == -1 {
-            fail2!("failure in dup2(in_fd, 0): {}", os::last_os_error());
-        }
-        if dup2(out_fd, 1) == -1 {
-            fail2!("failure in dup2(out_fd, 1): {}", os::last_os_error());
-        }
-        if dup2(err_fd, 2) == -1 {
-            fail2!("failure in dup3(err_fd, 2): {}", os::last_os_error());
-        }
-        // close all other fds
-        for fd in range(3, getdtablesize()).invert() {
-            close(fd as c_int);
-        }
-
-        do with_dirp(dir) |dirp| {
-            if !dirp.is_null() && chdir(dirp) == -1 {
-                fail2!("failure in chdir: {}", os::last_os_error());
-            }
-        }
-
-        do with_envp(env) |envp| {
-            if !envp.is_null() {
-                set_environ(envp);
-            }
-            do with_argv(prog, args) |argv| {
-                execvp(*argv, argv);
-                // execvp only returns if an error occurred
-                fail2!("failure in execvp: {}", os::last_os_error());
-            }
-        }
-    }
-}
-
-#[cfg(unix)]
-fn with_argv<T>(prog: &str, args: &[~str], cb: &fn(**libc::c_char) -> T) -> T {
-    use vec;
-
-    // We can't directly convert `str`s into `*char`s, as someone needs to hold
-    // a reference to the intermediary byte buffers. So first build an array to
-    // hold all the ~[u8] byte strings.
-    let mut tmps = vec::with_capacity(args.len() + 1);
-
-    tmps.push(prog.to_c_str());
-
-    for arg in args.iter() {
-        tmps.push(arg.to_c_str());
-    }
-
-    // Next, convert each of the byte strings into a pointer. This is
-    // technically unsafe as the caller could leak these pointers out of our
-    // scope.
-    let mut ptrs = do tmps.map |tmp| {
-        tmp.with_ref(|buf| buf)
-    };
-
-    // Finally, make sure we add a null pointer.
-    ptrs.push(ptr::null());
-
-    ptrs.as_imm_buf(|buf, _| cb(buf))
-}
-
-#[cfg(unix)]
-fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: &fn(*c_void) -> T) -> T {
-    use vec;
-
-    // On posixy systems we can pass a char** for envp, which is a
-    // null-terminated array of "k=v\n" strings. Like `with_argv`, we have to
-    // have a temporary buffer to hold the intermediary `~[u8]` byte strings.
-    match env {
-        Some(env) => {
-            let mut tmps = vec::with_capacity(env.len());
-
-            for pair in env.iter() {
-                let kv = format!("{}={}", pair.first(), pair.second());
-                tmps.push(kv.to_c_str());
-            }
-
-            // Once again, this is unsafe.
-            let mut ptrs = do tmps.map |tmp| {
-                tmp.with_ref(|buf| buf)
-            };
-            ptrs.push(ptr::null());
-
-            do ptrs.as_imm_buf |buf, _| {
-                unsafe { cb(cast::transmute(buf)) }
-            }
-        }
-        _ => cb(ptr::null())
-    }
-}
-
-#[cfg(windows)]
-fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
-    // On win32 we pass an "environment block" which is not a char**, but
-    // rather a concatenation of null-terminated k=v\0 sequences, with a final
-    // \0 to terminate.
-    match env {
-        Some(env) => {
-            let mut blk = ~[];
-
-            for pair in env.iter() {
-                let kv = format!("{}={}", pair.first(), pair.second());
-                blk.push_all(kv.as_bytes());
-                blk.push(0);
-            }
-
-            blk.push(0);
-
-            do blk.as_imm_buf |p, _len| {
-                unsafe { cb(cast::transmute(p)) }
-            }
-        }
-        _ => cb(ptr::mut_null())
-    }
-}
-
-fn with_dirp<T>(d: Option<&Path>, cb: &fn(*libc::c_char) -> T) -> T {
-    match d {
-      Some(dir) => dir.with_c_str(|buf| cb(buf)),
-      None => cb(ptr::null())
-    }
-}
-
-#[cfg(windows)]
-fn free_handle(handle: *()) {
-    #[fixed_stack_segment]; #[inline(never)];
-    unsafe {
-        libc::funcs::extra::kernel32::CloseHandle(cast::transmute(handle));
-    }
-}
-
-#[cfg(unix)]
-fn free_handle(_handle: *()) {
-    // unix has no process handle object, just a pid
-}
-
 /**
  * Spawns a process and waits for it to terminate. The process will
  * inherit the current stdin/stdout/stderr file descriptors.
@@ -825,13 +276,14 @@ fn free_handle(_handle: *()) {
  *
  * The process's exit code
  */
+#[fixed_stack_segment] #[inline(never)]
 pub fn process_status(prog: &str, args: &[~str]) -> int {
     let mut prog = Process::new(prog, args, ProcessOptions {
         env: None,
         dir: None,
-        in_fd: Some(0),
-        out_fd: Some(1),
-        err_fd: Some(2)
+        in_fd: Some(unsafe { libc::dup(libc::STDIN_FILENO) }),
+        out_fd: Some(unsafe { libc::dup(libc::STDOUT_FILENO) }),
+        err_fd: Some(unsafe { libc::dup(libc::STDERR_FILENO) })
     });
     prog.finish()
 }
@@ -853,107 +305,6 @@ pub fn process_output(prog: &str, args: &[~str]) -> ProcessOutput {
     prog.finish_with_output()
 }
 
-/**
- * Waits for a process to exit and returns the exit code, failing
- * if there is no process with the specified id.
- *
- * Note that this is private to avoid race conditions on unix where if
- * a user calls waitpid(some_process.get_id()) then some_process.finish()
- * and some_process.destroy() and some_process.finalize() will then either
- * operate on a none-existent process or, even worse, on a newer process
- * with the same id.
- */
-fn waitpid(pid: pid_t) -> int {
-    return waitpid_os(pid);
-
-    #[cfg(windows)]
-    fn waitpid_os(pid: pid_t) -> int {
-        #[fixed_stack_segment]; #[inline(never)];
-
-        use libc::types::os::arch::extra::DWORD;
-        use libc::consts::os::extra::{
-            SYNCHRONIZE,
-            PROCESS_QUERY_INFORMATION,
-            FALSE,
-            STILL_ACTIVE,
-            INFINITE,
-            WAIT_FAILED
-        };
-        use libc::funcs::extra::kernel32::{
-            OpenProcess,
-            GetExitCodeProcess,
-            CloseHandle,
-            WaitForSingleObject
-        };
-
-        unsafe {
-
-            let proc = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION, FALSE, pid as DWORD);
-            if proc.is_null() {
-                fail2!("failure in OpenProcess: {}", os::last_os_error());
-            }
-
-            loop {
-                let mut status = 0;
-                if GetExitCodeProcess(proc, &mut status) == FALSE {
-                    CloseHandle(proc);
-                    fail2!("failure in GetExitCodeProcess: {}", os::last_os_error());
-                }
-                if status != STILL_ACTIVE {
-                    CloseHandle(proc);
-                    return status as int;
-                }
-                if WaitForSingleObject(proc, INFINITE) == WAIT_FAILED {
-                    CloseHandle(proc);
-                    fail2!("failure in WaitForSingleObject: {}", os::last_os_error());
-                }
-            }
-        }
-    }
-
-    #[cfg(unix)]
-    fn waitpid_os(pid: pid_t) -> int {
-        #[fixed_stack_segment]; #[inline(never)];
-
-        use libc::funcs::posix01::wait::*;
-
-        #[cfg(target_os = "linux")]
-        #[cfg(target_os = "android")]
-        fn WIFEXITED(status: i32) -> bool {
-            (status & 0xffi32) == 0i32
-        }
-
-        #[cfg(target_os = "macos")]
-        #[cfg(target_os = "freebsd")]
-        fn WIFEXITED(status: i32) -> bool {
-            (status & 0x7fi32) == 0i32
-        }
-
-        #[cfg(target_os = "linux")]
-        #[cfg(target_os = "android")]
-        fn WEXITSTATUS(status: i32) -> i32 {
-            (status >> 8i32) & 0xffi32
-        }
-
-        #[cfg(target_os = "macos")]
-        #[cfg(target_os = "freebsd")]
-        fn WEXITSTATUS(status: i32) -> i32 {
-            status >> 8i32
-        }
-
-        let mut status = 0 as c_int;
-        if unsafe { waitpid(pid, &mut status, 0) } == -1 {
-            fail2!("failure in waitpid: {}", os::last_os_error());
-        }
-
-        return if WIFEXITED(status) {
-            WEXITSTATUS(status) as int
-        } else {
-            1
-        };
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use io;
@@ -966,27 +317,6 @@ mod tests {
     use unstable::running_on_valgrind;
 
     #[test]
-    #[cfg(windows)]
-    fn test_make_command_line() {
-        assert_eq!(
-            run::make_command_line("prog", [~"aaa", ~"bbb", ~"ccc"]),
-            ~"prog aaa bbb ccc"
-        );
-        assert_eq!(
-            run::make_command_line("C:\\Program Files\\blah\\blah.exe", [~"aaa"]),
-            ~"\"C:\\Program Files\\blah\\blah.exe\" aaa"
-        );
-        assert_eq!(
-            run::make_command_line("C:\\Program Files\\test", [~"aa\"bb"]),
-            ~"\"C:\\Program Files\\test\" aa\\\"bb"
-        );
-        assert_eq!(
-            run::make_command_line("echo", [~"a b c"]),
-            ~"echo \"a b c\""
-        );
-    }
-
-    #[test]
     #[cfg(not(target_os="android"))]
     fn test_process_status() {
         assert_eq!(run::process_status("false", []), 1);
@@ -1068,10 +398,6 @@ mod tests {
             err_fd: Some(pipe_err.out)
         });
 
-        assert!(proc.input_redirected());
-        assert!(proc.output_redirected());
-        assert!(proc.error_redirected());
-
         os::close(pipe_in.input);
         os::close(pipe_out.out);
         os::close(pipe_err.out);
@@ -1223,36 +549,6 @@ mod tests {
         }
     }
 
-    #[test]
-    #[should_fail]
-    #[cfg(not(windows),not(target_os="android"))]
-    fn test_finish_with_output_redirected() {
-        let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions {
-            env: None,
-            dir: None,
-            in_fd: Some(0),
-            out_fd: Some(1),
-            err_fd: Some(2)
-        });
-        // this should fail because it is not valid to read the output when it was redirected
-        prog.finish_with_output();
-    }
-    #[test]
-    #[should_fail]
-    #[cfg(not(windows),target_os="android")]
-    fn test_finish_with_output_redirected() {
-        let mut prog = run::Process::new("/system/bin/sh", [~"-c",~"echo hello"],
-                                         run::ProcessOptions {
-            env: None,
-            dir: None,
-            in_fd: Some(0),
-            out_fd: Some(1),
-            err_fd: Some(2)
-        });
-        // this should fail because it is not valid to read the output when it was redirected
-        prog.finish_with_output();
-    }
-
     #[cfg(unix,not(target_os="android"))]
     fn run_pwd(dir: Option<&Path>) -> run::Process {
         run::Process::new("pwd", [], run::ProcessOptions {