use crate::shell::ast::Command;
use crate::shell::environment::ShellEnv;
use std::fs;
use std::io;
#[derive(Debug, Clone)]
pub struct ExecResult {
pub stdout: String,
pub stderr: String,
pub exit_code: i32,
}
pub fn is_inproc_builtin(name: &str) -> bool {
matches!(
name,
"cd" | "pushd"
| "popd"
| "export"
| "echo"
| "@echo"
| "mkdir"
| "rm"
| "umask"
| "ulimit"
| ":"
)
}
pub fn run_inproc_builtin(
cmd: &Command,
env: &mut ShellEnv,
_stdin: Option<&str>,
) -> Result<ExecResult, String> {
if cmd.args.is_empty() {
return Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
});
}
match cmd.args[0].as_str() {
"cd" => builtin_cd(cmd, env),
"pushd" => builtin_pushd(cmd, env),
"popd" => builtin_popd(cmd, env),
"export" => builtin_export(cmd, env),
"echo" | "@echo" => builtin_echo(cmd, env, None),
"mkdir" => builtin_mkdir(cmd, env),
"rm" => builtin_rm(cmd, env),
"umask" => builtin_umask(cmd, env),
"ulimit" => builtin_ulimit(cmd, env),
":" => Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
}),
_ => Err(format!("unsupported builtin '{}'", cmd.args[0].as_str())),
}
}
fn builtin_cd(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 2 {
return Err("'cd' supports exactly one argument".into());
}
env.change_dir(cmd.args[1].as_str())?;
Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_pushd(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 2 {
return Err("'pushd' supports exactly one argument".into());
}
env.pushd(cmd.args[1].as_str())?;
Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_popd(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 1 {
return Err("'popd' does not support arguments".into());
}
env.popd()
.ok_or_else(|| "popd: directory stack empty".to_string())?;
Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_export(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() == 1 {
let mut entries = env
.env
.iter()
.map(|(key, value)| format!("{key}={value}"))
.collect::<Vec<_>>();
entries.sort_unstable();
let output = entries.join("\n") + "\n";
return Ok(ExecResult {
stdout: output,
stderr: String::new(),
exit_code: 0,
});
}
let mut i = 1usize;
let mut unset_next = false;
let mut clear_env = false;
while i < cmd.args.len() {
let arg = cmd.args[i].as_str();
if unset_next {
env.env.remove(arg);
unset_next = false;
i += 1;
continue;
}
if arg == "-u" {
unset_next = true;
i += 1;
continue;
}
if arg == "-i" {
clear_env = true;
i += 1;
continue;
}
if clear_env {
env.env.clear();
clear_env = false;
}
let Some((key, value)) = arg.split_once('=') else {
return Err(format!("'export' malformed assignment '{arg}'"));
};
env.env.insert(key.to_string(), value.to_string());
i += 1;
}
if unset_next {
return Err("'export -u' requires a variable name".to_string());
}
if clear_env {
env.env.clear();
}
Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_echo(
cmd: &Command,
_env: &mut ShellEnv,
_stdin: Option<&str>,
) -> Result<ExecResult, String> {
let mut args = cmd.args.iter().skip(1).peekable();
let mut interpret_escape = false;
let mut add_newline = true;
let mut payload = Vec::new();
while let Some(arg) = args.peek() {
match arg.as_str() {
"-e" => {
interpret_escape = true;
args.next();
}
"-n" => {
add_newline = false;
args.next();
}
_ => break,
}
}
for arg in args {
payload.push(decode_echo(arg.as_str(), interpret_escape));
}
let mut out = String::new();
if !payload.is_empty() {
out.push_str(&payload.join(" "));
}
if add_newline {
out.push('\n');
}
Ok(ExecResult {
stdout: out,
stderr: String::new(),
exit_code: 0,
})
}
fn decode_echo(input: &str, interpret_escape: bool) -> String {
if !interpret_escape {
return input.to_string();
}
let mut out = String::new();
let mut chars = input.chars().peekable();
while let Some(ch) = chars.next() {
if ch != '\\' {
out.push(ch);
continue;
}
match chars.next() {
Some('n') => out.push('\n'),
Some('t') => out.push('\t'),
Some('r') => out.push('\r'),
Some('0') => out.push('\0'),
Some(other) => out.push(other),
None => out.push('\\'),
}
}
out
}
fn builtin_mkdir(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() < 2 {
return Err("mkdir: missing operand".into());
}
let mut recursive = false;
let mut paths = Vec::new();
let mut i = 1usize;
while i < cmd.args.len() {
let arg = cmd.args[i].as_str();
if arg == "-p" {
recursive = true;
i += 1;
continue;
}
if arg == "--" {
i += 1;
paths.extend(cmd.args[i..].iter().map(|arg| arg.as_owned_text()));
break;
}
if arg.starts_with('-') && arg != "-" {
if arg[1..].chars().all(|flag| flag == 'p') {
recursive = true;
i += 1;
continue;
}
return Err(format!("mkdir: unsupported option '{arg}'"));
}
paths.push(arg.to_string());
i += 1;
}
if paths.is_empty() {
return Err("mkdir: missing operand".into());
}
let mut stderr = String::new();
let mut exit_code = 0;
for path in paths {
let path = env.resolve_path(&path);
let result = if recursive {
fs::create_dir_all(&path)
} else {
fs::create_dir(&path)
};
if let Err(err) = result {
exit_code = 1;
stderr.push_str(&format!("mkdir: {err}\n"));
}
}
Ok(ExecResult {
stdout: String::new(),
stderr,
exit_code,
})
}
fn builtin_rm(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() < 2 {
return Err("rm: missing operand".into());
}
let mut force = false;
let mut recursive = false;
let mut paths = Vec::new();
let mut i = 1usize;
while i < cmd.args.len() {
let arg = cmd.args[i].as_str();
if arg == "-f" {
force = true;
i += 1;
continue;
}
if arg == "-r" || arg == "-R" || arg == "--recursive" {
recursive = true;
i += 1;
continue;
}
if arg == "--" {
i += 1;
paths.extend(cmd.args[i..].iter().map(|arg| arg.as_owned_text()));
break;
}
if arg.starts_with('-') && arg != "-" {
let mut recognized = true;
for flag in arg[1..].chars() {
match flag {
'f' => force = true,
'r' | 'R' => recursive = true,
_ => recognized = false,
}
}
if recognized {
i += 1;
continue;
}
return Err(format!("rm: unsupported option '{arg}'"));
}
paths.push(arg.to_string());
i += 1;
}
if paths.is_empty() {
return Err("rm: missing operand".into());
}
let mut stderr = String::new();
let mut exit_code = 0;
for path in paths {
let target = env.resolve_path(&path);
let metadata = fs::symlink_metadata(&target);
let result = if metadata
.as_ref()
.is_ok_and(|metadata| metadata.file_type().is_symlink())
{
fs::remove_file(&target)
} else if target.is_dir() {
if recursive {
fs::remove_dir_all(&target)
} else {
Err(io::Error::other("is a directory"))
}
} else if force && !target.exists() {
Ok(())
} else {
fs::remove_file(&target)
};
if let Err(err) = result {
exit_code = 1;
if !force || err.kind() != io::ErrorKind::NotFound {
stderr.push_str(&format!("rm: {path}: {err}\n"));
}
}
}
Ok(ExecResult {
stdout: String::new(),
stderr,
exit_code,
})
}
fn builtin_umask(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
#[cfg(not(unix))]
{
let _ = (cmd, env);
Err("'umask' is not supported on this platform".into())
}
#[cfg(unix)]
{
if cmd.args.len() != 2 {
return Err("umask supports exactly one argument".into());
}
let value = u32::from_str_radix(cmd.args[1].as_str(), 8)
.map_err(|_| "invalid octal umask".to_string())?;
if value > 0o777 {
return Err("umask must be between 000 and 777".to_string());
}
env.umask = Some(value);
Ok(ExecResult {
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
}
fn builtin_ulimit(cmd: &Command, _env: &mut ShellEnv) -> Result<ExecResult, String> {
Err(format!(
"'ulimit' is unsupported; refusing to run '{}' without applying a resource limit",
cmd.args
.iter()
.map(|arg| arg.as_str())
.collect::<Vec<_>>()
.join(" ")
))
}
#[cfg(test)]
mod tests {
use super::builtin_echo;
#[test]
fn decode_escaped_newline() {
let cmd = crate::shell::ast::Command {
args: vec!["echo".into(), "a\\nb".into()],
redirects: Vec::new(),
};
let mut env = crate::shell::environment::ShellEnv::new(
std::env::current_dir().unwrap(),
std::collections::HashMap::new(),
false,
);
let res = builtin_echo(&cmd, &mut env, None).unwrap();
assert_eq!(res.stdout, "a\\nb\n");
}
}