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-2010 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               saw_signal++;
 125             }
 126           else
 127             {
 128               sh_needarg (word);
 129               return (EXECUTION_FAILURE);
 130             }
 131         }
 132       else if (ISOPTION (word, '-'))
 133         {
 134           list = list->next;
 135           break;
 136         }
 137       else if (ISOPTION (word, '?'))
 138         {
 139           builtin_usage ();
 140           return (EXECUTION_SUCCESS);
 141         }
 142       /* If this is a signal specification then process it.  We only process
 143          the first one seen; other arguments may signify process groups (e.g,
 144          -num == process group num). */
 145       else if (*word == '-' && saw_signal == 0)
 146         {
 147           sigspec = word + 1;
 148           sig = decode_signal (sigspec, dflags);
 149           saw_signal++;
 150           list = list->next;
 151         }
 152       else
 153         break;
 154     }
 155
 156   if (listing)
 157     return (display_signal_list (list, 0));
 158
 159   /* OK, we are killing processes. */
 160   if (sig == NO_SIG)
 161     {
 162       sh_invalidsig (sigspec);
 163       return (EXECUTION_FAILURE);
 164     }
 165
 166   if (list == 0)
 167     {
 168       builtin_usage ();
 169       return (EXECUTION_FAILURE);
 170     }
 171
 172   while (list)
 173     {
 174       word = list->word->word;
 175
 176       if (*word == '-')
 177         word++;
 178
 179       /* Use the entire argument in case of minus sign presence. */
 180       if (*word && legal_number (list->word->word, &pid_value) && (pid_value == (pid_t)pid_value))
 181         {
 182           pid = (pid_t) pid_value;
 183
 184           if (kill_pid (pid, sig, pid < -1) < 0)
 185             {
 186               if (errno == EINVAL)
 187                 sh_invalidsig (sigspec);
 188               else
 189                 kill_error (pid, errno);
 190               CONTINUE_OR_FAIL;
 191             }
 192           else
 193             any_succeeded++;
 194         }
 195 #if defined (JOB_CONTROL)
 196       else if (*list->word->word && *list->word->word != '%')
 197         {
 198           builtin_error (_("%s: arguments must be process or job IDs"), list->word->word);
 199           CONTINUE_OR_FAIL;
 200         }
 201       else if (*word)
 202         /* Posix.2 says you can kill without job control active (4.32.4) */
 203         {                       /* Must be a job spec.  Check it out. */
 204           int job;
 205           sigset_t set, oset;
 206           JOB *j;
 207
 208           BLOCK_CHILD (set, oset);
 209           job = get_job_spec (list);
 210
 211           if (INVALID_JOB (job))
 212             {
 213               if (job != DUP_JOB)
 214                 sh_badjob (list->word->word);
 215               UNBLOCK_CHILD (oset);
 216               CONTINUE_OR_FAIL;
 217             }
 218
 219           j = get_job_by_jid (job);
 220           /* Job spec used.  Kill the process group. If the job was started
 221              without job control, then its pgrp == shell_pgrp, so we have
 222              to be careful.  We take the pid of the first job in the pipeline
 223              in that case. */
 224           pid = IS_JOBCONTROL (job) ? j->pgrp : j->pipe->pid;
 225
 226           UNBLOCK_CHILD (oset);
 227
 228           if (kill_pid (pid, sig, 1) < 0)
 229             {
 230               if (errno == EINVAL)
 231                 sh_invalidsig (sigspec);
 232               else
 233                 kill_error (pid, errno);
 234               CONTINUE_OR_FAIL;
 235             }
 236           else
 237             any_succeeded++;
 238         }
 239 #endif /* !JOB_CONTROL */
 240       else
 241         {
 242           sh_badpid (list->word->word);
 243           CONTINUE_OR_FAIL;
 244         }
 245     continue_killing:
 246       list = list->next;
 247     }
 248
 249   return (any_succeeded ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
 250 }
 251
 252 static void
 253 kill_error (pid, e)
 254      pid_t pid;
 255      int e;
 256 {
 257   char *x;
 258
 259   x = strerror (e);
 260   if (x == 0)
 261     x = _("Unknown error");
 262   builtin_error ("(%ld) - %s", (long)pid, x);
 263 }