builtins/kill.def

   1 This file is kill.def, from which is created kill.c.
   2 It implements the builtin "kill" in Bash.
   3
   4 Copyright (C) 1987-2009 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 kill.c
  22
  23 $BUILTIN kill
  24 $FUNCTION kill_builtin
  25 $SHORT_DOC kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]
  26 Send a signal to a job.
  27
  28 Send the processes identified by PID or JOBSPEC the signal named by
  29 SIGSPEC or SIGNUM.  If neither SIGSPEC nor SIGNUM is present, then
  30 SIGTERM is assumed.
  31
  32 Options:
  33   -s sig        SIG is a signal name
  34   -n sig        SIG is a signal number
  35   -l    list the signal names; if arguments follow `-l' they are
  36         assumed to be signal numbers for which names should be listed
  37
  38 Kill is a shell builtin for two reasons: it allows job IDs to be used
  39 instead of process IDs, and allows processes to be killed if the limit
  40 on processes that you can create is reached.
  41
  42 Exit Status:
  43 Returns success unless an invalid option is given or an error occurs.
  44 $END
  45
  46 #include <config.h>
  47
  48 #include <stdio.h>
  49 #include <errno.h>
  50 #if defined (HAVE_UNISTD_H)
  51 #  ifdef _MINIX
  52 #    include <sys/types.h>
  53 #  endif
  54 #  include <unistd.h>
  55 #endif
  56
  57 #include "../bashansi.h"
  58 #include "../bashintl.h"
  59
  60 #include "../shell.h"
  61 #include "../trap.h"
  62 #include "../jobs.h"
  63 #include "common.h"
  64
  65 /* Not all systems declare ERRNO in errno.h... and some systems #define it! */
  66 #if !defined (errno)
  67 extern int errno;
  68 #endif /* !errno */
  69
  70 extern int posixly_correct;
  71
  72 static void kill_error __P((pid_t, int));
  73
  74 #if !defined (CONTINUE_AFTER_KILL_ERROR)
  75 #  define CONTINUE_OR_FAIL return (EXECUTION_FAILURE)
  76 #else
  77 #  define CONTINUE_OR_FAIL goto continue_killing
  78 #endif /* CONTINUE_AFTER_KILL_ERROR */
  79
  80 /* Here is the kill builtin.  We only have it so that people can type
  81    kill -KILL %1?  No, if you fill up the process table this way you
  82    can still kill some. */
  83 int
  84 kill_builtin (list)
  85      WORD_LIST *list;
  86 {
  87   int sig, any_succeeded, listing, saw_signal, dflags;
  88   char *sigspec, *word;
  89   pid_t pid;
  90   intmax_t pid_value;
  91
  92   if (list == 0)
  93     {
  94       builtin_usage ();
  95       return (EXECUTION_FAILURE);
  96     }
  97
  98   any_succeeded = listing = saw_signal = 0;
  99   sig = SIGTERM;
 100   sigspec = "TERM";
 101
 102   dflags = DSIG_NOCASE | ((posixly_correct == 0) ? DSIG_SIGPREFIX : 0);
 103   /* Process options. */
 104   while (list)
 105     {
 106       word = list->word->word;
 107
 108       if (ISOPTION (word, 'l'))
 109         {
 110           listing++;
 111           list = list->next;
 112         }
 113       else if (ISOPTION (word, 's') || ISOPTION (word, 'n'))
 114         {
 115           list = list->next;
 116           if (list)
 117             {
 118               sigspec = list->word->word;
 119               if (sigspec[0] == '0' && sigspec[1] == '\0')
 120                 sig = 0;
 121               else
 122                 sig = decode_signal (sigspec, dflags);
 123               list = list->next;
 124 #if 0
 125               saw_signal++;     /* XXX - for bash-4.2 */
 126 #endif
 127             }
 128           else
 129             {
 130               sh_needarg (word);
 131               return (EXECUTION_FAILURE);
 132             }
 133         }
 134       else if (ISOPTION (word, '-'))
 135         {
 136           list = list->next;
 137           break;
 138         }
 139       else if (ISOPTION (word, '?'))
 140         {
 141           builtin_usage ();
 142           return (EXECUTION_SUCCESS);
 143         }
 144       /* If this is a signal specification then process it.  We only process
 145          the first one seen; other arguments may signify process groups (e.g,
 146          -num == process group num). */
 147       else if (*word == '-' && saw_signal == 0)
 148         {
 149           sigspec = word + 1;
 150           sig = decode_signal (sigspec, dflags);
 151           saw_signal++;
 152           list = list->next;
 153         }
 154       else
 155         break;
 156     }
 157
 158   if (listing)
 159     return (display_signal_list (list, 0));
 160
 161   /* OK, we are killing processes. */
 162   if (sig == NO_SIG)
 163     {
 164       sh_invalidsig (sigspec);
 165       return (EXECUTION_FAILURE);
 166     }
 167
 168   if (list == 0)
 169     {
 170       builtin_usage ();
 171       return (EXECUTION_FAILURE);
 172     }
 173
 174   while (list)
 175     {
 176       word = list->word->word;
 177
 178       if (*word == '-')
 179         word++;
 180
 181       /* Use the entire argument in case of minus sign presence. */
 182       if (*word && legal_number (list->word->word, &pid_value) && (pid_value == (pid_t)pid_value))
 183         {
 184           pid = (pid_t) pid_value;
 185
 186           if (kill_pid (pid, sig, pid < -1) < 0)
 187             {
 188               if (errno == EINVAL)
 189                 sh_invalidsig (sigspec);
 190               else
 191                 kill_error (pid, errno);
 192               CONTINUE_OR_FAIL;
 193             }
 194           else
 195             any_succeeded++;
 196         }
 197 #if defined (JOB_CONTROL)
 198       else if (*list->word->word && *list->word->word != '%')
 199         {
 200           builtin_error (_("%s: arguments must be process or job IDs"), list->word->word);
 201           CONTINUE_OR_FAIL;
 202         }
 203       else if (*word)
 204         /* Posix.2 says you can kill without job control active (4.32.4) */
 205         {                       /* Must be a job spec.  Check it out. */
 206           int job;
 207           sigset_t set, oset;
 208           JOB *j;
 209
 210           BLOCK_CHILD (set, oset);
 211           job = get_job_spec (list);
 212
 213           if (INVALID_JOB (job))
 214             {
 215               if (job != DUP_JOB)
 216                 sh_badjob (list->word->word);
 217               UNBLOCK_CHILD (oset);
 218               CONTINUE_OR_FAIL;
 219             }
 220
 221           j = get_job_by_jid (job);
 222           /* Job spec used.  Kill the process group. If the job was started
 223              without job control, then its pgrp == shell_pgrp, so we have
 224              to be careful.  We take the pid of the first job in the pipeline
 225              in that case. */
 226           pid = IS_JOBCONTROL (job) ? j->pgrp : j->pipe->pid;
 227
 228           UNBLOCK_CHILD (oset);
 229
 230           if (kill_pid (pid, sig, 1) < 0)
 231             {
 232               if (errno == EINVAL)
 233                 sh_invalidsig (sigspec);
 234               else
 235                 kill_error (pid, errno);
 236               CONTINUE_OR_FAIL;
 237             }
 238           else
 239             any_succeeded++;
 240         }
 241 #endif /* !JOB_CONTROL */
 242       else
 243         {
 244           sh_badpid (list->word->word);
 245           CONTINUE_OR_FAIL;
 246         }
 247     continue_killing:
 248       list = list->next;
 249     }
 250
 251   return (any_succeeded ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
 252 }
 253
 254 static void
 255 kill_error (pid, e)
 256      pid_t pid;
 257      int e;
 258 {
 259   char *x;
 260
 261   x = strerror (e);
 262   if (x == 0)
 263     x = _("Unknown error");
 264   builtin_error ("(%ld) - %s", (long)pid, x);
 265 }