lib/sigtrap.pm

   1 package sigtrap;
   2
   3 =head1 NAME
   4
   5 sigtrap - Perl pragma to enable simple signal handling
   6
   7 =cut
   8
   9 use Carp;
  10
  11 $VERSION = 1.09;
  12 $Verbose ||= 0;
  13
  14 sub import {
  15     my $pkg = shift;
  16     my $handler = \&handler_traceback;
  17     my $saw_sig = 0;
  18     my $untrapped = 0;
  19     local $_;
  20
  21   Arg_loop:
  22     while (@_) {
  23         $_ = shift;
  24         if (/^[A-Z][A-Z0-9]*$/) {
  25             $saw_sig++;
  26             unless ($untrapped and $SIG{$_} and $SIG{$_} ne 'DEFAULT') {
  27                 print "Installing handler $handler for $_\n" if $Verbose;
  28                 $SIG{$_} = $handler;
  29             }
  30         }
  31         elsif ($_ eq 'normal-signals') {
  32             unshift @_, grep(exists $SIG{$_}, qw(HUP INT PIPE TERM));
  33         }
  34         elsif ($_ eq 'error-signals') {
  35             unshift @_, grep(exists $SIG{$_},
  36                              qw(ABRT BUS EMT FPE ILL QUIT SEGV SYS TRAP));
  37         }
  38         elsif ($_ eq 'old-interface-signals') {
  39             unshift @_,
  40             grep(exists $SIG{$_},
  41                  qw(ABRT BUS EMT FPE ILL PIPE QUIT SEGV SYS TERM TRAP));
  42         }
  43         elsif ($_ eq 'stack-trace') {
  44             $handler = \&handler_traceback;
  45         }
  46         elsif ($_ eq 'die') {
  47             $handler = \&handler_die;
  48         }
  49         elsif ($_ eq 'handler') {
  50             @_ or croak "No argument specified after 'handler'";
  51             $handler = shift;
  52             unless (ref $handler or $handler eq 'IGNORE'
  53                         or $handler eq 'DEFAULT') {
  54                 require Symbol;
  55                 $handler = Symbol::qualify($handler, (caller)[0]);
  56             }
  57         }
  58         elsif ($_ eq 'untrapped') {
  59             $untrapped = 1;
  60         }
  61         elsif ($_ eq 'any') {
  62             $untrapped = 0;
  63         }
  64         elsif ($_ =~ /^\d/) {
  65             $VERSION >= $_ or croak "sigtrap.pm version $_ required,"
  66                                         . " but this is only version $VERSION";
  67         }
  68         else {
  69             croak "Unrecognized argument $_";
  70         }
  71     }
  72     unless ($saw_sig) {
  73         @_ = qw(old-interface-signals);
  74         goto Arg_loop;
  75     }
  76 }
  77
  78 sub handler_die {
  79     croak "Caught a SIG$_[0]";
  80 }
  81
  82 sub handler_traceback {
  83     package DB;         # To get subroutine args.
  84     my $use_print;
  85     $SIG{'ABRT'} = DEFAULT;
  86     kill 'ABRT', $$ if $panic++;
  87
  88     # This function might be called as an unsafe signal handler, so it
  89     # tries to delay any memory allocations as long as possible.
  90     #
  91     # Unfortunately with PerlIO layers, using syswrite() here has always
  92     # been broken.
  93     #
  94     # Calling PerlIO::get_layers() here is tempting, but that does
  95     # allocations, which we're trying to avoid for this early code.
  96     if (eval { syswrite(STDERR, 'Caught a SIG', 12); 1 }) {
  97         syswrite(STDERR, $_[0], length($_[0]));
  98         syswrite(STDERR, ' at ', 4);
  99     }
 100     else {
 101         print STDERR 'Caught a SIG', $_[0], ' at ';
 102         ++$use_print;
 103     }
 104
 105     ($pack,$file,$line) = caller;
 106     unless ($use_print) {
 107         syswrite(STDERR, $file, length($file));
 108         syswrite(STDERR, ' line ', 6);
 109         syswrite(STDERR, $line, length($line));
 110         syswrite(STDERR, "\n", 1);
 111     }
 112     else {
 113         print STDERR $file, ' line ', $line, "\n";
 114     }
 115
 116     # we've got our basic output done, from now on we can be freer with allocations
 117     # find out whether we have any layers we need to worry about
 118     unless ($use_print) {
 119         my @layers = PerlIO::get_layers(*STDERR);
 120         for my $name (@layers) {
 121             unless ($name =~ /^(unix|perlio)$/) {
 122                 ++$use_print;
 123                 last;
 124             }
 125         }
 126     }
 127
 128     # Now go for broke.
 129     for ($i = 1; ($p,$f,$l,$s,$h,$w,$e,$r) = caller($i); $i++) {
 130         @a = ();
 131         for (@{[@args]}) {
 132             s/([\'\\])/\\$1/g;
 133             s/([^\0]*)/'$1'/
 134               unless /^(?: -?[\d.]+ | \*[\w:]* )$/x;
 135             require 'meta_notation.pm';
 136             $_ = _meta_notation($_) if /[[:^print:]]/a;
 137             push(@a, $_);
 138         }
 139         $w = $w ? '@ = ' : '$ = ';
 140         $a = $h ? '(' . join(', ', @a) . ')' : '';
 141         $e =~ s/\n\s*\;\s*\Z// if $e;
 142         $e =~ s/[\\\']/\\$1/g if $e;
 143         if ($r) {
 144             $s = "require '$e'";
 145         } elsif (defined $r) {
 146             $s = "eval '$e'";
 147         } elsif ($s eq '(eval)') {
 148             $s = "eval {...}";
 149         }
 150         $f = "file '$f'" unless $f eq '-e';
 151         $mess = "$w$s$a called from $f line $l\n";
 152         if ($use_print) {
 153             print STDERR $mess;
 154         }
 155         else {
 156             syswrite(STDERR, $mess, length($mess));
 157         }
 158     }
 159     kill 'ABRT', $$;
 160 }
 161
 162 1;
 163
 164 __END__
 165
 166 =head1 SYNOPSIS
 167
 168     use sigtrap;
 169     use sigtrap qw(stack-trace old-interface-signals);  # equivalent
 170     use sigtrap qw(BUS SEGV PIPE ABRT);
 171     use sigtrap qw(die INT QUIT);
 172     use sigtrap qw(die normal-signals);
 173     use sigtrap qw(die untrapped normal-signals);
 174     use sigtrap qw(die untrapped normal-signals
 175                     stack-trace any error-signals);
 176     use sigtrap 'handler' => \&my_handler, 'normal-signals';
 177     use sigtrap qw(handler my_handler normal-signals
 178                     stack-trace error-signals);
 179
 180 =head1 DESCRIPTION
 181
 182 The B<sigtrap> pragma is a simple interface to installing signal
 183 handlers.  You can have it install one of two handlers supplied by
 184 B<sigtrap> itself (one which provides a Perl stack trace and one which
 185 simply C<die()>s), or alternately you can supply your own handler for it
 186 to install.  It can be told only to install a handler for signals which
 187 are either untrapped or ignored.  It has a couple of lists of signals to
 188 trap, plus you can supply your own list of signals.
 189
 190 The arguments passed to the C<use> statement which invokes B<sigtrap>
 191 are processed in order.  When a signal name or the name of one of
 192 B<sigtrap>'s signal lists is encountered a handler is immediately
 193 installed, when an option is encountered it affects subsequently
 194 installed handlers.
 195
 196 =head1 OPTIONS
 197
 198 =head2 SIGNAL HANDLERS
 199
 200 These options affect which handler will be used for subsequently
 201 installed signals.
 202
 203 =over 4
 204
 205 =item B<stack-trace>
 206
 207 The handler used for subsequently installed signals outputs a Perl stack
 208 trace to STDERR and then tries to dump core.  This is the default signal
 209 handler.
 210
 211 =item B<die>
 212
 213 The handler used for subsequently installed signals calls C<die>
 214 (actually C<croak>) with a message indicating which signal was caught.
 215
 216 =item B<handler> I<your-handler>
 217
 218 I<your-handler> will be used as the handler for subsequently installed
 219 signals.  I<your-handler> can be any value which is valid as an
 220 assignment to an element of C<%SIG>. See L<perlvar> for examples of
 221 handler functions.
 222
 223 =back
 224
 225 =head2 SIGNAL LISTS
 226
 227 B<sigtrap> has a few built-in lists of signals to trap.  They are:
 228
 229 =over 4
 230
 231 =item B<normal-signals>
 232
 233 These are the signals which a program might normally expect to encounter
 234 and which by default cause it to terminate.  They are HUP, INT, PIPE and
 235 TERM.
 236
 237 =item B<error-signals>
 238
 239 These signals usually indicate a serious problem with the Perl
 240 interpreter or with your script.  They are ABRT, BUS, EMT, FPE, ILL,
 241 QUIT, SEGV, SYS and TRAP.
 242
 243 =item B<old-interface-signals>
 244
 245 These are the signals which were trapped by default by the old
 246 B<sigtrap> interface, they are ABRT, BUS, EMT, FPE, ILL, PIPE, QUIT,
 247 SEGV, SYS, TERM, and TRAP.  If no signals or signals lists are passed to
 248 B<sigtrap>, this list is used.
 249
 250 =back
 251
 252 For each of these three lists, the collection of signals set to be
 253 trapped is checked before trapping; if your architecture does not
 254 implement a particular signal, it will not be trapped but rather
 255 silently ignored.
 256
 257 =head2 OTHER
 258
 259 =over 4
 260
 261 =item B<untrapped>
 262
 263 This token tells B<sigtrap> to install handlers only for subsequently
 264 listed signals which aren't already trapped or ignored.
 265
 266 =item B<any>
 267
 268 This token tells B<sigtrap> to install handlers for all subsequently
 269 listed signals.  This is the default behavior.
 270
 271 =item I<signal>
 272
 273 Any argument which looks like a signal name (that is,
 274 C</^[A-Z][A-Z0-9]*$/>) indicates that B<sigtrap> should install a
 275 handler for that name.
 276
 277 =item I<number>
 278
 279 Require that at least version I<number> of B<sigtrap> is being used.
 280
 281 =back
 282
 283 =head1 EXAMPLES
 284
 285 Provide a stack trace for the old-interface-signals:
 286
 287     use sigtrap;
 288
 289 Ditto:
 290
 291     use sigtrap qw(stack-trace old-interface-signals);
 292
 293 Provide a stack trace on the 4 listed signals only:
 294
 295     use sigtrap qw(BUS SEGV PIPE ABRT);
 296
 297 Die on INT or QUIT:
 298
 299     use sigtrap qw(die INT QUIT);
 300
 301 Die on HUP, INT, PIPE or TERM:
 302
 303     use sigtrap qw(die normal-signals);
 304
 305 Die on HUP, INT, PIPE or TERM, except don't change the behavior for
 306 signals which are already trapped or ignored:
 307
 308     use sigtrap qw(die untrapped normal-signals);
 309
 310 Die on receipt one of an of the B<normal-signals> which is currently
 311 B<untrapped>, provide a stack trace on receipt of B<any> of the
 312 B<error-signals>:
 313
 314     use sigtrap qw(die untrapped normal-signals
 315                     stack-trace any error-signals);
 316
 317 Install my_handler() as the handler for the B<normal-signals>:
 318
 319     use sigtrap 'handler', \&my_handler, 'normal-signals';
 320
 321 Install my_handler() as the handler for the normal-signals, provide a
 322 Perl stack trace on receipt of one of the error-signals:
 323
 324     use sigtrap qw(handler my_handler normal-signals
 325                     stack-trace error-signals);
 326
 327 =cut