Function resolve_executable 

pub fn resolve_executable(
    requested: &Path,
    current_dir: &Path,
    search_directories: &[PathBuf],
) -> Result<PathBuf, ResolutionError>

Resolve one executable candidate without reading ambient PATH or running it.

Requests containing / are literal paths, including ./tool; absolute paths are used directly and relative paths are rooted at current_dir. Other names search only search_directories, in order. Relative search directories and explicitly supplied empty entries are rooted at current_dir; an empty list searches nothing. The working directory must be absolute, even if unused. No HOME/default installation directory, shell expansion or fallback is added.

Selection requires a regular file with at least one Unix execute permission bit. Search skips missing candidates (including dangling symlinks), directories and nonexecutable files, and stops on other filesystem errors. Once an eligible candidate is observed, canonicalization errors stop selection, including if that candidate disappears. All search directories are checked for NUL before a name search; literal requests ignore the unused search list. Symlinks are followed and the result is canonical and absolute. Permission bits do not prove effective user access or interpreter validity. Caller-owned trusted path trees and exclusion of concurrent writers remain necessary; this path is not a frozen file capability.

A selected path must still undergo super::AdmittedTool::admit with the consumer’s digest, byte bound and exact version authority before execution. No candidate is retried or replaced after that admission fails.

Errors

Returns typed invalid-input, missing/nonexecutable or filesystem failures.

Examples found in repository

examples/resolve_tool.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use ic_host_tools::tool::resolve_executable;
    use std::{io, path::PathBuf};

    let mut args = std::env::args_os().skip(1);
    let mut required = || {
        args.next().map(PathBuf::from).ok_or_else(|| {
            io::Error::new(
                io::ErrorKind::InvalidInput,
                "usage: resolve_tool REQUEST ABSOLUTE_WORKDIR [SEARCH_DIRECTORY ...]",
            )
        })
    };
    let requested = required()?;
    let current_dir = required()?;
    let directories = args.map(PathBuf::from).collect::<Vec<_>>();
    let selected = resolve_executable(&requested, &current_dir, &directories)?;
    // Debug quoting preserves non-UTF-8 paths and prevents control characters
    // from becoming additional terminal lines. This example intentionally prints
    // the selected path, not a trust or executable identity claim.
    println!("candidate={:?}", selected.as_os_str());
    Ok(())
}