fix: check path is valid executable when resolving command name (#154)

Author: dsherret

Cargo.toml

@@ -29,7 +29,7 @@ sys_traits = { version = "0.1.14", optional = true, features = ["real", "winapi"
 which = { version = "8.0.0", default-features = false, optional = true }
 
 [target.'cfg(unix)'.dependencies]
-nix = { version = "0.29.0", features = ["signal"], optional = true }
+nix = { version = "0.29.0", features = ["fs", "signal"], optional = true }
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.59.0", features = ["Win32_Security", "Win32_System_JobObjects", "Win32_System_Threading"], optional = true }

src/shell/command.rs

@@ -125,7 +125,7 @@ async fn resolve_command<'a>(
   // only bother checking for a shebang when the path has a slash
   // in it because for global commands someone on Windows likely
   // won't have a script with a shebang in it on Windows
-  if command_name.name.to_string_lossy().contains('/') {
+  if Path::new(&command_name.name).components().count() > 1 {
     if let Some(shebang) = resolve_shebang(&command_path).map_err(|err| {
       ResolveCommandError::FailedShebang(FailedShebangError::Any(err.into()))
     })? {

src/shell/execute.rs

@@ -839,7 +839,7 @@ fn evaluate_word_parts(
           }
         }
       }
-      let is_absolute = std::path::PathBuf::from(&current_text).is_absolute();
+      let is_absolute = Path::new(&current_text).is_absolute();
       let cwd = state.cwd();
       let pattern = if is_absolute {
         current_text

src/shell/types.rs

@@ -8,6 +8,7 @@ use std::ffi::OsStr;
 use std::ffi::OsString;
 use std::io::Read;
 use std::io::Write;
+use std::path::Path;
 use std::path::PathBuf;
 use std::rc::Rc;
 use std::rc::Weak;
@@ -148,11 +149,11 @@ impl ShellState {
       name.to_os_string()
     };
     if name == "PWD" {
-      let cwd = PathBuf::from(value);
+      let cwd = Path::new(value);
       if cwd.is_absolute() {
         if let Ok(cwd) = deno_path_util::fs::canonicalize_path_maybe_not_exists(
           &sys_traits::impls::RealSys,
-          &cwd,
+          cwd,
         ) {
           // this will update the environment variable too
           self.set_cwd(cwd);

src/shell/which.rs

@@ -42,9 +42,12 @@ pub fn resolve_command_path(
     return Err(CommandPathResolutionError::CommandEmpty);
   }
 
-  // check for absolute
-  if PathBuf::from(command_name).is_absolute() {
-    return Ok(PathBuf::from(command_name));
+  // check for absolute or relative path
+  let path = Path::new(command_name);
+  if path.is_absolute() {
+    return Ok(path.to_path_buf());
+  } else if path.components().count() > 1 {
+    return Ok(base_dir.join(command_name));
   }
 
   let result = which::WhichConfig::new_with_sys(state.clone())
@@ -95,7 +98,7 @@ impl which::sys::Sys for ShellState {
   fn env_windows_path_ext(&self) -> Cow<'static, [String]> {
     Cow::Owned(
       self
-        .env_path_ext()
+        .get_var(OsStr::new("PATHEXT"))
         .and_then(|pathext| {
           Some(
             pathext
@@ -141,13 +144,42 @@ impl which::sys::Sys for ShellState {
     Ok(Box::new(iter))
   }
 
+  #[cfg(unix)]
   fn is_valid_executable(
     &self,
-    _path: &std::path::Path,
+    path: &std::path::Path,
   ) -> std::io::Result<bool> {
-    // we've considered everything to be executable so that cross platform
-    // shebangs work and so that people don't need to bother marking an
-    // item as executable in git, which is annoying for Windows users
-    Ok(true)
+    use nix::unistd::AccessFlags;
+    use nix::unistd::access;
+
+    match access(path, AccessFlags::X_OK) {
+      Ok(()) => Ok(true),
+      Err(nix::errno::Errno::ENOENT) => Ok(false),
+      Err(e) => Err(std::io::Error::from_raw_os_error(e as i32)),
+    }
+  }
+
+  #[cfg(windows)]
+  fn is_valid_executable(
+    &self,
+    path: &std::path::Path,
+  ) -> std::io::Result<bool> {
+    use std::os::windows::ffi::OsStrExt;
+
+    let name = path
+      .as_os_str()
+      .encode_wide()
+      .chain(Some(0))
+      .collect::<Vec<u16>>();
+    let mut bt: u32 = 0;
+    // SAFETY: winapi call
+    unsafe {
+      Ok(
+        windows_sys::Win32::Storage::FileSystem::GetBinaryTypeW(
+          name.as_ptr(),
+          &mut bt,
+        ) != 0,
+      )
+    }
   }
 }