485 lines · 19.7 KB · Rust
RawDownload
//! Launch commands very similarly to `Command`, but with `git` specific capabilities and adjustments.#![deny(rust_2018_idioms, missing_docs)]#![forbid(unsafe_code)] use std::io::Read;use std::{    ffi::OsString,    path::{Path, PathBuf},}; use bstr::{BString, ByteSlice}; /// A structure to keep settings to use when invoking a command via [`spawn()`][Prepare::spawn()], after creating it with [`prepare()`].pub struct Prepare {    /// The command to invoke (either with or without shell depending on `use_shell`.    pub command: OsString,    /// Additional information to be passed to the spawned command.    pub context: Option<Context>,    /// The way standard input is configured.    pub stdin: std::process::Stdio,    /// The way standard output is configured.    pub stdout: std::process::Stdio,    /// The way standard error is configured.    pub stderr: std::process::Stdio,    /// The arguments to pass to the spawned process.    pub args: Vec<OsString>,    /// environment variables to set in the spawned process.    pub env: Vec<(OsString, OsString)>,    /// If `true`, we will use `shell_program` or `sh` to execute the `command`.    pub use_shell: bool,    /// The name or path to the shell program to use instead of `sh`.    pub shell_program: Option<OsString>,    /// If `true` (default `true` on windows and `false` everywhere else)    /// we will see if it's safe to manually invoke `command` after splitting    /// its arguments as a shell would do.    /// Note that outside of windows, it's generally not advisable as this    /// removes support for literal shell scripts with shell-builtins.    ///    /// This mimics the behaviour we see with `git` on windows, which also    /// won't invoke the shell there at all.    ///    /// Only effective if `use_shell` is `true` as well, as the shell will    /// be used as a fallback if it's not possible to split arguments as    /// the command-line contains 'scripting'.    pub allow_manual_arg_splitting: bool,} /// Additional information that is relevant to spawned processes, which typically receive/// a wealth of contextual information when spawned from `git`.////// See [the git source code](https://github.com/git/git/blob/cfb8a6e9a93adbe81efca66e6110c9b4d2e57169/git.c#L191)/// for details.#[derive(Debug, Default, Clone)]pub struct Context {    /// The `.git` directory that contains the repository.    ///    /// If set, it will be used to set the `GIT_DIR` environment variable.    pub git_dir: Option<PathBuf>,    /// Set the `GIT_WORK_TREE` environment variable with the given path.    pub worktree_dir: Option<PathBuf>,    /// If `true`, set `GIT_NO_REPLACE_OBJECTS` to `1`, which turns off object replacements, or `0` otherwise.    /// If `None`, the variable won't be set.    pub no_replace_objects: Option<bool>,    /// Set the `GIT_NAMESPACE` variable with the given value, effectively namespacing all    /// operations on references.    pub ref_namespace: Option<BString>,    /// If `true`, set `GIT_LITERAL_PATHSPECS` to `1`, which makes globs literal and prefixes as well, or `0` otherwise.    /// If `None`, the variable won't be set.    pub literal_pathspecs: Option<bool>,    /// If `true`, set `GIT_GLOB_PATHSPECS` to `1`, which lets wildcards not match the `/` character, and equals the `:(glob)` prefix.    /// If `false`, set `GIT_NOGLOB_PATHSPECS` to `1` which lets globs match only themselves.    /// If `None`, the variable won't be set.    pub glob_pathspecs: Option<bool>,    /// If `true`, set `GIT_ICASE_PATHSPECS` to `1`, to let patterns match case-insensitively, or `0` otherwise.    /// If `None`, the variable won't be set.    pub icase_pathspecs: Option<bool>,    /// If `true`, inherit `stderr` just like it's the default when spawning processes.    /// If `false`, suppress all stderr output.    /// If not `None`, this will override any value set with [`Prepare::stderr()`].    pub stderr: Option<bool>,} mod prepare {    use std::borrow::Cow;    use std::{        ffi::OsString,        process::{Command, Stdio},    };     use bstr::ByteSlice;     use crate::{extract_interpreter, win_path_lookup, Context, Prepare};     /// Builder    impl Prepare {        /// If called, the command will not be executed directly, but with `sh`, but only if the        /// command passed to [`prepare`](super::prepare()) requires this.        ///        /// This also allows to pass shell scripts as command, or use commands that contain arguments which are subsequently        /// parsed by `sh`.        pub fn with_shell(mut self) -> Self {            self.use_shell = self.command.to_str().map_or(true, |cmd| {                cmd.as_bytes().find_byteset(b"|&;<>()$`\\\"' \t\n*?[#~=%").is_some()            });            self        }         /// Set the name or path to the shell `program` to use, to avoid using the default shell which is `sh`.        pub fn with_shell_program(mut self, program: impl Into<OsString>) -> Self {            self.shell_program = Some(program.into());            self        }         /// Unconditionally turn off using the shell when spawning the command.        /// Note that not using the shell is the default so an effective use of this method        /// is some time after [`with_shell()`][Prepare::with_shell()] was called.        pub fn without_shell(mut self) -> Self {            self.use_shell = false;            self        }         /// Set additional `ctx` to be used when spawning the process.        ///        /// Note that this is a must for most kind of commands that `git` usually spawns,        /// as at least they need to know the correct `git` repository to function.        pub fn with_context(mut self, ctx: Context) -> Self {            self.context = Some(ctx);            self        }         /// Use a shell, but try to split arguments by hand if this can be safely done without a shell.        ///        /// If that's not the case, use a shell instead.        pub fn with_shell_allow_manual_argument_splitting(mut self) -> Self {            self.allow_manual_arg_splitting = true;            self.with_shell()        }         /// Use a shell, but prohibit splitting arguments by hand even if this could be safely done without a shell.        pub fn with_shell_disallow_manual_argument_splitting(mut self) -> Self {            self.allow_manual_arg_splitting = false;            self.with_shell()        }         /// Configure the process to use `stdio` for _stdin.        pub fn stdin(mut self, stdio: Stdio) -> Self {            self.stdin = stdio;            self        }        /// Configure the process to use `stdio` for _stdout_.        pub fn stdout(mut self, stdio: Stdio) -> Self {            self.stdout = stdio;            self        }        /// Configure the process to use `stdio` for _stderr.        pub fn stderr(mut self, stdio: Stdio) -> Self {            self.stderr = stdio;            self        }         /// Add `arg` to the list of arguments to call the command with.        pub fn arg(mut self, arg: impl Into<OsString>) -> Self {            self.args.push(arg.into());            self        }         /// Add `args` to the list of arguments to call the command with.        pub fn args(mut self, args: impl IntoIterator<Item = impl Into<OsString>>) -> Self {            self.args                .append(&mut args.into_iter().map(Into::into).collect::<Vec<_>>());            self        }         /// Add `key` with `value` to the environment of the spawned command.        pub fn env(mut self, key: impl Into<OsString>, value: impl Into<OsString>) -> Self {            self.env.push((key.into(), value.into()));            self        }    }     /// Finalization    impl Prepare {        /// Spawn the command as configured.        pub fn spawn(self) -> std::io::Result<std::process::Child> {            let mut cmd = Command::from(self);            gix_trace::debug!(cmd = ?cmd);            cmd.spawn()        }    }     impl From<Prepare> for Command {        fn from(mut prep: Prepare) -> Command {            let mut cmd = if prep.use_shell {                let split_args = prep                    .allow_manual_arg_splitting                    .then(|| {                        if gix_path::into_bstr(std::borrow::Cow::Borrowed(prep.command.as_ref()))                            .find_byteset(b"\\|&;<>()$`\n*?[#~%")                            .is_none()                        {                            prep.command                                .to_str()                                .and_then(|args| shell_words::split(args).ok().map(Vec::into_iter))                        } else {                            None                        }                    })                    .flatten();                match split_args {                    Some(mut args) => {                        let mut cmd = Command::new(args.next().expect("non-empty input"));                        cmd.args(args);                        cmd                    }                    None => {                        let mut cmd = Command::new(                            prep.shell_program                                .unwrap_or(if cfg!(windows) { "sh" } else { "/bin/sh" }.into()),                        );                        cmd.arg("-c");                        if !prep.args.is_empty() {                            if prep.command.to_str().map_or(true, |cmd| !cmd.contains("$@")) {                                prep.command.push(" \"$@\"");                            } else {                                gix_trace::debug!(                                    "Will not add '$@' to '{:?}' as it seems to contain it already",                                    prep.command                                );                            }                        }                        cmd.arg(prep.command);                        cmd.arg("--");                        cmd                    }                }            } else if cfg!(windows) {                let program: Cow<'_, std::path::Path> = std::env::var_os("PATH")                    .and_then(|path| win_path_lookup(prep.command.as_ref(), &path))                    .map(Cow::Owned)                    .unwrap_or(Cow::Borrowed(prep.command.as_ref()));                if let Some(shebang) = extract_interpreter(program.as_ref()) {                    let mut cmd = Command::new(shebang.interpreter);                    // For relative paths, we may have picked up a file in the current repository                    // for which an attacker could control everything. Hence, strip options just like Git.                    // If the file was found in the PATH though, it should be trustworthy.                    if program.is_absolute() {                        cmd.args(shebang.args);                    }                    cmd.arg(prep.command);                    cmd                } else {                    Command::new(prep.command)                }            } else {                Command::new(prep.command)            };            // We never want to have terminals pop-up on Windows if this runs from a GUI application.            #[cfg(windows)]            {                use std::os::windows::process::CommandExt;                const CREATE_NO_WINDOW: u32 = 0x08000000;                cmd.creation_flags(CREATE_NO_WINDOW);            }            cmd.stdin(prep.stdin)                .stdout(prep.stdout)                .stderr(prep.stderr)                .envs(prep.env)                .args(prep.args);            if let Some(ctx) = prep.context {                if let Some(git_dir) = ctx.git_dir {                    cmd.env("GIT_DIR", &git_dir);                }                if let Some(worktree_dir) = ctx.worktree_dir {                    cmd.env("GIT_WORK_TREE", worktree_dir);                }                if let Some(value) = ctx.no_replace_objects {                    cmd.env("GIT_NO_REPLACE_OBJECTS", usize::from(value).to_string());                }                if let Some(namespace) = ctx.ref_namespace {                    cmd.env("GIT_NAMESPACE", gix_path::from_bstring(namespace));                }                if let Some(value) = ctx.literal_pathspecs {                    cmd.env("GIT_LITERAL_PATHSPECS", usize::from(value).to_string());                }                if let Some(value) = ctx.glob_pathspecs {                    cmd.env(                        if value {                            "GIT_GLOB_PATHSPECS"                        } else {                            "GIT_NOGLOB_PATHSPECS"                        },                        "1",                    );                }                if let Some(value) = ctx.icase_pathspecs {                    cmd.env("GIT_ICASE_PATHSPECS", usize::from(value).to_string());                }                if let Some(stderr) = ctx.stderr {                    cmd.stderr(if stderr { Stdio::inherit() } else { Stdio::null() });                }            }            cmd        }    }} fn is_exe(executable: &Path) -> bool {    executable.extension() == Some(std::ffi::OsStr::new("exe"))} /// Try to find `command` in the `path_value` (the value of `PATH`) as separated by `;`, or return `None`./// Has special handling for `.exe` extensions, as these will be appended automatically if needed./// Note that just like Git, no lookup is performed if a slash or backslash is in `command`.fn win_path_lookup(command: &Path, path_value: &std::ffi::OsStr) -> Option<PathBuf> {    fn lookup(root: &bstr::BStr, command: &Path, is_exe: bool) -> Option<PathBuf> {        let mut path = gix_path::try_from_bstr(root).ok()?.join(command);        if !is_exe {            path.set_extension("exe");        }        if path.is_file() {            return Some(path);        }        if is_exe {            return None;        }        path.set_extension("");        path.is_file().then_some(path)    }    if command.components().take(2).count() == 2 {        return None;    }    let path = gix_path::os_str_into_bstr(path_value).ok()?;    let is_exe = is_exe(command);     for root in path.split(|b| *b == b';') {        if let Some(executable) = lookup(root.as_bstr(), command, is_exe) {            return Some(executable);        }    }    None} /// Parse the shebang (`#!<path>`) from the first line of `executable`, and return the shebang/// data when available.pub fn extract_interpreter(executable: &Path) -> Option<shebang::Data> {    #[cfg(windows)]    if is_exe(executable) {        return None;    }    let mut buf = [0; 100]; // Note: just like Git    let mut file = std::fs::File::open(executable).ok()?;    let n = file.read(&mut buf).ok()?;    shebang::parse(buf[..n].as_bstr())} ///pub mod shebang {    use bstr::{BStr, ByteSlice};    use std::ffi::OsString;    use std::path::PathBuf;     /// Parse `buf` to extract all shebang information.    pub fn parse(buf: &BStr) -> Option<Data> {        let mut line = buf.lines().next()?;        line = line.strip_prefix(b"#!")?;         let slash_idx = line.rfind_byteset(b"/\\")?;        Some(match line[slash_idx..].find_byte(b' ') {            Some(space_idx) => {                let space = slash_idx + space_idx;                Data {                    interpreter: gix_path::from_byte_slice(line[..space].trim()).to_owned(),                    args: line                        .get(space + 1..)                        .and_then(|mut r| {                            r = r.trim();                            if r.is_empty() {                                return None;                            }                             match r.as_bstr().to_str() {                                Ok(args) => shell_words::split(args)                                    .ok()                                    .map(|args| args.into_iter().map(Into::into).collect()),                                Err(_) => Some(vec![gix_path::from_byte_slice(r).to_owned().into()]),                            }                        })                        .unwrap_or_default(),                }            }            None => Data {                interpreter: gix_path::from_byte_slice(line.trim()).to_owned(),                args: Vec::new(),            },        })    }     /// Shebang information as [parsed](parse()) from a buffer that should contain at least one line.    ///    /// ### Deviation    ///    /// According to the [shebang documentation](https://en.wikipedia.org/wiki/Shebang_(Unix)), it will only consider    /// the path of the executable, along with the arguments as the consecutive portion after the space that separates    /// them. Argument splitting would then have to be done elsewhere, probably in the kernel.    ///    /// To make that work without the kernel, we perform the splitting while Git just ignores options.    /// For now it seems more compatible to not ignore options, but if it is important this could be changed.    #[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]    pub struct Data {        /// The interpreter to run.        pub interpreter: PathBuf,        /// The remainder of the line past the space after `interpreter`, without leading or trailing whitespace,        /// as pre-split arguments just like a shell would do it.        /// Note that we accept that illformed UTF-8 will prevent argument splitting.        pub args: Vec<OsString>,    }} /// Prepare `cmd` for [spawning][std::process::Command::spawn()] by configuring it with various builder methods.////// Note that the default IO is configured for typical API usage, that is////// - `stdin` is null to prevent blocking unexpectedly on consumption of stdin/// - `stdout` is captured for consumption by the caller/// - `stderr` is inherited to allow the command to provide context to the user////// On Windows, terminal Windows will be suppressed automatically.////// ### Warning////// When using this method, be sure that the invoked program doesn't rely on the current working dir and/or/// environment variables to know its context. If so, call instead [`Prepare::with_context()`] to provide/// additional information.pub fn prepare(cmd: impl Into<OsString>) -> Prepare {    Prepare {        command: cmd.into(),        shell_program: None,        context: None,        stdin: std::process::Stdio::null(),        stdout: std::process::Stdio::piped(),        stderr: std::process::Stdio::inherit(),        args: Vec::new(),        env: Vec::new(),        use_shell: false,        allow_manual_arg_splitting: cfg!(windows),    }} #[cfg(test)]mod tests {    use super::*;     #[test]    fn internal_win_path_lookup() -> gix_testtools::Result {        let root = gix_testtools::scripted_fixture_read_only("win_path_lookup.sh")?;        let mut paths: Vec<_> = std::fs::read_dir(&root)?            .filter_map(Result::ok)            .map(|e| e.path().to_str().expect("no illformed UTF8").to_owned())            .collect();        paths.sort();        let lookup_path: OsString = paths.join(";").into();         assert_eq!(            win_path_lookup("a/b".as_ref(), &lookup_path),            None,            "any path with separator is considered ready to use"        );        assert_eq!(            win_path_lookup("x".as_ref(), &lookup_path),            Some(root.join("a").join("x.exe")),            "exe will be preferred, and it searches left to right thus doesn't find c/x.exe"        );        assert_eq!(            win_path_lookup("x.exe".as_ref(), &lookup_path),            Some(root.join("a").join("x.exe")),            "no matter what, a/x won't be found as it's shadowed by an exe file"        );        assert_eq!(            win_path_lookup("exe".as_ref(), &lookup_path),            Some(root.join("b").join("exe")),            "it finds files further down the path as well"        );        Ok(())    }}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t