From b1a964a9bf23c92a6b6cb5762b54e0f0f4a337d5 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 24 Jun 2014 12:10:31 -0700
Subject: [PATCH] native: Search the child's PATH on win32

In order to have the spawning semantics be the same for unix/windows, the
child's PATH environment variable needs to be searched rather than the parent's
environment variable.

If the child is inheriting the parent's PATH, then no action need be taken as
windows will do the heavy lifting. If the child specifies its own PATH, then it
is searched beforehand for the target program and the result is favored if a hit
is found.

cc #15149, but does not close the issue because libgreen still needs to be
updated.
---
 src/libnative/io/process.rs      | 22 ++++++++++++-
 src/test/run-pass/issue-15149.rs | 56 ++++++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+), 1 deletion(-)
 create mode 100644 src/test/run-pass/issue-15149.rs

diff --git a/src/libnative/io/process.rs b/src/libnative/io/process.rs
index 21da0104c2f8d..e3e6ae425266e 100644
--- a/src/libnative/io/process.rs
+++ b/src/libnative/io/process.rs
@@ -305,6 +305,25 @@ fn spawn_process_os(cfg: ProcessConfig,
         })
     }
 
+    // To have the spawning semantics of unix/windows stay the same, we need to
+    // read the *child's* PATH if one is provided. See #15149 for more details.
+    let program = cfg.env.and_then(|env| {
+        for &(ref key, ref v) in env.iter() {
+            if b"PATH" != key.as_bytes_no_nul() { continue }
+
+            // Split the value and test each path to see if the program exists.
+            for path in os::split_paths(v.as_bytes_no_nul()).move_iter() {
+                let path = path.join(cfg.program.as_bytes_no_nul())
+                               .with_extension(os::consts::EXE_EXTENSION);
+                if path.exists() {
+                    return Some(path.to_c_str())
+                }
+            }
+            break
+        }
+        None
+    });
+
     unsafe {
         let mut si = zeroed_startupinfo();
         si.cb = mem::size_of::<STARTUPINFO>() as DWORD;
@@ -362,7 +381,8 @@ fn spawn_process_os(cfg: ProcessConfig,
         try!(set_fd(&out_fd, &mut si.hStdOutput, false));
         try!(set_fd(&err_fd, &mut si.hStdError, false));
 
-        let cmd_str = make_command_line(cfg.program, cfg.args);
+        let cmd_str = make_command_line(program.as_ref().unwrap_or(cfg.program),
+                                        cfg.args);
         let mut pi = zeroed_process_information();
         let mut create_err = None;
 
diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs
new file mode 100644
index 0000000000000..d76a7109ced8e
--- /dev/null
+++ b/src/test/run-pass/issue-15149.rs
@@ -0,0 +1,56 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(phase)]
+extern crate native;
+#[phase(plugin)]
+extern crate green;
+
+use native::NativeTaskBuilder;
+use std::io::{TempDir, Command, fs};
+use std::os;
+use std::task::TaskBuilder;
+
+// FIXME(#15149) libgreen still needs to be update. There is an open PR for it
+//               but it is not yet merged.
+// green_start!(main)
+
+fn main() {
+    // If we're the child, make sure we were invoked correctly
+    let args = os::args();
+    if args.len() > 1 && args.get(1).as_slice() == "child" {
+        return assert_eq!(args.get(0).as_slice(), "mytest");
+    }
+
+    test();
+    let (tx, rx) = channel();
+    TaskBuilder::new().native().spawn(proc() {
+        tx.send(test());
+    });
+    rx.recv();
+}
+
+fn test() {
+    // If we're the parent, copy our own binary to a tempr directory, and then
+    // make it executable.
+    let dir = TempDir::new("mytest").unwrap();
+    let me = os::self_exe_name().unwrap();
+    let dest = dir.path().join(format!("mytest{}", os::consts::EXE_SUFFIX));
+    fs::copy(&me, &dest).unwrap();
+
+    // Append the temp directory to our own PATH.
+    let mut path = os::split_paths(os::getenv("PATH").unwrap_or(String::new()));
+    path.push(dir.path().clone());
+    let path = os::join_paths(path.as_slice()).unwrap();
+
+    Command::new("mytest").env("PATH", path.as_slice())
+                          .arg("child")
+                          .spawn().unwrap();
+}