builtins/trap.def

   1 This file is trap.def, from which is created trap.c.
   2 It implements the builtin "trap" in Bash.
   3
   4 Copyright (C) 1987-2015 Free Software Foundation, Inc.
   5
   6 This file is part of GNU Bash, the Bourne Again SHell.
   7
   8 Bash is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 Bash is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 $PRODUCES trap.c
  22
  23 $BUILTIN trap
  24 $FUNCTION trap_builtin
  25 $SHORT_DOC trap [-lp] [[arg] signal_spec ...]
  26 Trap signals and other events.
  27
  28 Defines and activates handlers to be run when the shell receives signals
  29 or other conditions.
  30
  31 ARG is a command to be read and executed when the shell receives the
  32 signal(s) SIGNAL_SPEC.  If ARG is absent (and a single SIGNAL_SPEC
  33 is supplied) or `-', each specified signal is reset to its original
  34 value.  If ARG is the null string each SIGNAL_SPEC is ignored by the
  35 shell and by the commands it invokes.
  36
  37 If a SIGNAL_SPEC is EXIT (0) ARG is executed on exit from the shell.  If
  38 a SIGNAL_SPEC is DEBUG, ARG is executed before every simple command.  If
  39 a SIGNAL_SPEC is RETURN, ARG is executed each time a shell function or a
  40 script run by the . or source builtins finishes executing.  A SIGNAL_SPEC
  41 of ERR means to execute ARG each time a command's failure would cause the
  42 shell to exit when the -e option is enabled.
  43
  44 If no arguments are supplied, trap prints the list of commands associated
  45 with each signal.
  46
  47 Options:
  48   -l    print a list of signal names and their corresponding numbers
  49   -p    display the trap commands associated with each SIGNAL_SPEC
  50
  51 Each SIGNAL_SPEC is either a signal name in <signal.h> or a signal number.
  52 Signal names are case insensitive and the SIG prefix is optional.  A
  53 signal may be sent to the shell with "kill -signal $$".
  54
  55 Exit Status:
  56 Returns success unless a SIGSPEC is invalid or an invalid option is given.
  57 $END
  58
  59 #include <config.h>
  60
  61 #if defined (HAVE_UNISTD_H)
  62 #  ifdef _MINIX
  63 #    include <sys/types.h>
  64 #  endif
  65 #  include <unistd.h>
  66 #endif
  67
  68 #include "../bashtypes.h"
  69 #include <signal.h>
  70 #include <stdio.h>
  71 #include "../bashansi.h"
  72
  73 #include "../shell.h"
  74 #include "../trap.h"
  75 #include "common.h"
  76 #include "bashgetopt.h"
  77
  78 static void showtrap __P((int));
  79 static int display_traps __P((WORD_LIST *));
  80
  81 /* The trap command:
  82
  83    trap <arg> <signal ...>
  84    trap <signal ...>
  85    trap -l
  86    trap -p [sigspec ...]
  87    trap [--]
  88
  89    Set things up so that ARG is executed when SIGNAL(s) N is received.
  90    If ARG is the empty string, then ignore the SIGNAL(s).  If there is
  91    no ARG, then set the trap for SIGNAL(s) to its original value.  Just
  92    plain "trap" means to print out the list of commands associated with
  93    each signal number.  Single arg of "-l" means list the signal names. */
  94
  95 /* Possible operations to perform on the list of signals.*/
  96 #define SET 0                   /* Set this signal to first_arg. */
  97 #define REVERT 1                /* Revert to this signals original value. */
  98 #define IGNORE 2                /* Ignore this signal. */
  99
 100 extern int posixly_correct, subshell_environment;
 101
 102 int
 103 trap_builtin (list)
 104      WORD_LIST *list;
 105 {
 106   int list_signal_names, display, result, opt;
 107
 108   list_signal_names = display = 0;
 109   result = EXECUTION_SUCCESS;
 110
 111   reset_internal_getopt ();
 112   while ((opt = internal_getopt (list, "lp")) != -1)
 113     {
 114       switch (opt)
 115         {
 116         case 'l':
 117           list_signal_names++;
 118           break;
 119         case 'p':
 120           display++;
 121           break;
 122         CASE_HELPOPT;
 123         default:
 124           builtin_usage ();
 125           return (EX_USAGE);
 126         }
 127     }
 128   list = loptend;
 129
 130   opt = DSIG_NOCASE|DSIG_SIGPREFIX;     /* flags for decode_signal */
 131
 132   if (list_signal_names)
 133     return (sh_chkwrite (display_signal_list ((WORD_LIST *)NULL, 1)));
 134   else if (display || list == 0)
 135     {
 136       initialize_terminating_signals ();
 137       get_all_original_signals ();
 138       return (sh_chkwrite (display_traps (list)));
 139     }
 140   else
 141     {
 142       char *first_arg;
 143       int operation, sig, first_signal;
 144
 145       operation = SET;
 146       first_arg = list->word->word;
 147       first_signal = first_arg && *first_arg && all_digits (first_arg) && signal_object_p (first_arg, opt);
 148
 149       /* Backwards compatibility.  XXX - question about whether or not we
 150          should throw an error if an all-digit argument doesn't correspond
 151          to a valid signal number (e.g., if it's `50' on a system with only
 152          32 signals).  */
 153       if (first_signal)
 154         operation = REVERT;
 155       /* When in posix mode, the historical behavior of looking for a
 156          missing first argument is disabled.  To revert to the original
 157          signal handling disposition, use `-' as the first argument. */
 158       else if (posixly_correct == 0 && first_arg && *first_arg &&
 159                 (*first_arg != '-' || first_arg[1]) &&
 160                 signal_object_p (first_arg, opt) && list->next == 0)
 161         operation = REVERT;
 162       else
 163         {
 164           list = list->next;
 165           if (list == 0)
 166             {
 167               builtin_usage ();
 168               return (EX_USAGE);
 169             }
 170           else if (*first_arg == '\0')
 171             operation = IGNORE;
 172           else if (first_arg[0] == '-' && !first_arg[1])
 173             operation = REVERT;
 174         }
 175
 176       /* If we're in a command substitution, we haven't freed the trap strings
 177          (though we reset the signal handlers).  If we're setting a trap to
 178          handle a signal here, free the rest of the trap strings since they
 179          don't apply any more. */
 180       if (subshell_environment & SUBSHELL_RESETTRAP)
 181         {
 182           free_trap_strings ();
 183           subshell_environment &= ~SUBSHELL_RESETTRAP;
 184         }
 185
 186       while (list)
 187         {
 188           sig = decode_signal (list->word->word, opt);
 189
 190           if (sig == NO_SIG)
 191             {
 192               sh_invalidsig (list->word->word);
 193               result = EXECUTION_FAILURE;
 194             }
 195           else
 196             {
 197               switch (operation)
 198                 {
 199                   case SET:
 200                     set_signal (sig, first_arg);
 201                     break;
 202
 203                   case REVERT:
 204                     restore_default_signal (sig);
 205
 206                     /* Signals that the shell treats specially need special
 207                        handling. */
 208                     switch (sig)
 209                       {
 210                       case SIGINT:
 211                         /* XXX - should we do this if original disposition
 212                            was SIG_IGN? */
 213                         if (interactive)
 214                           set_signal_handler (SIGINT, sigint_sighandler);
 215                         else
 216                           set_signal_handler (SIGINT, termsig_sighandler);
 217                         break;
 218
 219                       case SIGQUIT:
 220                         /* Always ignore SIGQUIT. */
 221                         set_signal_handler (SIGQUIT, SIG_IGN);
 222                         break;
 223                       case SIGTERM:
 224 #if defined (JOB_CONTROL)
 225                       case SIGTTIN:
 226                       case SIGTTOU:
 227                       case SIGTSTP:
 228 #endif /* JOB_CONTROL */
 229                         if (interactive)
 230                           set_signal_handler (sig, SIG_IGN);
 231                         break;
 232                       }
 233                     break;
 234
 235                   case IGNORE:
 236                     ignore_signal (sig);
 237                     break;
 238                 }
 239             }
 240           list = list->next;
 241         }
 242     }
 243
 244   return (result);
 245 }
 246
 247 static void
 248 showtrap (i)
 249      int i;
 250 {
 251   char *t, *p, *sn;
 252
 253   p = trap_list[i];
 254   if (p == (char *)DEFAULT_SIG && signal_is_hard_ignored (i) == 0)
 255     return;
 256   else if (signal_is_hard_ignored (i))
 257     t = (char *)NULL;
 258   else
 259     t = (p == (char *)IGNORE_SIG) ? (char *)NULL : sh_single_quote (p);
 260
 261   sn = signal_name (i);
 262   /* Make sure that signals whose names are unknown (for whatever reason)
 263      are printed as signal numbers. */
 264   if (STREQN (sn, "SIGJUNK", 7) || STREQN (sn, "unknown", 7))
 265     printf ("trap -- %s %d\n", t ? t : "''", i);
 266   else if (posixly_correct)
 267     {
 268       if (STREQN (sn, "SIG", 3))
 269         printf ("trap -- %s %s\n", t ? t : "''", sn+3);
 270       else
 271         printf ("trap -- %s %s\n", t ? t : "''", sn);
 272     }
 273   else
 274     printf ("trap -- %s %s\n", t ? t : "''", sn);
 275
 276   FREE (t);
 277 }
 278
 279 static int
 280 display_traps (list)
 281      WORD_LIST *list;
 282 {
 283   int result, i;
 284
 285   if (list == 0)
 286     {
 287       for (i = 0; i < BASH_NSIG; i++)
 288         showtrap (i);
 289       return (EXECUTION_SUCCESS);
 290     }
 291
 292   for (result = EXECUTION_SUCCESS; list; list = list->next)
 293     {
 294       i = decode_signal (list->word->word, DSIG_NOCASE|DSIG_SIGPREFIX);
 295       if (i == NO_SIG)
 296         {
 297           sh_invalidsig (list->word->word);
 298           result = EXECUTION_FAILURE;
 299         }
 300       else
 301         showtrap (i);
 302     }
 303
 304   return (result);
 305 }