Struct yash_env::trap::TrapSet

pub struct TrapSet { /* private fields */ }

Collection of event handling settings.

See the module documentation for details.

Implementations

impl TrapSet

pub fn get_state<C: Into<Condition>>( &self, cond: C, ) -> (Option<&TrapState>, Option<&TrapState>)

Returns the current state for a condition.

This function returns a pair of optional trap states. The first is the currently configured trap action, and the second is the action set before enter_subshell was called.

This function does not reflect the initial signal actions the shell inherited on startup.

pub fn set_action<S: SignalSystem, C: Into<Condition>>( &mut self, system: &mut S, cond: C, action: Action, origin: Location, override_ignore: bool, ) -> Result<(), SetActionError>

Sets a trap action for a condition.

If the condition is a signal, this function installs a signal handler to the specified underlying system.

If override_ignore is false, you cannot set a trap for a signal that has been ignored since the shell startup. An interactive shell should set override_ignore to true to bypass this restriction.

You can never set a trap for SIGKILL or SIGSTOP.

origin should be the location of the command performing this trap update. It is only informative: It does not affect the signal handling behavior and can be referenced later by get_state.

This function clears all parent states remembered when entering a subshell, not only for the specified condition but also for all other conditions.

pub fn iter(&self) -> Iter<'_>

Returns an iterator over the signal actions configured in this trap set.

The iterator yields tuples of the signal, the currently configured trap action, and the action set before enter_subshell was called.

pub fn enter_subshell<S: SignalSystem>( &mut self, system: &mut S, ignore_sigint_sigquit: bool, keep_stopper_handlers: bool, )

Updates signal handlings on entering a subshell.

Resetting non-ignore traps

POSIX requires that traps other than Action::Ignore be reset when entering a subshell. This function achieves that effect.

The trap set will remember the original trap states as the parent states. You can get them from the second return value of get_state or the third item of tuples yielded by an iterator.

Note that trap actions other than Trap::Command remain as before.

Clearing internal handlers

Internal handlers that have been installed are cleared except for the SIGCHLD handler.

Ignoring SIGINT and SIGQUIT

If ignore_sigint_sigquit is true, this function sets the signal handlings for SIGINT and SIGQUIT to Ignore.

Ignoring SIGTSTP, SIGTTIN, and SIGTTOU

If keep_stopper_handlers is true and the stopper handlers have been enabled, this function leaves the signal handlings for SIGTSTP, SIGTTIN, and SIGTTOU set to Ignore.

Errors

This function ignores any errors that may occur when setting signal handlings.

pub fn catch_signal(&mut self, signal: Number)

Sets the pending flag of the TrapState for the specified signal.

This function does nothing if no trap action has been set for the signal.

pub fn take_signal_if_caught(&mut self, signal: Number) -> Option<&TrapState>

Resets the pending flag of the TrapState for the specified signal.

Returns the TrapState if the flag was set.

pub fn take_caught_signal(&mut self) -> Option<(Number, &TrapState)>

Returns a signal that has been caught.

This function clears the pending flag of the TrapState for the specified signal.

If there is more than one caught signal, it is unspecified which one of them is returned. If there is no caught signal, None is returned.

pub fn enable_sigchld_handler<S: SignalSystem>( &mut self, system: &mut S, ) -> Result<(), Errno>

Installs an internal handler for SIGCHLD.

You should install the SIGCHLD handler to the system by using this function before waiting for SIGCHLD with System::wait and SharedSystem::wait_for_signal. The handler allows catching SIGCHLD.

This function remembers that the handler has been installed, so a second call to the function will be a no-op.

pub fn enable_terminator_handlers<S: SignalSystem>( &mut self, system: &mut S, ) -> Result<(), Errno>

Installs internal handlers for SIGINT, SIGTERM, and SIGQUIT.

An interactive shell should install the handlers for these signals by using this function. The SIGINT handler allows catching SIGINT and the SIGTERM and SIGQUIT handlers ignore the signals.

This function remembers that the handlers have been installed, so a second call to the function will be a no-op.

pub fn enable_stopper_handlers<S: SignalSystem>( &mut self, system: &mut S, ) -> Result<(), Errno>

Installs internal handlers for SIGTSTP, SIGTTIN, and SIGTTOU.

An interactive job-controlling shell should install the handlers for these signals by using this function. The handlers ignore the signals.

This function remembers that the handlers have been installed, so a second call to the function will be a no-op.

pub fn disable_terminator_handlers<S: SignalSystem>( &mut self, system: &mut S, ) -> Result<(), Errno>

Uninstalls the internal handlers for SIGINT, SIGTERM, and SIGQUIT.

pub fn disable_stopper_handlers<S: SignalSystem>( &mut self, system: &mut S, ) -> Result<(), Errno>

Uninstalls the internal handlers for SIGTSTP, SIGTTIN, and SIGTTOU.

pub fn disable_internal_handlers<S: SignalSystem>( &mut self, system: &mut S, ) -> Result<(), Errno>

Uninstalls all internal handlers.

This function removes all internal handlers that have been previously installed by self. It leaves handlers for any existing user-defined traps.

Trait Implementations

impl Clone for TrapSet

fn clone(&self) -> TrapSet

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrapSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TrapSet

fn default() -> TrapSet

Returns the “default value” for a type.

impl<'a> IntoIterator for &'a TrapSet

type Item = (&'a Condition, Option<&'a TrapState>, Option<&'a TrapState>)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.