diff options
Diffstat (limited to 'vendor/gix-command/src/lib.rs')
| -rw-r--r-- | vendor/gix-command/src/lib.rs | 159 |
1 files changed, 148 insertions, 11 deletions
diff --git a/vendor/gix-command/src/lib.rs b/vendor/gix-command/src/lib.rs index 9e662b016..e23275e73 100644 --- a/vendor/gix-command/src/lib.rs +++ b/vendor/gix-command/src/lib.rs @@ -2,12 +2,16 @@ #![deny(rust_2018_idioms, missing_docs)] #![forbid(unsafe_code)] -use std::ffi::OsString; +use std::{ffi::OsString, path::PathBuf}; + +use bstr::BString; /// 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. @@ -20,6 +24,54 @@ pub struct Prepare { pub env: Vec<(OsString, OsString)>, /// If `true`, we will use `sh` to execute the `command`. pub use_shell: bool, + /// 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 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 { @@ -30,11 +82,12 @@ mod prepare { use bstr::ByteSlice; - use crate::Prepare; + use crate::{Context, Prepare}; /// Builder impl Prepare { - /// If called, the command will not be executed directly, but with `sh`. + /// If called, the command will not be executed directly, but with `sh`, but ony 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`. @@ -53,6 +106,23 @@ mod prepare { 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 be safely done without a shell. + /// + /// If that's not the case, use a shell instead. + pub fn with_shell_allow_argument_splitting(mut self) -> Self { + self.allow_manual_arg_splitting = true; + self.with_shell() + } + /// Configure the process to use `stdio` for _stdin. pub fn stdin(mut self, stdio: Stdio) -> Self { self.stdin = stdio; @@ -93,21 +163,47 @@ mod prepare { impl Prepare { /// Spawn the command as configured. pub fn spawn(self) -> std::io::Result<std::process::Child> { - Command::from(self).spawn() + 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 mut cmd = Command::new(if cfg!(windows) { "sh" } else { "/bin/sh" }); - cmd.arg("-c"); - if !prep.args.is_empty() { - prep.command.push(" \"$@\"") + 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(if cfg!(windows) { "sh" } else { "/bin/sh" }); + cmd.arg("-c"); + if !prep.args.is_empty() { + prep.command.push(" \"$@\"") + } + cmd.arg(prep.command); + cmd.arg("--"); + cmd + } } - cmd.arg(prep.command); - cmd.arg("--"); - cmd } else { Command::new(prep.command) }; @@ -116,6 +212,39 @@ mod prepare { .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 } } @@ -128,14 +257,22 @@ mod prepare { /// - `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 +/// +/// ### 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(), + 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), } } |