File Coverage

blib/lib/Signal/Unsafe.pm

Criterion	Covered	Total	%
statement	42	79	53.1
branch	2	14	14.2
condition	1	3	33.3
subroutine	14	25	56.0
pod	0	1	0.0
total	59	122	48.3

package Signal::Unsafe;
$Signal::Unsafe::VERSION = '0.007';
use strict;
use warnings;

use XSLoader;
XSLoader::load(__PACKAGE__, Signal::Unsafe->VERSION);

use Exporter 5.57 'import';
our @EXPORT_OK = qw/sigaction/;

use Config;
use IPC::Signal qw/sig_num sig_name/;
use Scalar::Util 'blessed';
use List::Util 'reduce';
use POSIX ();
use Signal::Info;

{
	no warnings 'once';
	tie %Signal::Unsafe, __PACKAGE__;
}
our $Flags = POSIX::SA_SIGINFO;
our $Mask  = POSIX::SigSet->new;

my $sig_max = $Config{sig_count} - 1;

sub TIEHASH {
	my $class = shift;
	my $self = { iterator => 1, };
	return bless $self, $class;
}

sub _get_status {
	my ($self, $num) = @_;
	my $ret = POSIX::SigAction->new;
	sigaction($num, undef, $ret);
	return [ $ret->handler, $ret->flags, $ret->mask ];
}

sub FETCH {
	my ($self, $key) = @_;
	return $self->_get_status(sig_num($key));
}

my %flag_values = (
	siginfo   => POSIX::SA_SIGINFO,
	nodefer   => POSIX::SA_NODEFER,
	restart   => POSIX::SA_RESTART,
	onstack   => POSIX::SA_ONSTACK,
	resethand => POSIX::SA_RESETHAND,
	nocldstop => POSIX::SA_NOCLDSTOP,
	nocldwait => POSIX::SA_NOCLDWAIT,
);

sub make_action {
	my $value = shift;
	if (blessed($value) && $value->isa('POSIX::SigAction')) {
		return $value;
	} elsif (ref $value eq 'ARRAY') {
		my ($handler, $flags, $mask) = @{$value};
		$mask = $Mask if not defined $mask;
		$flags = not defined $flags ? $Flags : ref($flags) ne 'ARRAY' ? $flags : reduce { $a | $b } map { $flag_values{$_} } @{$flags};
		return POSIX::SigAction->new($handler, $mask, $flags);
	}
	else {
		return POSIX::SigAction->new($value, $Mask, $Flags);
	}
}

sub STORE {
	my ($self, $key, $value) = @_;
	sigaction(sig_num($key), make_action($value));
	return;
}

sub DELETE {
	my ($self, $key) = @_;
	my $old = POSIX::SigAction->new("DEFAULT", $Mask, $Flags);
	sigaction(sig_num($key), POSIX::SigAction->new("DEFAULT", $Mask, $Flags), $old);
	return ($old->handler, $old->mask, $old->flags);
}

sub CLEAR {
	my ($self) = @_;
	for my $sig_no (1 .. $sig_max) {
		sigaction($sig_no, POSIX::SigAction->new("DEFAULT", $Mask, $Flags));
	}
	return;
}

sub EXISTS {
	my ($self, $key) = @_;
	return defined sig_num($key);
}

sub FIRSTKEY {
	my $self = shift;
	$self->{iterator} = 1;
	return $self->NEXTKEY;
}

sub NEXTKEY {
	my $self = shift;
	if ($self->{iterator} <= $sig_max) {
		my $num = $self->{iterator}++;
		return wantarray ? (sig_name($num) => $self->_get_status($num)) : sig_name($num);
	}
	else {
		return;
	}
}

sub SCALAR {
	return 1;
}

sub UNTIE {
	my $self = shift;
	$self->CLEAR;
	return;
}

sub DESTROY {
}

1;

#ABSTRACT: Unsafe signal handlers made convenient

__END__