From 166585796d037b259f2bf6933309a0a1498a87fb Mon Sep 17 00:00:00 2001
From: Michael Aaron Murphy <mmstickman@gmail.com>
Date: Sat, 23 Dec 2017 14:33:03 -0500
Subject: [PATCH] Forks may now ignore streams
Before this commit, it was possible to capture the stdout and
stderr streams. Now it is possible to also ignore the stdout
and stderr streams. As a result, the usage of fork within Ion
will now ignore stderr when performing a shell expansion, or
obtaining the function prompt.
---
src/shell/binary/prompt.rs | 2 +-
src/shell/fork.rs | 48 ++++++++++++++++++++++++++------------
src/shell/mod.rs | 2 +-
src/sys/redox.rs | 1 +
src/sys/unix/mod.rs | 1 +
5 files changed, 37 insertions(+), 17 deletions(-)
diff --git a/src/shell/binary/prompt.rs b/src/shell/binary/prompt.rs
index 4df35747..34cc3cf3 100644
--- a/src/shell/binary/prompt.rs
+++ b/src/shell/binary/prompt.rs
@@ -20,7 +20,7 @@ pub(crate) fn prompt_fn(shell: &mut Shell) -> Option<String> {
let mut output = None;
- match shell.fork(Capture::Stdout, |child| unsafe {
+ match shell.fork(Capture::StdoutThenIgnoreStderr, |child| unsafe {
let _ = function.read().execute(child, &["ion"]);
}) {
Ok(result) => {
diff --git a/src/shell/fork.rs b/src/shell/fork.rs
index 761eb8ed..97a7d0c8 100644
--- a/src/shell/fork.rs
+++ b/src/shell/fork.rs
@@ -11,13 +11,23 @@ use sys;
/// A type that is utilized by the `Fork` structure.
pub enum Capture {
/// Don't capture any streams at all.
- None = 0,
+ None = 0b0000,
/// Capture just the standard output stream.
- Stdout = 1,
+ Stdout = 0b0001,
/// Capture just the standard error stream.
- Stderr = 2,
+ Stderr = 0b0010,
/// Capture both the standard output and error streams.
- Both = 3,
+ Both = 0b0011,
+ /// Redirect just the stdandard output stream to /dev/null.
+ IgnoreStdout = 0b0100,
+ /// Redirect just the standard error stream to /dev/null.
+ IgnoreStderr = 0b1000,
+ /// Redirect both the standard output and error streams to /dev/null.
+ IgnoreBoth = 0b1100,
+ /// Capture standard output and ignore standard error.
+ StdoutThenIgnoreStderr = 0b1001,
+ /// Capture standard error and ignore standard output.
+ StderrThenIgnoreStdout = 0b0110,
}
/// Utilized by the shell for performing forks and capturing streams.
@@ -49,7 +59,7 @@ impl<'a> Fork<'a> {
sys::signals::block();
// If we are to capture stdout, create a pipe for capturing outputs.
- let outs = if self.capture as u8 & Capture::Stdout as u8 != 0 {
+ let mut outs = if self.capture as u8 & Capture::Stdout as u8 != 0 {
Some(sys::pipe2(sys::O_CLOEXEC)
.map(|fds| unsafe { (File::from_raw_fd(fds.0), File::from_raw_fd(fds.1)) })
.map_err(|err| IonError::Fork { why: err })?)
@@ -58,7 +68,7 @@ impl<'a> Fork<'a> {
};
// And if we are to capture stderr, create a pipe for that as well.
- let errs = if self.capture as u8 & Capture::Stderr as u8 != 0 {
+ let mut errs = if self.capture as u8 & Capture::Stderr as u8 != 0 {
Some(sys::pipe2(sys::O_CLOEXEC)
.map(|fds| unsafe { (File::from_raw_fd(fds.0), File::from_raw_fd(fds.1)) })
.map_err(|err| IonError::Fork { why: err })?)
@@ -66,28 +76,36 @@ impl<'a> Fork<'a> {
None
};
+ // TODO: Have a global static store a File that points to /dev/null (or :null for Redox)
+ // at the beginning of the program so that any request for /dev/null's fd doesn't need to
+ // be repeated.
+ let null_file = File::open(sys::NULL_PATH);
+
match unsafe { sys::fork() } {
Ok(0) => {
// Allow the child to handle it's own signal handling.
sys::signals::unblock();
- // Redirect standard output to a pipe, if needed.
- if let Some((read, write)) = outs {
+ // Redirect standard output to a pipe, or /dev/null, if needed.
+ if self.capture as u8 & Capture::IgnoreStdout as u8 != 0 {
+ if let Ok(null) = null_file.as_ref() {
+ let _ = sys::dup2(null.as_raw_fd(), sys::STDOUT_FILENO);
+ }
+ } else if let Some((_read, write)) = outs.take() {
let _ = sys::dup2(write.as_raw_fd(), sys::STDOUT_FILENO);
- drop(write);
- drop(read);
}
- // Redirect standard error to a pipe, if needed.
- if let Some((read, write)) = errs {
+ // Redirect standard error to a pipe, or /dev/null, if needed.
+ if self.capture as u8 & Capture::IgnoreStderr as u8 != 0 {
+ if let Ok(null) = null_file.as_ref() {
+ let _ = sys::dup2(null.as_raw_fd(), sys::STDERR_FILENO);
+ }
+ } else if let Some((_read, write)) = errs.take() {
let _ = sys::dup2(write.as_raw_fd(), sys::STDERR_FILENO);
- drop(write);
- drop(read);
}
// Execute the given closure within the child's shell.
let mut shell: Shell = unsafe { (self.shell as *const Shell).read() };
- // shell.context.take().map(|mut c| c.history.commit_history());
child_func(&mut shell);
// Reap the child, enabling the parent to get EOF from the read end of the pipe.
diff --git a/src/shell/mod.rs b/src/shell/mod.rs
index b492b047..50b938e3 100644
--- a/src/shell/mod.rs
+++ b/src/shell/mod.rs
@@ -461,7 +461,7 @@ impl<'a> Expander for Shell {
/// Uses a subshell to expand a given command.
fn command(&self, command: &str) -> Option<Value> {
let mut output = None;
- match self.fork(Capture::Stdout, move |shell| shell.on_command(command)) {
+ match self.fork(Capture::StdoutThenIgnoreStderr, move |shell| shell.on_command(command)) {
Ok(result) => {
let mut string = String::new();
match result.stdout.unwrap().read_to_string(&mut string) {
diff --git a/src/sys/redox.rs b/src/sys/redox.rs
index 0426f3ba..7719cc5c 100644
--- a/src/sys/redox.rs
+++ b/src/sys/redox.rs
@@ -9,6 +9,7 @@ use std::path::PathBuf;
use syscall::SigAction;
pub(crate) const PATH_SEPARATOR: &str = ";";
+pub(crate) const NULL_PATH: &str = "null:";
pub(crate) const O_CLOEXEC: usize = syscall::O_CLOEXEC;
pub(crate) const SIGHUP: i32 = syscall::SIGHUP as i32;
diff --git a/src/sys/unix/mod.rs b/src/sys/unix/mod.rs
index 5f6ff086..2af338a0 100644
--- a/src/sys/unix/mod.rs
+++ b/src/sys/unix/mod.rs
@@ -10,6 +10,7 @@ use std::ffi::CString;
use std::os::unix::io::RawFd;
pub(crate) const PATH_SEPARATOR: &str = ":";
+pub(crate) const NULL_PATH: &str = "/dev/null";
pub(crate) const O_CLOEXEC: usize = libc::O_CLOEXEC as usize;
pub(crate) const SIGHUP: i32 = libc::SIGHUP;
--
GitLab