Files
codex/codex-rs/git-utils/src/guarded_config.rs
T

2188 lines
76 KiB
Rust

use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::ffi::OsStr;
use std::io;
use std::io::Seek;
use std::path::Path;
use std::path::PathBuf;
use std::process::Stdio;
use std::sync::Arc;
use crate::FsmonitorOverride;
use crate::git_command::GitAsyncCommand;
use crate::git_command::GitCommand;
use crate::git_command::GitRunner;
use crate::git_command::IsolatedGitStorage;
use crate::git_command::MAX_INTERNAL_GIT_OUTPUT_BYTES;
use crate::git_config::GitConfigEntry;
use crate::git_config::GitConfigOrigin;
use crate::git_config::GitConfigValue;
use crate::git_config::MergeConfigRecord;
use crate::git_config::parse_config_entries;
use crate::git_config::parse_config_entries_with_origins;
use crate::git_config::read_effective_config_with_fallback;
use crate::git_config::read_effective_config_with_fallback_async;
use crate::git_config::read_effective_shared_repository_with_fallback;
use crate::git_config::read_merge_config_records_with_fallback;
use crate::git_config_sources::ensure_no_worktree_config_sources;
use crate::git_config_sources::ensure_no_worktree_config_sources_async;
use crate::safe_git::DISABLED_HOOKS_PATH;
use crate::safe_git::ExecutableFilterDrivers;
use crate::safe_git::FilterAttributeValue;
use crate::safe_git::FilterExecution;
use crate::safe_git::FilterPolicyRole;
use crate::safe_git::FilterPolicySnapshot;
use crate::safe_git::MAX_EXECUTABLE_FILTER_DRIVERS;
use crate::safe_git::SelectedFilterPolicy;
use crate::safe_git::SentinelFilterProbeBudget;
use crate::safe_git::SentinelFilterProbeResolution;
use crate::safe_git::build_filter_policy_snapshot;
use crate::safe_git::classify_selected_filter;
use crate::safe_git::classify_sentinel_filter_probes;
use crate::safe_git::status_policy_filter_drivers;
use crate::safe_git::git_path_argument;
use crate::safe_git::parse_filter_attributes;
use crate::safe_git::parse_nul_paths;
use crate::safe_git::validate_executable_driver_count;
use crate::safe_git::write_nul_paths;
const MAX_STATUS_TRACKED_PATHS: usize = 250_000;
const FILTER_NEUTRALIZATION_PLAN: [(&str, &str); 4] = [
("clean", ""),
("smudge", ""),
("process", ""),
("required", "false"),
];
mod merge_overlay;
use merge_overlay::SealedMergeConfigOverride;
#[cfg(test)]
pub(crate) use merge_overlay::merge_attribute_read_count;
#[cfg(test)]
pub(crate) use merge_overlay::merge_config_read_count;
#[cfg(test)]
pub(crate) use merge_overlay::merge_overlay_count;
#[cfg(test)]
pub(crate) use merge_overlay::reset_merge_policy_counts;
mod reverse_probe;
mod status_context;
use status_context::SealedStatusReadContext;
/// Proof that one exact Git config invocation has no worktree-controlled
/// source routes for one runner and canonical repository root.
///
/// The capability deliberately owns the ordered base arguments and cannot be
/// cloned or rebound to another runner, root, or command environment.
pub(crate) struct ValidatedConfigSources<'git> {
git: &'git GitRunner,
canonical_root: PathBuf,
base_config_args: Box<[String]>,
}
impl<'git> ValidatedConfigSources<'git> {
fn authorize(
git: &'git GitRunner,
canonical_root: &Path,
base_config_args: Vec<String>,
) -> io::Result<Self> {
#[cfg(test)]
CONFIG_SOURCE_AUTHORIZATION_COUNT.with(|count| count.set(count.get() + 1));
validate_base_config_args(&base_config_args)?;
let canonical_root = std::fs::canonicalize(canonical_root)?;
git.ensure_active_worktree_root(&canonical_root)?;
ensure_no_worktree_config_sources(git, &canonical_root, &base_config_args)?;
Ok(Self {
git,
canonical_root,
base_config_args: base_config_args.into_boxed_slice(),
})
}
async fn authorize_async(
git: &'git GitRunner,
canonical_root: &Path,
base_config_args: Vec<String>,
) -> io::Result<Self> {
#[cfg(test)]
CONFIG_SOURCE_AUTHORIZATION_COUNT.with(|count| count.set(count.get() + 1));
validate_base_config_args(&base_config_args)?;
let canonical_root = std::fs::canonicalize(canonical_root)?;
git.ensure_active_worktree_root(&canonical_root)?;
ensure_no_worktree_config_sources_async(git, &canonical_root, &base_config_args).await?;
Ok(Self {
git,
canonical_root,
base_config_args: base_config_args.into_boxed_slice(),
})
}
fn read_effective(
&self,
pattern: &str,
probe: &str,
) -> io::Result<BTreeMap<String, GitConfigEntry>> {
read_effective_config_with_fallback(
self.git,
&self.canonical_root,
&self.base_config_args,
pattern,
probe,
)
}
fn read_shared_repository(&self) -> io::Result<Option<GitConfigValue>> {
read_effective_shared_repository_with_fallback(
self.git,
&self.canonical_root,
&self.base_config_args,
)
}
fn read_merge_config(&self) -> io::Result<Vec<MergeConfigRecord>> {
read_merge_config_records_with_fallback(
self.git,
&self.canonical_root,
&self.base_config_args,
)
}
fn read_direct_common_config(
&self,
pattern: &str,
probe: &str,
) -> io::Result<BTreeMap<String, GitConfigEntry>> {
let (scoped, scoped_path) = self
.git
.read_active_common_config_without_includes(pattern, /*show_scope*/ true)?;
let entries = if scoped
.status
.code()
.is_some_and(|code| code == 0 || code == 1)
{
parse_config_entries(&scoped.stdout)?
} else {
let (legacy, legacy_path) = self
.git
.read_active_common_config_without_includes(pattern, /*show_scope*/ false)?;
if legacy_path != scoped_path {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"active Git common config changed during format fallback",
));
}
if !legacy
.status
.code()
.is_some_and(|code| code == 0 || code == 1)
{
return Err(io::Error::other(format!(
"git {probe} direct common config probe failed with status {}: {}",
legacy.status,
String::from_utf8_lossy(&legacy.stderr).trim()
)));
}
parse_config_entries_with_origins(&legacy.stdout)?
};
for entry in &entries {
let expected_origin = match &entry.origin {
GitConfigOrigin::File(origin) => {
same_file::is_same_file(origin, &scoped_path).unwrap_or(false)
}
GitConfigOrigin::CommandLine => false,
};
if !expected_origin {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
format!("git {probe} direct common config probe returned an unexpected origin"),
));
}
}
Ok(entries
.into_iter()
.map(|entry| (entry.key.clone(), entry))
.collect())
}
async fn read_direct_common_config_async(
&self,
pattern: &str,
probe: &str,
) -> io::Result<BTreeMap<String, GitConfigEntry>> {
let (scoped, scoped_path) = self
.git
.read_active_common_config_without_includes_async(pattern, /*show_scope*/ true)
.await?;
let entries = if scoped
.status
.code()
.is_some_and(|code| code == 0 || code == 1)
{
parse_config_entries(&scoped.stdout)?
} else {
let (legacy, legacy_path) = self
.git
.read_active_common_config_without_includes_async(
pattern,
/*show_scope*/ false,
)
.await?;
if legacy_path != scoped_path {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"active Git common config changed during format fallback",
));
}
if !legacy
.status
.code()
.is_some_and(|code| code == 0 || code == 1)
{
return Err(io::Error::other(format!(
"git {probe} direct common config probe failed with status {}: {}",
legacy.status,
String::from_utf8_lossy(&legacy.stderr).trim()
)));
}
parse_config_entries_with_origins(&legacy.stdout)?
};
for entry in &entries {
let expected_origin = match &entry.origin {
GitConfigOrigin::File(origin) => {
same_file::is_same_file(origin, &scoped_path).unwrap_or(false)
}
GitConfigOrigin::CommandLine => false,
};
if !expected_origin {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
format!("git {probe} direct common config probe returned an unexpected origin"),
));
}
}
Ok(entries
.into_iter()
.map(|entry| (entry.key.clone(), entry))
.collect())
}
fn read_bool(&self, key: &str) -> io::Result<Option<bool>> {
let mut command = self.git.command_for_cwd(&self.canonical_root)?;
command
.env("GIT_OPTIONAL_LOCKS", "0")
.args(&self.base_config_args)
.args(["config", "--type=bool", "--get", key]);
let output = self.git.output(command)?;
parse_bool_output(&output, key)
}
async fn read_effective_async(
&self,
pattern: &str,
probe: &str,
) -> io::Result<BTreeMap<String, GitConfigEntry>> {
read_effective_config_with_fallback_async(
self.git,
&self.canonical_root,
&self.base_config_args,
pattern,
probe,
)
.await
}
async fn read_bool_async(&self, key: &str) -> io::Result<Option<bool>> {
let mut command = self.git.async_command_for_cwd(&self.canonical_root)?;
command
.env("GIT_OPTIONAL_LOCKS", "0")
.args(&self.base_config_args)
.args(["config", "--type=bool", "--get", key]);
let output = self
.git
.output_async_bounded(command, MAX_INTERNAL_GIT_OUTPUT_BYTES)
.await?;
parse_bool_output(&output, key)
}
}
fn parse_bool_output(output: &std::process::Output, key: &str) -> io::Result<Option<bool>> {
if output.status.code() == Some(1) && output.stdout.is_empty() && output.stderr.is_empty() {
return Ok(None);
}
if !output.status.success() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!(
"Git boolean config probe for {key:?} failed with status {}: {}",
output.status,
String::from_utf8_lossy(&output.stderr).trim()
),
));
}
match String::from_utf8_lossy(&output.stdout).trim() {
"true" => Ok(Some(true)),
"false" => Ok(Some(false)),
value => Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("unexpected normalized Git boolean value {value:?} for {key:?}"),
)),
}
}
fn validate_base_config_args(args: &[String]) -> io::Result<()> {
let mut pairs = args.chunks_exact(2);
for pair in &mut pairs {
let Some((key, _value)) = pair[1].split_once('=') else {
return Err(invalid_base_config_args());
};
if pair[0] != "-c" || key.is_empty() {
return Err(invalid_base_config_args());
}
}
if !pairs.remainder().is_empty() {
return Err(invalid_base_config_args());
}
Ok(())
}
fn invalid_base_config_args() -> io::Error {
io::Error::new(
io::ErrorKind::InvalidInput,
"guarded Git base config must contain only ordered -c key=value pairs",
)
}
/// Operation-owned Git configuration capability.
///
/// All operation children are rooted at the authorized repository, inherit
/// the exact frozen base invocation, receive fixed library safety scalars, and
/// retain any sealed filter override for the capability lifetime.
pub(crate) struct GuardedGitConfig<'git> {
sources: ValidatedConfigSources<'git>,
identity: Arc<CapabilityIdentity>,
// Captured once for an apply operation and appended after every mutable
// config source/overlay so these scalar inputs cannot change between a
// nonmutating gate and a later index/worktree mutation.
apply_policy: Option<ApplyPolicySnapshot>,
// Set only by the fixed real-policy numstat gate. Fatal whitespace modes
// may be neutralized for a later mutating child only after this proof is
// recorded on the same operation capability.
apply_policy_gate: ApplyPolicyGateState,
// Ordered, typed snapshots keep each sealed filter overlay alive through
// every later child. Downstream staging may attach a fresh Git-add policy
// without rebuilding or weakening the source authorization.
filters: Vec<FilterPolicySnapshot>,
// At most one merge-driver neutralizer may be attached. Command assembly
// places it between the apply and Git-add filter slots regardless of
// attachment timing.
merge: Option<SealedMergeConfigOverride>,
merge_policy_installed: bool,
// Status is a mutually exclusive operation state rather than another
// mutation overlay. The retained context freezes helper selection, HEAD,
// and untracked presence for the final tracked-only Status sink.
status: Option<StatusPolicySnapshot>,
// Set only after proving the effective replacement-ref namespace empty
// (or already disabled). Every later snapshot command then forces
// replacements off so a late ref cannot affect the frozen context.
status_replacements_disabled: bool,
}
struct StatusPolicySnapshot {
context: SealedStatusReadContext,
fsmonitor: Option<FsmonitorOverride>,
}
#[derive(Debug, thiserror::Error)]
#[error("executable filter {driver:?} is selected for {path:?}")]
pub(crate) struct SelectedStatusFilterRefusal {
driver: String,
path: Vec<u8>,
}
impl SelectedStatusFilterRefusal {
pub(crate) fn driver(&self) -> &str {
&self.driver
}
pub(crate) fn path(&self) -> &[u8] {
&self.path
}
}
#[derive(Debug, thiserror::Error)]
#[error("Git resolved {reported:?} instead of expected root {expected:?}")]
pub(crate) struct StatusRootMismatch {
expected: PathBuf,
reported: PathBuf,
}
#[derive(Debug, thiserror::Error)]
#[error("selected Git authority has no active worktree root")]
pub(crate) struct NoActiveStatusWorktree;
#[derive(Debug, thiserror::Error)]
#[error("Git filter attribute selection exceeded its {max_probes}-probe limit")]
pub(crate) struct StatusFilterProbeLimitExceeded {
max_probes: usize,
}
#[derive(Debug, thiserror::Error)]
#[error("{description} failed with exit code {exit_code:?}")]
pub(crate) struct StatusPolicyCommandFailure {
description: String,
exit_code: Option<i32>,
}
impl StatusPolicyCommandFailure {
pub(crate) fn exit_code(&self) -> Option<i32> {
self.exit_code
}
}
impl StatusFilterProbeLimitExceeded {
pub(crate) fn max_probes(&self) -> usize {
self.max_probes
}
}
impl StatusRootMismatch {
pub(crate) fn expected(&self) -> &Path {
&self.expected
}
pub(crate) fn reported(&self) -> &Path {
&self.reported
}
}
struct CapabilityIdentity;
/// Opaque operation identity for sealed plans implemented in sibling modules.
/// Its inner capability cannot be forged or rebound outside this module.
#[derive(Clone)]
pub(crate) struct GuardedOperationIdentity(Arc<CapabilityIdentity>);
impl GuardedOperationIdentity {
pub(crate) fn same_operation(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.0, &other.0)
}
}
enum ApplyPolicyGateState {
NotRun,
Failed,
Succeeded { revert: bool, patch_path: String },
}
const APPLY_POLICY_CONFIG_PATTERN: &str =
r"^(apply\.(whitespace|ignorewhitespace)|core\.whitespace)$";
const DEFAULT_APPLY_WHITESPACE: &str = "warn";
const DEFAULT_APPLY_IGNORE_WHITESPACE: &str = "false";
const DEFAULT_CORE_WHITESPACE: &str = "blank-at-eol,blank-at-eof,space-before-tab";
struct ApplyPolicySnapshot {
config_args: Box<[String]>,
whitespace_mode: ApplyWhitespaceMode,
}
/// Normalized `apply.whitespace` behavior frozen for one apply operation.
///
/// Unknown or case-mismatched values stay invalid here and are left for Git's
/// authoritative policy gate to reject. The `strip` alias has the same byte-
/// correcting behavior as `fix`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ApplyWhitespaceMode {
Warn,
Nowarn,
Error,
ErrorAll,
Fix,
Invalid,
}
impl ApplyWhitespaceMode {
fn normalize(value: &str) -> Self {
match value {
"warn" => Self::Warn,
"nowarn" => Self::Nowarn,
"error" => Self::Error,
"error-all" => Self::ErrorAll,
"fix" | "strip" => Self::Fix,
_ => Self::Invalid,
}
}
pub(crate) fn is_fatal(self) -> bool {
matches!(self, Self::Error | Self::ErrorAll)
}
}
impl ApplyPolicySnapshot {
fn capture(sources: &ValidatedConfigSources<'_>) -> io::Result<Self> {
let entries = sources.read_effective(APPLY_POLICY_CONFIG_PATTERN, "apply policy")?;
let value = |key: &str, default: &str| {
entries
.get(key)
.map(|entry| entry.value.clone())
.unwrap_or_else(|| default.to_string())
};
let apply_whitespace = value("apply.whitespace", DEFAULT_APPLY_WHITESPACE);
Ok(Self {
config_args: vec![
"-c".to_string(),
format!("apply.whitespace={apply_whitespace}"),
"-c".to_string(),
format!(
"apply.ignoreWhitespace={}",
value("apply.ignorewhitespace", DEFAULT_APPLY_IGNORE_WHITESPACE)
),
"-c".to_string(),
format!(
"core.whitespace={}",
value("core.whitespace", DEFAULT_CORE_WHITESPACE)
),
]
.into_boxed_slice(),
whitespace_mode: ApplyWhitespaceMode::normalize(&apply_whitespace),
})
}
fn append_to(&self, command: &mut GitCommand) {
command.args(&self.config_args);
}
fn append_rendered(&self, parts: &mut Vec<String>) {
parts.extend(self.config_args.iter().cloned());
}
}
#[derive(Clone, Copy)]
enum BoundSubcommand {
Apply,
CheckAttr,
CheckIgnore,
HashObject,
ListBuiltinCommands,
LsFiles,
RevParse,
SparseCheckout,
UpdateIndexLiteralPathspecs,
}
impl BoundSubcommand {
fn append_to(self, command: &mut GitCommand) {
match self {
Self::Apply => {
command.arg("apply");
}
Self::CheckAttr => {
command.arg("check-attr");
}
Self::CheckIgnore => {
command.arg("check-ignore");
}
Self::HashObject => {
command.arg("hash-object");
}
Self::ListBuiltinCommands => {
command.arg("--list-cmds=builtins");
}
Self::LsFiles => {
command.arg("ls-files");
}
Self::RevParse => {
command.arg("rev-parse");
}
Self::SparseCheckout => {
command.arg("sparse-checkout");
}
Self::UpdateIndexLiteralPathspecs => {
command.args(["--literal-pathspecs", "update-index"]);
}
}
}
}
/// Async counterpart to [`GuardedGitCommand`]. The raw Tokio command never
/// leaves this module, so status callers cannot change its cwd, config
/// invocation, overlay order, or final metadata revalidation.
struct GuardedAsyncGitCommand<'operation, 'git> {
operation: &'operation GuardedGitConfig<'git>,
inner: GitAsyncCommand,
}
impl GuardedAsyncGitCommand<'_, '_> {
fn arg(&mut self, arg: impl AsRef<OsStr>) -> &mut Self {
self.inner.arg(arg);
self
}
fn args<I, S>(&mut self, args: I) -> &mut Self
where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
{
self.inner.args(args);
self
}
fn disable_optional_locks(&mut self) -> &mut Self {
self.inner.env("GIT_OPTIONAL_LOCKS", "0");
self
}
fn stdin(&mut self, config: impl Into<Stdio>) -> &mut Self {
self.inner.stdin(config);
self
}
async fn output(self) -> io::Result<std::process::Output> {
self.operation
.sources
.git
.output_async_bounded(self.inner, MAX_INTERNAL_GIT_OUTPUT_BYTES)
.await
}
async fn output_in_status_context(
self,
context: &SealedStatusReadContext,
) -> io::Result<std::process::Output> {
let isolated = context.context(&self.operation.identity)?;
let operation_identity = self.operation.operation_identity();
self.operation
.sources
.git
.output_async_in_isolated_read_context(
self.inner,
isolated,
&operation_identity,
MAX_INTERNAL_GIT_OUTPUT_BYTES,
)
.await
}
}
/// A sealed filter-only include owned for the complete capability lifetime.
/// Its fields and include argument are intentionally inaccessible outside this
/// module; callers can neither forge one nor append it to another command.
pub(crate) struct SealedFilterConfigOverride {
owner: Arc<CapabilityIdentity>,
include_arg: String,
_config_dir: tempfile::TempDir,
}
impl SealedFilterConfigOverride {
fn append_to(
&self,
owner: &Arc<CapabilityIdentity>,
command: &mut GitCommand,
) -> io::Result<()> {
self.ensure_owner(owner)?;
command.args(["-c", &self.include_arg]);
Ok(())
}
fn append_rendered_args(
&self,
owner: &Arc<CapabilityIdentity>,
args: &mut Vec<String>,
) -> io::Result<()> {
self.ensure_owner(owner)?;
args.push("-c".to_string());
args.push(self.include_arg.clone());
Ok(())
}
fn ensure_owner(&self, owner: &Arc<CapabilityIdentity>) -> io::Result<()> {
if !Arc::ptr_eq(&self.owner, owner) {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"sealed Git filter override belongs to another operation",
));
}
Ok(())
}
}
/// A command whose runner, root, config invocation, overlay lifetime, and
/// fixed subcommand are inseparably bound to one operation capability.
pub(crate) struct GuardedGitCommand<'operation, 'git> {
operation: &'operation GuardedGitConfig<'git>,
inner: GitCommand,
}
impl GuardedGitCommand<'_, '_> {
pub(crate) fn arg(&mut self, arg: impl AsRef<OsStr>) -> &mut Self {
self.inner.arg(arg);
self
}
pub(crate) fn args<I, S>(&mut self, args: I) -> &mut Self
where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
{
self.inner.args(args);
self
}
pub(crate) fn disable_optional_locks(&mut self) -> &mut Self {
self.inner.env("GIT_OPTIONAL_LOCKS", "0");
self
}
pub(crate) fn stdin(&mut self, config: impl Into<Stdio>) -> &mut Self {
self.inner.stdin(config);
self
}
pub(crate) fn output(self) -> io::Result<std::process::Output> {
self.operation.sources.git.output(self.inner)
}
pub(crate) fn output_in_merge_scratch(
self,
storage: &IsolatedGitStorage,
) -> io::Result<std::process::Output> {
let merge = self.operation.merge.as_ref().ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"scratch index command requires an installed merge policy",
)
})?;
let isolated = merge.common_dir(&self.operation.identity)?;
self.operation
.sources
.git
.output_in_isolated_scratch(self.inner, isolated, storage)
}
}
impl<'git> GuardedGitConfig<'git> {
pub(crate) fn authorize(
git: &'git GitRunner,
canonical_root: &Path,
base_config_args: Vec<String>,
) -> io::Result<Self> {
Ok(Self {
sources: ValidatedConfigSources::authorize(git, canonical_root, base_config_args)?,
identity: Arc::new(CapabilityIdentity),
apply_policy: None,
apply_policy_gate: ApplyPolicyGateState::NotRun,
filters: Vec::new(),
merge: None,
merge_policy_installed: false,
status: None,
status_replacements_disabled: false,
})
}
pub(crate) async fn authorize_status_async(git: &'git GitRunner) -> io::Result<Self> {
let root = git
.active_worktree_root()
.ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, NoActiveStatusWorktree))?;
git.ensure_repository_root_route(root)?;
Ok(Self {
sources: ValidatedConfigSources::authorize_async(git, root, Vec::new()).await?,
identity: Arc::new(CapabilityIdentity),
apply_policy: None,
apply_policy_gate: ApplyPolicyGateState::NotRun,
filters: Vec::new(),
merge: None,
merge_policy_installed: false,
status: None,
status_replacements_disabled: false,
})
}
pub(crate) fn canonical_root(&self) -> &Path {
&self.sources.canonical_root
}
pub(crate) fn operation_identity(&self) -> GuardedOperationIdentity {
GuardedOperationIdentity(Arc::clone(&self.identity))
}
pub(crate) fn ensure_operation_identity(
&self,
identity: &GuardedOperationIdentity,
) -> io::Result<()> {
if Arc::ptr_eq(&self.identity, &identity.0) {
Ok(())
} else {
Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"sealed Git plan belongs to another operation",
))
}
}
pub(crate) fn freeze_apply_policy(&mut self) -> io::Result<()> {
if self.status.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"apply policy cannot coexist with status policy",
));
}
if self.apply_policy.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"apply policy is already frozen for this operation",
));
}
self.apply_policy = Some(ApplyPolicySnapshot::capture(&self.sources)?);
Ok(())
}
/// Parse the patch's path inventory without consulting or mutating the
/// index/worktree. The fixed whitespace override keeps path discovery from
/// preempting the later authoritative apply-policy result.
pub(crate) fn run_apply_numstat_path_inventory(
&self,
revert: bool,
patch_path: &Path,
) -> io::Result<std::process::Output> {
let mut command = self.apply_command()?;
command.args(["--numstat", "--whitespace=nowarn", "-z"]);
if revert {
command.arg("-R");
}
command.arg("--").arg(patch_path);
command.output()
}
/// Run the one fixed, nonmutating policy gate and bind a successful result
/// to this operation. Keeping the proof here prevents a future caller from
/// suppressing a fatal final whitespace check without first executing the
/// authoritative frozen-policy gate.
pub(crate) fn run_apply_policy_gate(
&mut self,
revert: bool,
patch_path: &str,
) -> io::Result<(String, std::process::Output)> {
if !matches!(self.apply_policy_gate, ApplyPolicyGateState::NotRun) {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"apply policy gate may run only once per operation",
));
}
if self.apply_policy.is_none() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"apply policy must be frozen before its gate runs",
));
}
// Mark the one-shot gate consumed before any fallible launch step.
self.apply_policy_gate = ApplyPolicyGateState::Failed;
let mut args = vec![
"apply".to_string(),
"--numstat".to_string(),
"-z".to_string(),
];
if revert {
args.push("-R".to_string());
}
args.push(patch_path.to_string());
let rendered = self.render_apply_command_for_log(&args)?;
let mut command = self.apply_command()?;
command.args(&args[1..]);
let output = command.output()?;
if output.status.success() {
self.apply_policy_gate = ApplyPolicyGateState::Succeeded {
revert,
patch_path: patch_path.to_string(),
};
}
Ok((rendered, output))
}
/// Run the public preflight shape without exposing a generic `git apply`
/// command on which a caller could append mutating options.
pub(crate) fn run_apply_preflight_check(
&self,
revert: bool,
patch_path: &str,
) -> io::Result<(String, std::process::Output)> {
let mut args = vec!["apply".to_string(), "--check".to_string()];
if revert {
args.push("-R".to_string());
}
args.push(patch_path.to_string());
let rendered = self.render_apply_command_for_log(&args)?;
let mut command = self.apply_command()?;
command.args(&args[1..]);
Ok((rendered, command.output()?))
}
/// Check whether the final operation can use the direct strategy. This is
/// deliberately fixed to `--check`; callers receive only the output, never
/// the underlying apply command.
pub(crate) fn run_apply_strategy_check(
&self,
revert: bool,
patch_path: &str,
) -> io::Result<std::process::Output> {
let mut command = self.apply_command()?;
command.args(["--check", "--whitespace=nowarn"]);
if !revert {
command.arg("--index");
}
if revert {
command.arg("-R");
}
command.arg(patch_path);
command.output()
}
/// Return the typed frozen mode only after the authoritative gate has
/// succeeded for this operation.
pub(crate) fn final_apply_whitespace_mode(
&self,
revert: bool,
patch_path: &str,
) -> io::Result<ApplyWhitespaceMode> {
match &self.apply_policy_gate {
ApplyPolicyGateState::Succeeded {
revert: gated_revert,
patch_path: gated_patch,
} if *gated_revert == revert && gated_patch == patch_path => {}
ApplyPolicyGateState::Succeeded { .. } => {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"final apply does not match its successful policy gate",
));
}
ApplyPolicyGateState::NotRun | ApplyPolicyGateState::Failed => {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"final apply whitespace policy requires a successful policy gate",
));
}
}
self.apply_policy
.as_ref()
.map(|policy| policy.whitespace_mode)
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"final apply whitespace policy is not frozen",
)
})
}
fn apply_command(&self) -> io::Result<GuardedGitCommand<'_, 'git>> {
let mut command = self.command_with_attached_overlays()?;
if let Some(policy) = &self.apply_policy {
policy.append_to(&mut command);
}
BoundSubcommand::Apply.append_to(&mut command);
Ok(GuardedGitCommand {
operation: self,
inner: command,
})
}
pub(crate) fn rev_parse_command(&self) -> io::Result<GuardedGitCommand<'_, 'git>> {
self.guarded_command(BoundSubcommand::RevParse)
}
pub(crate) fn check_ignore_command(&self) -> io::Result<GuardedGitCommand<'_, 'git>> {
self.guarded_command(BoundSubcommand::CheckIgnore)
}
pub(crate) fn list_builtin_commands(&self) -> io::Result<std::process::Output> {
let mut command = self.guarded_command(BoundSubcommand::ListBuiltinCommands)?;
command.disable_optional_locks();
command.output()
}
pub(crate) fn ls_files_command(&self) -> io::Result<GuardedGitCommand<'_, 'git>> {
self.guarded_command(BoundSubcommand::LsFiles)
}
pub(crate) fn sparse_checkout_command(&self) -> io::Result<GuardedGitCommand<'_, 'git>> {
self.guarded_command(BoundSubcommand::SparseCheckout)
}
pub(crate) fn update_index_literal_pathspecs_command(
&self,
) -> io::Result<GuardedGitCommand<'_, 'git>> {
self.guarded_command(BoundSubcommand::UpdateIndexLiteralPathspecs)
}
pub(crate) fn pending_filter_attribute_command<'operation>(
&'operation self,
neutralizer: &'operation SealedFilterConfigOverride,
) -> io::Result<GuardedGitCommand<'operation, 'git>> {
let mut command = self.command_with_attached_overlays()?;
neutralizer.append_to(&self.identity, &mut command)?;
BoundSubcommand::CheckAttr.append_to(&mut command);
Ok(GuardedGitCommand {
operation: self,
inner: command,
})
}
fn guarded_command(
&self,
subcommand: BoundSubcommand,
) -> io::Result<GuardedGitCommand<'_, 'git>> {
let mut command = self.command_with_attached_overlays()?;
subcommand.append_to(&mut command);
Ok(GuardedGitCommand {
operation: self,
inner: command,
})
}
fn command_with_attached_overlays(&self) -> io::Result<GitCommand> {
let mut command = self
.sources
.git
.command_for_cwd(&self.sources.canonical_root)?;
command.args(self.mutation_config_args()?);
Ok(command)
}
fn mutation_config_args(&self) -> io::Result<Vec<String>> {
if self.status.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"status policy cannot be used by a mutation command",
));
}
let mut args = self.sources.base_config_args.to_vec();
args.extend(safe_scalar_override_args());
let (apply, git_add) = self.ordered_filter_snapshots()?;
if let Some(neutralizer) = apply.and_then(FilterPolicySnapshot::neutralizer) {
neutralizer.append_rendered_args(&self.identity, &mut args)?;
}
if let Some(neutralizer) = git_add.and_then(FilterPolicySnapshot::neutralizer) {
neutralizer.append_rendered_args(&self.identity, &mut args)?;
}
Ok(args)
}
fn status_config_args(
&self,
fsmonitor: FsmonitorOverride,
neutralizer: Option<&SealedFilterConfigOverride>,
) -> io::Result<Vec<String>> {
self.ensure_status_exclusive_state()?;
let mut args = self.sources.base_config_args.to_vec();
args.extend([
"-c".to_string(),
format!("core.hooksPath={DISABLED_HOOKS_PATH}"),
"-c".to_string(),
fsmonitor.git_config_arg().to_string(),
]);
if let Some(neutralizer) = neutralizer {
neutralizer.append_rendered_args(&self.identity, &mut args)?;
}
Ok(args)
}
fn ensure_status_exclusive_state(&self) -> io::Result<()> {
if self.apply_policy.is_some()
|| !matches!(self.apply_policy_gate, ApplyPolicyGateState::NotRun)
|| !self.filters.is_empty()
|| self.merge.is_some()
|| self.merge_policy_installed
{
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"status policy cannot coexist with apply, mutation filter, or merge policy",
));
}
Ok(())
}
fn ordered_filter_snapshots(
&self,
) -> io::Result<(Option<&FilterPolicySnapshot>, Option<&FilterPolicySnapshot>)> {
let ordered = match self.filters.as_slice() {
[] => (None, None),
[apply] if apply.role() == FilterPolicyRole::Apply => (Some(apply), None),
[git_add] if git_add.role() == FilterPolicyRole::GitAdd => (None, Some(git_add)),
[apply, git_add]
if apply.role() == FilterPolicyRole::Apply
&& git_add.role() == FilterPolicyRole::GitAdd =>
{
(Some(apply), Some(git_add))
}
_ => {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"invalid ordered Git filter policy state",
));
}
};
if self.merge_policy_installed && ordered.0.is_none() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"merge policy requires an apply filter snapshot",
));
}
Ok(ordered)
}
pub(crate) fn command_for_sentinel_filter_probe<'operation>(
&'operation self,
neutralizer: &'operation SealedFilterConfigOverride,
driver: &str,
required: bool,
) -> io::Result<GuardedGitCommand<'operation, 'git>> {
if !matches!(driver, "set" | "unset" | "unspecified") {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"Git filter sentinel probe requested for a non-sentinel driver",
));
}
let mut command = self.command_with_attached_overlays()?;
neutralizer.append_to(&self.identity, &mut command)?;
command.args(["-c", &format!("filter.{driver}.required={required}")]);
BoundSubcommand::HashObject.append_to(&mut command);
Ok(GuardedGitCommand {
operation: self,
inner: command,
})
}
pub(crate) fn read_effective(
&self,
pattern: &str,
probe: &str,
) -> io::Result<BTreeMap<String, GitConfigEntry>> {
self.sources.read_effective(pattern, probe)
}
pub(crate) fn read_bool(&self, key: &str) -> io::Result<Option<bool>> {
self.sources.read_bool(key)
}
/// Confirm selected Git agrees with the retained authority about the
/// repository root before any status worktree read.
pub(crate) async fn verify_status_root_async(&self, requested_cwd: &Path) -> io::Result<()> {
let requested_cwd = std::fs::canonicalize(requested_cwd)?;
let mut command = self.sources.git.async_command_for_cwd(&requested_cwd)?;
command
.env("GIT_OPTIONAL_LOCKS", "0")
.args(self.status_config_args(FsmonitorOverride::Disabled, /*neutralizer*/ None)?)
.args(["rev-parse", "--show-toplevel"]);
let output = self
.sources
.git
.output_async_bounded(command, MAX_INTERNAL_GIT_OUTPUT_BYTES)
.await?;
if !output.status.success() {
return Err(command_failure("status repository-root probe", &output));
}
let reported = git_path_from_line_output(&output.stdout)?;
let reported = std::fs::canonicalize(reported).map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
"Git repository-root output did not resolve to an existing path",
)
})?;
if reported != self.sources.canonical_root {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
StatusRootMismatch {
expected: self.sources.canonical_root.clone(),
reported,
},
));
}
Ok(())
}
/// Return the exact tracked-path byte strings for the Status policy.
async fn read_status_tracked_paths_async(&self) -> io::Result<Vec<Vec<u8>>> {
if self.status.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"tracked paths must be read before status policy installation",
));
}
let mut command =
self.pending_status_command(FsmonitorOverride::Disabled, /*neutralizer*/ None)?;
command
.disable_optional_locks()
.args(["ls-files", "-z", "--cached"]);
let output = command.output().await?;
if !output.status.success() {
return Err(command_failure("tracked-path probe", &output));
}
let mut paths = parse_nul_paths(&output.stdout)?;
if paths.len() > MAX_STATUS_TRACKED_PATHS {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!(
"tracked path record count {} exceeds the status limit {MAX_STATUS_TRACKED_PATHS}",
paths.len()
),
));
}
paths.sort();
paths.dedup();
Ok(paths)
}
/// Install the mutually exclusive Status filter policy and publish one
/// operation-owned config, attribute, HEAD, and untracked-presence view.
pub(crate) async fn install_status_policy_async(&mut self) -> io::Result<()> {
self.ensure_status_exclusive_state()?;
if self.status.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"status filter policy is already installed",
));
}
#[cfg(test)]
FILTER_POLICY_READ_COUNT_FOR_STATUS.with(|count| count.set(count.get() + 1));
let entries = self
.sources
.read_effective_async(crate::safe_git::EXECUTABLE_FILTER_CONFIG_PATTERN, "filter")
.await?;
let executable_drivers = status_policy_filter_drivers(&entries)?;
validate_executable_driver_count(&executable_drivers)?;
let paths = self.read_status_tracked_paths_async().await?;
let neutralizer = if executable_drivers.is_empty() {
None
} else {
Some(
self.build_filter_override_async(&executable_drivers)
.await?,
)
};
self.ensure_no_effective_replacement_refs_async(neutralizer.as_ref())
.await?;
if let Some(neutralizer) = &neutralizer {
let attributes = self
.read_status_filter_attributes_async(&paths, &executable_drivers, neutralizer)
.await?;
let mut required_cache = BTreeMap::new();
for (path, driver) in attributes {
if !executable_drivers.contains(&driver) {
continue;
}
let required = required_cache.get(&driver).copied();
let mut policy = classify_selected_filter(&entries, &driver, required);
if policy == SelectedFilterPolicy::NeedsRequiredValue {
let required = self
.sources
.read_bool_async(&format!("filter.{driver}.required"))
.await
.map_err(|error| {
io::Error::new(
io::ErrorKind::Unsupported,
format!(
"refusing selected Git filter {driver:?} with malformed required value: {error}"
),
)
})?
.unwrap_or(false);
required_cache.insert(driver.clone(), required);
policy = classify_selected_filter(&entries, &driver, Some(required));
}
if policy == SelectedFilterPolicy::Refused {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
SelectedStatusFilterRefusal { driver, path },
));
}
}
}
let has_untracked = self
.read_status_untracked_presence_async(neutralizer.as_ref())
.await?;
let head_oid = self
.read_status_head_oid_async(neutralizer.as_ref())
.await?;
let context = self
.build_status_read_context_async(
head_oid.as_deref(),
has_untracked,
)
.await?;
self.status = Some(StatusPolicySnapshot {
context,
fsmonitor: None,
});
Ok(())
}
async fn read_status_untracked_presence_async(
&self,
neutralizer: Option<&SealedFilterConfigOverride>,
) -> io::Result<bool> {
let mut command =
self.pending_status_command(FsmonitorOverride::Disabled, neutralizer)?;
command.disable_optional_locks().args([
"ls-files",
"-z",
"--others",
"--exclude-standard",
"--directory",
"--no-empty-directory",
"--",
]);
let output = command.output().await?;
if !output.status.success() {
return Err(command_failure("status untracked-presence inventory", &output));
}
let paths = parse_nul_paths(&output.stdout)?;
if paths.len() > MAX_STATUS_TRACKED_PATHS {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"status untracked-presence inventory exceeds its path limit",
));
}
Ok(!paths.is_empty())
}
async fn read_status_head_oid_async(
&self,
neutralizer: Option<&SealedFilterConfigOverride>,
) -> io::Result<Option<String>> {
let mut command =
self.pending_status_command(FsmonitorOverride::Disabled, neutralizer)?;
command
.disable_optional_locks()
.args(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
let output = command.output().await?;
if output.status.success() {
return parse_status_head_oid(&output.stdout).map(Some);
}
if output.status.code() != Some(1)
|| !output.stdout.is_empty()
|| !output.stderr.is_empty()
{
return Err(command_failure("status HEAD snapshot", &output));
}
let mut symbolic =
self.pending_status_command(FsmonitorOverride::Disabled, neutralizer)?;
symbolic
.disable_optional_locks()
.args(["symbolic-ref", "--quiet", "HEAD"]);
let symbolic = symbolic.output().await?;
if !symbolic.status.success() {
return Err(command_failure("status symbolic HEAD snapshot", &symbolic));
}
let target = parse_status_symbolic_ref(&symbolic.stdout)?;
let mut verify = self.pending_status_command(FsmonitorOverride::Disabled, neutralizer)?;
verify
.disable_optional_locks()
.args(["show-ref", "--verify", "--quiet", "--"])
.arg(&target);
let verify = verify.output().await?;
if verify.status.code() == Some(1)
&& verify.stdout.is_empty()
&& verify.stderr.is_empty()
{
return Ok(None);
}
if verify.status.success() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Status HEAD target exists but does not resolve to a commit",
));
}
Err(command_failure("status unborn HEAD verification", &verify))
}
async fn ensure_no_effective_replacement_refs_async(
&mut self,
neutralizer: Option<&SealedFilterConfigOverride>,
) -> io::Result<()> {
if self.sources.git.replacement_refs_are_disabled() {
self.status_replacements_disabled = true;
return Ok(());
}
if self.sources.git.replacement_ref_base_is_custom() {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"frozen Status is unavailable with a custom Git replacement-ref namespace",
));
}
let mut command =
self.pending_status_command(FsmonitorOverride::Disabled, neutralizer)?;
command.disable_optional_locks().args([
"for-each-ref",
"--format=%(refname)",
"refs/replace/",
]);
let output = command.output().await?;
if !output.status.success() {
return Err(command_failure("status replacement-ref inventory", &output));
}
if output.stdout.is_empty() {
self.status_replacements_disabled = true;
Ok(())
} else {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"frozen Status is unavailable with active Git replacement refs",
))
}
}
pub(crate) async fn detect_status_fsmonitor_async(&mut self) -> FsmonitorOverride {
if self.status.is_none() || self.ensure_status_exclusive_state().is_err() {
return FsmonitorOverride::Disabled;
}
if let Some(fsmonitor) = self.status.as_ref().and_then(|status| status.fsmonitor) {
return fsmonitor;
}
if let Some(status) = &mut self.status {
// The synthetic owned Git directory has no stable fsmonitor daemon
// identity or socket lifecycle. Disabling it is a performance-only
// downgrade and avoids launching a daemon tied to temporary state.
status.fsmonitor = Some(FsmonitorOverride::Disabled);
}
FsmonitorOverride::Disabled
}
pub(crate) async fn status_output_async(&self) -> io::Result<std::process::Output> {
let status = self.status.as_ref().ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"status output requires an installed status filter policy",
)
})?;
let fsmonitor = status.fsmonitor.ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"status output requires a retained fsmonitor decision",
)
})?;
let mut command = self.pending_frozen_status_command(fsmonitor)?;
command.disable_optional_locks().args([
"status",
"--porcelain",
"--ignore-submodules=dirty",
"--untracked-files=no",
]);
command.output_in_status_context(&status.context).await
}
pub(crate) fn status_has_untracked_snapshot(&self) -> io::Result<bool> {
let status = self.status.as_ref().ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"untracked status requires an installed status filter policy",
)
})?;
status.context.has_untracked(&self.identity)
}
fn pending_frozen_status_command<'operation>(
&'operation self,
fsmonitor: FsmonitorOverride,
) -> io::Result<GuardedAsyncGitCommand<'operation, 'git>> {
self.ensure_status_exclusive_state()?;
if self.status.is_none() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"frozen Status command requires an installed context",
));
}
let mut command = self
.sources
.git
.async_command_for_cwd(&self.sources.canonical_root)?;
command.args([
"-c",
&format!("core.hooksPath={DISABLED_HOOKS_PATH}"),
"-c",
fsmonitor.git_config_arg(),
]);
Ok(GuardedAsyncGitCommand {
operation: self,
inner: command,
})
}
fn pending_status_command<'operation>(
&'operation self,
fsmonitor: FsmonitorOverride,
neutralizer: Option<&'operation SealedFilterConfigOverride>,
) -> io::Result<GuardedAsyncGitCommand<'operation, 'git>> {
let mut command = self
.sources
.git
.async_command_for_cwd(&self.sources.canonical_root)?;
command.args(self.status_config_args(fsmonitor, neutralizer)?);
if self.status_replacements_disabled {
command.env("GIT_NO_REPLACE_OBJECTS", "1");
}
Ok(GuardedAsyncGitCommand {
operation: self,
inner: command,
})
}
async fn read_status_filter_attributes_async(
&self,
paths: &[Vec<u8>],
executable_drivers: &ExecutableFilterDrivers,
neutralizer: &SealedFilterConfigOverride,
) -> io::Result<BTreeMap<Vec<u8>, String>> {
if paths.is_empty() {
return Ok(BTreeMap::new());
}
let mut input = tempfile::tempfile()?;
write_nul_paths(&mut input, paths)?;
input.rewind()?;
let mut command =
self.pending_status_command(FsmonitorOverride::Disabled, Some(neutralizer))?;
command
.disable_optional_locks()
.args(["check-attr", "--stdin", "-z", "filter"])
.stdin(Stdio::from(input));
let output = command.output().await?;
if !output.status.success() {
return Err(command_failure("status filter attribute probe", &output));
}
let attributes = parse_filter_attributes(&output.stdout, paths)?;
self.resolve_status_filter_sentinels_async(attributes, executable_drivers, neutralizer)
.await
}
async fn resolve_status_filter_sentinels_async(
&self,
attributes: BTreeMap<Vec<u8>, FilterAttributeValue>,
executable_drivers: &ExecutableFilterDrivers,
neutralizer: &SealedFilterConfigOverride,
) -> io::Result<BTreeMap<Vec<u8>, String>> {
let mut resolved = BTreeMap::new();
let mut probe_budget = SentinelFilterProbeBudget::default();
for (path, attribute) in attributes {
match attribute {
FilterAttributeValue::Driver(driver) => {
resolved.insert(path, driver);
}
FilterAttributeValue::AmbiguousSentinel(driver) => {
if executable_drivers.contains(&driver)
&& self
.status_sentinel_selects_driver_async(
&path,
&driver,
neutralizer,
&mut probe_budget,
)
.await?
{
resolved.insert(path, driver);
}
}
}
}
Ok(resolved)
}
async fn status_sentinel_selects_driver_async(
&self,
path: &[u8],
driver: &str,
neutralizer: &SealedFilterConfigOverride,
probe_budget: &mut SentinelFilterProbeBudget,
) -> io::Result<bool> {
let required = self
.run_status_sentinel_probe_async(
path,
driver,
/*required*/ true,
neutralizer,
probe_budget,
)
.await?;
if classify_sentinel_filter_probes(
required.status.success(),
/*optional_succeeded*/ None,
) == SentinelFilterProbeResolution::SpecialAttributeState
{
return Ok(false);
}
let optional = self
.run_status_sentinel_probe_async(
path,
driver,
/*required*/ false,
neutralizer,
probe_budget,
)
.await?;
if classify_sentinel_filter_probes(
required.status.success(),
Some(optional.status.success()),
) == SentinelFilterProbeResolution::LiteralDriver
{
return Ok(true);
}
Err(command_failure("status filter sentinel probe", &optional))
}
async fn run_status_sentinel_probe_async(
&self,
path: &[u8],
driver: &str,
required: bool,
neutralizer: &SealedFilterConfigOverride,
probe_budget: &mut SentinelFilterProbeBudget,
) -> io::Result<std::process::Output> {
if !matches!(driver, "set" | "unset" | "unspecified") {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"Git filter sentinel probe requested for a non-sentinel driver",
));
}
probe_budget.ensure_probe_available().map_err(|_| {
io::Error::new(
io::ErrorKind::PermissionDenied,
StatusFilterProbeLimitExceeded {
max_probes: SentinelFilterProbeBudget::max_probes(),
},
)
})?;
let mut command =
self.pending_status_command(FsmonitorOverride::Disabled, Some(neutralizer))?;
command
.disable_optional_locks()
.args(["-c", &format!("filter.{driver}.required={required}")])
.args(["hash-object", "--stdin"])
.arg("--path")
.arg(git_path_argument(path)?)
.stdin(Stdio::null());
let output = command.output().await?;
probe_budget.record_completed_probe();
Ok(output)
}
fn ensure_owned_config_path(&self, path: &Path, description: &str) -> io::Result<()> {
self.sources
.git
.ensure_config_source_is_not_worktree_controlled(path, description)
}
pub(crate) fn build_filter_override(
&self,
executable_drivers: &ExecutableFilterDrivers,
) -> io::Result<SealedFilterConfigOverride> {
let config_dir = tempfile::tempdir()?;
let config_path = config_dir.path().join("filter-neutralization.gitconfig");
self.ensure_owned_config_path(&config_path, "owned Git filter neutralization")?;
std::fs::write(&config_path, [])?;
for driver in executable_drivers.iter() {
for (name, value) in FILTER_NEUTRALIZATION_PLAN {
self.write_filter_override_value(&config_path, driver, name, value)?;
}
}
let config_path = config_path.to_str().ok_or_else(|| {
io::Error::new(io::ErrorKind::InvalidData, "non-UTF-8 filter guard path")
})?;
Ok(SealedFilterConfigOverride {
owner: Arc::clone(&self.identity),
include_arg: format!("include.path={config_path}"),
_config_dir: config_dir,
})
}
async fn build_filter_override_async(
&self,
executable_drivers: &ExecutableFilterDrivers,
) -> io::Result<SealedFilterConfigOverride> {
if executable_drivers.len() > MAX_EXECUTABLE_FILTER_DRIVERS {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"too many executable filter drivers for status neutralization",
));
}
let config_dir = tempfile::tempdir()?;
let config_path = config_dir.path().join("filter-neutralization.gitconfig");
self.ensure_owned_config_path(&config_path, "owned Git filter neutralization")?;
std::fs::write(&config_path, [])?;
for driver in executable_drivers.iter() {
for (name, value) in FILTER_NEUTRALIZATION_PLAN {
self.write_filter_override_value_async(&config_path, driver, name, value)
.await?;
}
}
let config_path = config_path.to_str().ok_or_else(|| {
io::Error::new(io::ErrorKind::InvalidData, "non-UTF-8 filter guard path")
})?;
Ok(SealedFilterConfigOverride {
owner: Arc::clone(&self.identity),
include_arg: format!("include.path={config_path}"),
_config_dir: config_dir,
})
}
fn write_filter_override_value(
&self,
config_path: &Path,
driver: &str,
name: &str,
value: &str,
) -> io::Result<()> {
debug_assert!(matches!(name, "clean" | "smudge" | "process" | "required"));
let mut command = self
.sources
.git
.command_for_cwd(&self.sources.canonical_root)?;
command
.args(&self.sources.base_config_args)
.args(["config", "--file"])
.arg(config_path)
.args(["--add", &format!("filter.{driver}.{name}"), value]);
let output = self.sources.git.output(command)?;
if !output.status.success() {
return Err(io::Error::other(format!(
"failed to write Git filter neutralization for {driver:?} (status {}): {}",
output.status,
String::from_utf8_lossy(&output.stderr).trim()
)));
}
Ok(())
}
async fn write_filter_override_value_async(
&self,
config_path: &Path,
driver: &str,
name: &str,
value: &str,
) -> io::Result<()> {
debug_assert!(matches!(name, "clean" | "smudge" | "process" | "required"));
let mut command = self
.sources
.git
.async_command_for_cwd(&self.sources.canonical_root)?;
command
.args(&self.sources.base_config_args)
.args(["config", "--file"])
.arg(config_path)
.args(["--add", &format!("filter.{driver}.{name}"), value]);
let output = self
.sources
.git
.output_async_bounded(command, MAX_INTERNAL_GIT_OUTPUT_BYTES)
.await?;
if !output.status.success() {
return Err(command_failure(
"status filter neutralization write",
&output,
));
}
Ok(())
}
pub(crate) fn authorize_filter_paths(&mut self, paths: &[String]) -> io::Result<()> {
if self.status.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"apply filter policy cannot coexist with status policy",
));
}
if !self.filters.is_empty() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"apply filter policy must be the first operation snapshot",
));
}
let filter =
build_filter_policy_snapshot(self, paths, FilterExecution::AnyWorktreeOperation)?;
self.filters.push(filter);
Ok(())
}
pub(crate) fn ensure_apply_filter_path_subset(&self, paths: &[String]) -> io::Result<()> {
let [apply] = self.filters.as_slice() else {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"reverse exact staging requires exactly one apply filter snapshot",
));
};
if apply.role() != FilterPolicyRole::Apply {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"reverse exact staging requires an apply filter snapshot",
));
}
if let Some(path) = paths
.iter()
.find(|path| !apply.contains_checked_path(path.as_str()))
{
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
format!(
"content-filter staging path {path:?} was not authorized by the apply snapshot"
),
));
}
Ok(())
}
pub(crate) fn apply_filter_paths(&self) -> io::Result<Vec<String>> {
let [apply] = self.filters.as_slice() else {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"merge policy requires exactly one apply filter snapshot",
));
};
if apply.role() != FilterPolicyRole::Apply {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"merge policy requires an apply filter snapshot",
));
}
Ok(apply.checked_paths())
}
pub(crate) fn run_direct_apply(
&self,
revert: bool,
patch_path: &str,
) -> io::Result<std::process::Output> {
let mode = self.final_apply_whitespace_mode(revert, patch_path)?;
let mut command = self.apply_command()?;
command.arg("--index");
if mode.is_fatal() {
command.arg("--whitespace=nowarn");
}
if revert {
command.arg("-R");
}
command.arg(patch_path);
command.output()
}
pub(crate) fn render_direct_apply_for_log(
&self,
revert: bool,
patch_path: &str,
) -> io::Result<String> {
let mode = self.final_apply_whitespace_mode(revert, patch_path)?;
let mut args = vec!["apply".to_string(), "--index".to_string()];
if mode.is_fatal() {
args.push("--whitespace=nowarn".to_string());
}
if revert {
args.push("-R".to_string());
}
args.push(patch_path.to_string());
self.render_apply_command_for_log(&args)
}
pub(crate) fn run_three_way_apply(
&mut self,
revert: bool,
patch_path: &str,
) -> io::Result<std::process::Output> {
let (apply, _git_add) = self.ordered_filter_snapshots()?;
if apply.is_none() || !self.merge_policy_installed {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"three-way apply policy is not installed",
));
}
self.consume_three_way_merge_policy_proof(revert, patch_path)?;
let merge = self.merge.as_ref().ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"isolated three-way config is unavailable",
)
})?;
let isolated = merge.common_dir(&self.identity)?;
let mut command = self
.sources
.git
.command_for_cwd(&self.sources.canonical_root)?;
append_safe_scalar_overrides(&mut command);
self.apply_policy
.as_ref()
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"three-way apply policy scalars are not frozen",
)
})?
.append_to(&mut command);
BoundSubcommand::Apply.append_to(&mut command);
command.arg("--3way");
if self
.final_apply_whitespace_mode(revert, patch_path)?
.is_fatal()
{
command.arg("--whitespace=nowarn");
}
if revert {
command.arg("-R");
}
command.arg(patch_path);
self.sources
.git
.output_in_isolated_common_dir(command, isolated)
}
pub(crate) fn render_three_way_apply_for_log(
&self,
revert: bool,
patch_path: &str,
) -> io::Result<String> {
// Rendering may precede the final post-staging index revalidation,
// but it must never render a selected-custom operation with no proof.
self.ensure_three_way_merge_policy_proof_installed()?;
let merge = self.merge.as_ref().ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"isolated three-way config is unavailable",
)
})?;
let _ = merge.common_dir(&self.identity)?;
let mut parts = vec![
"env".to_string(),
"GIT_COMMON_DIR=<isolated>".to_string(),
"git".to_string(),
];
parts.extend(safe_scalar_override_args());
self.apply_policy
.as_ref()
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::PermissionDenied,
"three-way apply policy scalars are not frozen",
)
})?
.append_rendered(&mut parts);
parts.push("apply".to_string());
parts.push("--3way".to_string());
if self
.final_apply_whitespace_mode(revert, patch_path)?
.is_fatal()
{
parts.push("--whitespace=nowarn".to_string());
}
if revert {
parts.push("-R".to_string());
}
parts.push(patch_path.to_string());
Ok(format!(
"(cd {} && {})",
quote_shell(&self.sources.canonical_root.display().to_string()),
parts
.into_iter()
.map(|part| quote_shell(&part))
.collect::<Vec<_>>()
.join(" ")
))
}
#[cfg(test)]
pub(crate) fn merge_common_config_path(&self) -> Option<PathBuf> {
self.merge
.as_ref()
.and_then(|merge| merge.common_dir(&self.identity).ok())
.map(crate::git_command::IsolatedGitCommonDir::config_path)
}
pub(crate) fn authorize_git_add_filter_paths(&mut self, paths: &[String]) -> io::Result<()> {
if self.status.is_some() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"Git-add filter policy cannot coexist with status policy",
));
}
match self.filters.as_slice() {
[] => {}
[apply] if apply.role() == FilterPolicyRole::Apply => {}
[apply, git_add]
if apply.role() == FilterPolicyRole::Apply
&& git_add.role() == FilterPolicyRole::GitAdd
&& git_add.checked_paths().into_iter().collect::<BTreeSet<_>>()
== paths.iter().cloned().collect::<BTreeSet<_>>() =>
{
return Ok(());
}
_ => {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"Git-add filter policy requires zero snapshots or exactly one apply snapshot",
));
}
}
let filter = build_filter_policy_snapshot(self, paths, FilterExecution::GitAdd)?;
self.filters.push(filter);
Ok(())
}
#[cfg(test)]
pub(crate) fn render_command_for_log(&self, args: &[String]) -> io::Result<String> {
let mut parts = vec!["git".to_string()];
parts.extend(self.mutation_config_args()?);
parts.extend(args.iter().cloned());
Ok(format!(
"(cd {} && {})",
quote_shell(&self.sources.canonical_root.display().to_string()),
parts
.into_iter()
.map(|part| quote_shell(&part))
.collect::<Vec<_>>()
.join(" ")
))
}
pub(crate) fn render_apply_command_for_log(&self, args: &[String]) -> io::Result<String> {
let mut parts = vec!["git".to_string()];
parts.extend(self.sources.base_config_args.iter().cloned());
parts.extend(safe_scalar_override_args());
let (apply, git_add) = self.ordered_filter_snapshots()?;
if let Some(neutralizer) = apply.and_then(FilterPolicySnapshot::neutralizer) {
neutralizer.append_rendered_args(&self.identity, &mut parts)?;
}
if let Some(neutralizer) = git_add.and_then(FilterPolicySnapshot::neutralizer) {
neutralizer.append_rendered_args(&self.identity, &mut parts)?;
}
if let Some(policy) = &self.apply_policy {
policy.append_rendered(&mut parts);
}
parts.extend(args.iter().cloned());
Ok(format!(
"(cd {} && {})",
quote_shell(&self.sources.canonical_root.display().to_string()),
parts
.into_iter()
.map(|part| quote_shell(&part))
.collect::<Vec<_>>()
.join(" ")
))
}
}
fn command_failure(description: &str, output: &std::process::Output) -> io::Error {
io::Error::other(StatusPolicyCommandFailure {
description: description.to_string(),
exit_code: output.status.code(),
})
}
fn git_path_from_line_output(output: &[u8]) -> io::Result<PathBuf> {
let output = output.strip_suffix(b"\n").unwrap_or(output);
#[cfg(windows)]
let output = output.strip_suffix(b"\r").unwrap_or(output);
if output.is_empty() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"empty Git repository-root output",
));
}
#[cfg(unix)]
{
use std::ffi::OsString;
use std::os::unix::ffi::OsStringExt;
Ok(PathBuf::from(OsString::from_vec(output.to_vec())))
}
#[cfg(not(unix))]
{
String::from_utf8(output.to_vec())
.map(PathBuf::from)
.map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
"non-UTF-8 Git repository-root output",
)
})
}
}
fn safe_scalar_override_args() -> [String; 4] {
[
"-c".to_string(),
format!("core.hooksPath={DISABLED_HOOKS_PATH}"),
"-c".to_string(),
FsmonitorOverride::Disabled.git_config_arg().to_string(),
]
}
fn parse_status_head_oid(output: &[u8]) -> io::Result<String> {
let line = output.strip_suffix(b"\n").ok_or_else(|| {
io::Error::new(io::ErrorKind::InvalidData, "unterminated Status HEAD output")
})?;
let line = line.strip_suffix(b"\r").unwrap_or(line);
if !matches!(line.len(), 40 | 64) || !line.iter().all(u8::is_ascii_hexdigit) {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Status HEAD did not resolve to one full object ID",
));
}
Ok(String::from_utf8(line.to_ascii_lowercase()).expect("ASCII object ID"))
}
fn parse_status_symbolic_ref(output: &[u8]) -> io::Result<std::ffi::OsString> {
let line = output.strip_suffix(b"\n").ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidData,
"unterminated Status symbolic HEAD output",
)
})?;
let line = line.strip_suffix(b"\r").unwrap_or(line);
if !line.starts_with(b"refs/heads/")
|| line.contains(&0)
|| line
.iter()
.any(|byte| byte.is_ascii_control() || byte.is_ascii_whitespace())
{
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Status HEAD did not resolve to a safe symbolic ref",
));
}
git_path_argument(line)
}
fn append_safe_scalar_overrides(command: &mut GitCommand) {
command.args(safe_scalar_override_args());
}
fn quote_shell(value: &str) -> String {
let simple = value
.chars()
.all(|character| character.is_ascii_alphanumeric() || "-_.:/@%+".contains(character));
if simple {
value.to_string()
} else {
format!("'{}'", value.replace('\'', "'\\''"))
}
}
#[cfg(test)]
thread_local! {
static CONFIG_SOURCE_AUTHORIZATION_COUNT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
static FILTER_POLICY_READ_COUNT_FOR_STATUS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
#[cfg(test)]
pub(crate) fn reset_config_source_authorization_count() {
CONFIG_SOURCE_AUTHORIZATION_COUNT.with(|count| count.set(0));
FILTER_POLICY_READ_COUNT_FOR_STATUS.with(|count| count.set(0));
}
#[cfg(test)]
pub(crate) fn config_source_authorization_count() -> usize {
CONFIG_SOURCE_AUTHORIZATION_COUNT.with(std::cell::Cell::get)
}
#[cfg(test)]
pub(crate) fn status_filter_policy_read_count() -> usize {
FILTER_POLICY_READ_COUNT_FOR_STATUS.with(std::cell::Cell::get)
}
#[cfg(test)]
#[path = "guarded_config_tests.rs"]
mod tests;