misc-utils/kill.c

   1 /*
   2  * Copyright (c) 1988, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 /*
  34  *  oct 5 1994 -- almost entirely re-written to allow for process names.
  35  *  modifications (c) salvatore valente <svalente@mit.edu>
  36  *  may be used / modified / distributed under the same terms as the original.
  37  *
  38  *  1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
  39  *  - added Native Language Support
  40  *
  41  *  1999-11-13 aeb Accept signal numbers 128+s.
  42  *
  43  * Copyright (C) 2014 Sami Kerola <kerolasa@iki.fi>
  44  * Copyright (C) 2014 Karel Zak <kzak@redhat.com>
  45  */
  46
  47 #include <ctype.h>              /* for isdigit() */
  48 #include <signal.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 #include "c.h"
  55 #include "closestream.h"
  56 #include "nls.h"
  57 #include "procutils.h"
  58 #include "strutils.h"
  59 #include "ttyutils.h"
  60 #include "xalloc.h"
  61
  62 /* partial success, otherwise we return regular EXIT_{SUCCESS,FAILURE} */
  63 #define KILL_EXIT_SOMEOK        64
  64
  65 enum {
  66         KILL_FIELD_WIDTH = 11,
  67         KILL_OUTPUT_WIDTH = 72
  68 };
  69
  70 struct kill_control {
  71         char *arg;
  72         pid_t pid;
  73         int numsig;
  74 #ifdef HAVE_SIGQUEUE
  75         union sigval sigdata;
  76 #endif
  77         unsigned int
  78                 check_all:1,
  79                 do_kill:1,
  80                 do_pid:1,
  81                 use_sigval:1,
  82                 verbose:1;
  83 };
  84
  85 static const struct signv {
  86         const char *name;
  87         int val;
  88 } sys_signame[] = {
  89         /* POSIX signals */
  90         { "HUP",        SIGHUP },       /* 1 */
  91         { "INT",        SIGINT },       /* 2 */
  92         { "QUIT",       SIGQUIT },      /* 3 */
  93         { "ILL",        SIGILL },       /* 4 */
  94 #ifdef SIGTRAP
  95         { "TRAP",       SIGTRAP },      /* 5 */
  96 #endif
  97         { "ABRT",       SIGABRT },      /* 6 */
  98 #ifdef SIGIOT
  99         { "IOT",        SIGIOT },       /* 6, same as SIGABRT */
 100 #endif
 101 #ifdef SIGEMT
 102         { "EMT",        SIGEMT },       /* 7 (mips,alpha,sparc*) */
 103 #endif
 104 #ifdef SIGBUS
 105         { "BUS",        SIGBUS },       /* 7 (arm,i386,m68k,ppc), 10 (mips,alpha,sparc*) */
 106 #endif
 107         { "FPE",        SIGFPE },       /* 8 */
 108         { "KILL",       SIGKILL },      /* 9 */
 109         { "USR1",       SIGUSR1 },      /* 10 (arm,i386,m68k,ppc), 30 (alpha,sparc*), 16 (mips) */
 110         { "SEGV",       SIGSEGV },      /* 11 */
 111         { "USR2",       SIGUSR2 },      /* 12 (arm,i386,m68k,ppc), 31 (alpha,sparc*), 17 (mips) */
 112         { "PIPE",       SIGPIPE },      /* 13 */
 113         { "ALRM",       SIGALRM },      /* 14 */
 114         { "TERM",       SIGTERM },      /* 15 */
 115 #ifdef SIGSTKFLT
 116         { "STKFLT",     SIGSTKFLT },    /* 16 (arm,i386,m68k,ppc) */
 117 #endif
 118         { "CHLD",       SIGCHLD },      /* 17 (arm,i386,m68k,ppc), 20 (alpha,sparc*), 18 (mips) */
 119 #ifdef SIGCLD
 120         { "CLD",        SIGCLD },       /* same as SIGCHLD (mips) */
 121 #endif
 122         { "CONT",       SIGCONT },      /* 18 (arm,i386,m68k,ppc), 19 (alpha,sparc*), 25 (mips) */
 123         { "STOP",       SIGSTOP },      /* 19 (arm,i386,m68k,ppc), 17 (alpha,sparc*), 23 (mips) */
 124         { "TSTP",       SIGTSTP },      /* 20 (arm,i386,m68k,ppc), 18 (alpha,sparc*), 24 (mips) */
 125         { "TTIN",       SIGTTIN },      /* 21 (arm,i386,m68k,ppc,alpha,sparc*), 26 (mips) */
 126         { "TTOU",       SIGTTOU },      /* 22 (arm,i386,m68k,ppc,alpha,sparc*), 27 (mips) */
 127 #ifdef SIGURG
 128         { "URG",        SIGURG },       /* 23 (arm,i386,m68k,ppc), 16 (alpha,sparc*), 21 (mips) */
 129 #endif
 130 #ifdef SIGXCPU
 131         { "XCPU",       SIGXCPU },      /* 24 (arm,i386,m68k,ppc,alpha,sparc*), 30 (mips) */
 132 #endif
 133 #ifdef SIGXFSZ
 134         { "XFSZ",       SIGXFSZ },      /* 25 (arm,i386,m68k,ppc,alpha,sparc*), 31 (mips) */
 135 #endif
 136 #ifdef SIGVTALRM
 137         { "VTALRM",     SIGVTALRM },    /* 26 (arm,i386,m68k,ppc,alpha,sparc*), 28 (mips) */
 138 #endif
 139 #ifdef SIGPROF
 140         { "PROF",       SIGPROF },      /* 27 (arm,i386,m68k,ppc,alpha,sparc*), 29 (mips) */
 141 #endif
 142 #ifdef SIGWINCH
 143         { "WINCH",      SIGWINCH },     /* 28 (arm,i386,m68k,ppc,alpha,sparc*), 20 (mips) */
 144 #endif
 145 #ifdef SIGIO
 146         { "IO",         SIGIO },        /* 29 (arm,i386,m68k,ppc), 23 (alpha,sparc*), 22 (mips) */
 147 #endif
 148 #ifdef SIGPOLL
 149         { "POLL",       SIGPOLL },      /* same as SIGIO */
 150 #endif
 151 #ifdef SIGINFO
 152         { "INFO",       SIGINFO },      /* 29 (alpha) */
 153 #endif
 154 #ifdef SIGLOST
 155         { "LOST",       SIGLOST },      /* 29 (arm,i386,m68k,ppc,sparc*) */
 156 #endif
 157 #ifdef SIGPWR
 158         { "PWR",        SIGPWR },       /* 30 (arm,i386,m68k,ppc), 29 (alpha,sparc*), 19 (mips) */
 159 #endif
 160 #ifdef SIGUNUSED
 161         { "UNUSED",     SIGUNUSED },    /* 31 (arm,i386,m68k,ppc) */
 162 #endif
 163 #ifdef SIGSYS
 164         { "SYS",        SIGSYS },       /* 31 (mips,alpha,sparc*) */
 165 #endif
 166 };
 167
 168 static void print_signal_name(int signum)
 169 {
 170         size_t n;
 171
 172         for (n = 0; n < ARRAY_SIZE(sys_signame); n++) {
 173                 if (sys_signame[n].val == signum) {
 174                         printf("%s\n", sys_signame[n].name);
 175                         return;
 176                 }
 177         }
 178 #ifdef SIGRTMIN
 179         if (SIGRTMIN <= signum && signum <= SIGRTMAX) {
 180                 printf("RT%d\n", signum - SIGRTMIN);
 181                 return;
 182         }
 183 #endif
 184         printf("%d\n", signum);
 185 }
 186
 187 static void pretty_print_signal(FILE *fp, size_t term_width, size_t *lpos,
 188                                 int signum, const char *name)
 189 {
 190         if (term_width < (*lpos + KILL_FIELD_WIDTH)) {
 191                 fputc('\n', fp);
 192                 *lpos = 0;
 193         }
 194         *lpos += KILL_FIELD_WIDTH;
 195         fprintf(fp, "%2d %-8s", signum, name);
 196 }
 197
 198 static void print_all_signals(FILE *fp, int pretty)
 199 {
 200         size_t n, lth, lpos = 0, width;
 201
 202         if (!pretty) {
 203                 for (n = 0; n < ARRAY_SIZE(sys_signame); n++) {
 204                         lth = 1 + strlen(sys_signame[n].name);
 205                         if (KILL_OUTPUT_WIDTH < lpos + lth) {
 206                                 fputc('\n', fp);
 207                                 lpos = 0;
 208                         } else if (lpos)
 209                                 fputc(' ', fp);
 210                         lpos += lth;
 211                         fputs(sys_signame[n].name, fp);
 212                 }
 213 #ifdef SIGRTMIN
 214                 fputs(" RT<N> RTMIN+<N> RTMAX-<N>", fp);
 215 #endif
 216                 fputc('\n', fp);
 217                 return;
 218         }
 219
 220         /* pretty print */
 221         width = get_terminal_width(KILL_OUTPUT_WIDTH + 1) - 1;
 222         for (n = 0; n < ARRAY_SIZE(sys_signame); n++)
 223                 pretty_print_signal(fp, width, &lpos,
 224                                     sys_signame[n].val, sys_signame[n].name);
 225 #ifdef SIGRTMIN
 226         pretty_print_signal(fp, width, &lpos, SIGRTMIN, "RTMIN");
 227         pretty_print_signal(fp, width, &lpos, SIGRTMAX, "RTMAX");
 228 #endif
 229         fputc('\n', fp);
 230 }
 231
 232 static void err_nosig(char *name)
 233 {
 234         warnx(_("unknown signal %s; valid signals:"), name);
 235         print_all_signals(stderr, 1);
 236         exit(EXIT_FAILURE);
 237 }
 238
 239 #ifdef SIGRTMIN
 240 static int rtsig_to_signum(char *sig)
 241 {
 242         int num, maxi = 0;
 243         char *ep = NULL;
 244
 245         if (strncasecmp(sig, "min+", 4) == 0)
 246                 sig += 4;
 247         else if (strncasecmp(sig, "max-", 4) == 0) {
 248                 sig += 4;
 249                 maxi = 1;
 250         }
 251         if (!isdigit(*sig))
 252                 return -1;
 253         errno = 0;
 254         num = strtol(sig, &ep, 10);
 255         if (!ep || sig == ep || errno || num < 0)
 256                 return -1;
 257         num = maxi ? SIGRTMAX - num : SIGRTMIN + num;
 258         if (num < SIGRTMIN || SIGRTMAX < num)
 259                 return -1;
 260         return num;
 261 }
 262 #endif
 263
 264 static int signame_to_signum(char *sig)
 265 {
 266         size_t n;
 267
 268         if (!strncasecmp(sig, "sig", 3))
 269                 sig += 3;
 270 #ifdef SIGRTMIN
 271         /* RT signals */
 272         if (!strncasecmp(sig, "rt", 2))
 273                 return rtsig_to_signum(sig + 2);
 274 #endif
 275         /* Normal signals */
 276         for (n = 0; n < ARRAY_SIZE(sys_signame); n++) {
 277                 if (!strcasecmp(sys_signame[n].name, sig))
 278                         return sys_signame[n].val;
 279         }
 280         return -1;
 281 }
 282
 283 static int arg_to_signum(char *arg, int maskbit)
 284 {
 285         int numsig;
 286         char *ep;
 287
 288         if (isdigit(*arg)) {
 289                 numsig = strtol(arg, &ep, 10);
 290                 if (NSIG <= numsig && maskbit && (numsig & 128) != 0)
 291                         numsig -= 128;
 292                 if (*ep != 0 || numsig < 0 || NSIG <= numsig)
 293                         return -1;
 294                 return numsig;
 295         }
 296         return signame_to_signum(arg);
 297 }
 298
 299 static void __attribute__((__noreturn__)) usage(void)
 300 {
 301         FILE *out = stdout;
 302         fputs(USAGE_HEADER, out);
 303         fprintf(out, _(" %s [options] <pid>|<name>...\n"), program_invocation_short_name);
 304
 305         fputs(USAGE_SEPARATOR, out);
 306         fputs(_("Forcibly terminate a process.\n"), out);
 307
 308         fputs(USAGE_OPTIONS, out);
 309         fputs(_(" -a, --all              do not restrict the name-to-pid conversion to processes\n"
 310                 "                          with the same uid as the present process\n"), out);
 311         fputs(_(" -s, --signal <signal>  send this <signal> instead of SIGTERM\n"), out);
 312 #ifdef HAVE_SIGQUEUE
 313         fputs(_(" -q, --queue <value>    use sigqueue(2), not kill(2), and pass <value> as data\n"), out);
 314 #endif
 315         fputs(_(" -p, --pid              print pids without signaling them\n"), out);
 316         fputs(_(" -l, --list[=<signal>]  list signal names, or convert a signal number to a name\n"), out);
 317         fputs(_(" -L, --table            list signal names and numbers\n"), out);
 318         fputs(_("     --verbose          print pids that will be signaled\n"), out);
 319
 320         fputs(USAGE_SEPARATOR, out);
 321         print_usage_help_options(24);
 322         fprintf(out, USAGE_MAN_TAIL("kill(1)"));
 323
 324         exit(EXIT_SUCCESS);
 325 }
 326
 327 static char **parse_arguments(int argc, char **argv, struct kill_control *ctl)
 328 {
 329         char *arg;
 330
 331         /* Loop through the arguments.  Actually, -a is the only option
 332          * can be used with other options.  The 'kill' is basically a
 333          * one-option-at-most program. */
 334         for (argc--, argv++; 0 < argc; argc--, argv++) {
 335                 arg = *argv;
 336                 if (*arg != '-')
 337                         break;
 338                 if (!strcmp(arg, "--")) {
 339                         argc--, argv++;
 340                         break;
 341                 }
 342                 if (!strcmp(arg, "-v") || !strcmp(arg, "-V") ||
 343                     !strcmp(arg, "--version")) {
 344                         printf(UTIL_LINUX_VERSION);
 345                         exit(EXIT_SUCCESS);
 346                 }
 347                 if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
 348                         usage();
 349                 if (!strcmp(arg, "--verbose")) {
 350                         ctl->verbose = 1;
 351                         continue;
 352                 }
 353                 if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
 354                         ctl->check_all = 1;
 355                         continue;
 356                 }
 357                 if (!strcmp(arg, "-l") || !strcmp(arg, "--list")) {
 358                         if (argc < 2) {
 359                                 print_all_signals(stdout, 0);
 360                                 exit(EXIT_SUCCESS);
 361                         }
 362                         if (2 < argc)
 363                                 errx(EXIT_FAILURE, _("too many arguments"));
 364                         /* argc == 2, accept "kill -l $?" */
 365                         arg = argv[1];
 366                         if ((ctl->numsig = arg_to_signum(arg, 1)) < 0)
 367                                 errx(EXIT_FAILURE, _("unknown signal: %s"),
 368                                      arg);
 369                         print_signal_name(ctl->numsig);
 370                         exit(EXIT_SUCCESS);
 371                 }
 372                 /* for compatibility with procps kill(1) */
 373                 if (!strncmp(arg, "--list=", 7) || !strncmp(arg, "-l=", 3)) {
 374                         char *p = strchr(arg, '=') + 1;
 375                         if ((ctl->numsig = arg_to_signum(p, 1)) < 0)
 376                                 errx(EXIT_FAILURE, _("unknown signal: %s"), p);
 377                         print_signal_name(ctl->numsig);
 378                         exit(EXIT_SUCCESS);
 379                 }
 380                 if (!strcmp(arg, "-L") || !strcmp(arg, "--table")) {
 381                         print_all_signals(stdout, 1);
 382                         exit(EXIT_SUCCESS);
 383                 }
 384                 if (!strcmp(arg, "-p") || !strcmp(arg, "--pid")) {
 385                         ctl->do_pid = 1;
 386                         if (ctl->do_kill)
 387                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
 388 #ifdef HAVE_SIGQUEUE
 389                         if (ctl->use_sigval)
 390                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
 391 #endif
 392                         continue;
 393                 }
 394                 if (!strcmp(arg, "-s") || !strcmp(arg, "--signal")) {
 395                         if (argc < 2)
 396                                 errx(EXIT_FAILURE, _("not enough arguments"));
 397                         ctl->do_kill = 1;
 398                         if (ctl->do_pid)
 399                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
 400                         argc--, argv++;
 401                         arg = *argv;
 402                         if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
 403                                 err_nosig(arg);
 404                         continue;
 405                 }
 406 #ifdef HAVE_SIGQUEUE
 407                 if (!strcmp(arg, "-q") || !strcmp(arg, "--queue")) {
 408                         if (argc < 2)
 409                                 errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
 410                         if (ctl->do_pid)
 411                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
 412                         argc--, argv++;
 413                         arg = *argv;
 414                         ctl->sigdata.sival_int = strtos32_or_err(arg, _("argument error"));
 415                         ctl->use_sigval = 1;
 416                         continue;
 417                 }
 418 #endif
 419                 /* 'arg' begins with a dash but is not a known option.
 420                  * So it's probably something like -HUP, or -1/-n try to
 421                  * deal with it.
 422                  *
 423                  * -n could be either signal n or pid -n (a process group
 424                  * number).  In case of doubt, POSIX tells us to assume a
 425                  * signal.  But if a signal has already been parsed, then
 426                  * assume it is a process group, so stop parsing options. */
 427                 if (ctl->do_kill)
 428                         break;
 429                 arg++;
 430                 if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
 431                         errx(EXIT_FAILURE, _("invalid signal name or number: %s"), arg);
 432                 ctl->do_kill = 1;
 433                 if (ctl->do_pid)
 434                         errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
 435                 continue;
 436         }
 437         if (!*argv)
 438                 errx(EXIT_FAILURE, _("not enough arguments"));
 439         return argv;
 440 }
 441
 442
 443 static int kill_verbose(const struct kill_control *ctl)
 444 {
 445         int rc = 0;
 446
 447         if (ctl->verbose)
 448                 printf(_("sending signal %d to pid %d\n"), ctl->numsig, ctl->pid);
 449         if (ctl->do_pid) {
 450                 printf("%ld\n", (long) ctl->pid);
 451                 return 0;
 452         }
 453 #ifdef HAVE_SIGQUEUE
 454         if (ctl->use_sigval)
 455                 rc = sigqueue(ctl->pid, ctl->numsig, ctl->sigdata);
 456         else
 457 #endif
 458                 rc = kill(ctl->pid, ctl->numsig);
 459
 460         if (rc < 0)
 461                 warn(_("sending signal to %s failed"), ctl->arg);
 462         return rc;
 463 }
 464
 465 int main(int argc, char **argv)
 466 {
 467         struct kill_control ctl = { .numsig = SIGTERM };
 468         int nerrs = 0, ct = 0;
 469
 470         setlocale(LC_ALL, "");
 471         bindtextdomain(PACKAGE, LOCALEDIR);
 472         textdomain(PACKAGE);
 473         atexit(close_stdout);
 474
 475         argv = parse_arguments(argc, argv, &ctl);
 476
 477         /* The rest of the arguments should be process ids and names. */
 478         for ( ; (ctl.arg = *argv) != NULL; argv++) {
 479                 char *ep = NULL;
 480
 481                 errno = 0;
 482                 ctl.pid = strtol(ctl.arg, &ep, 10);
 483                 if (errno == 0 && ep && *ep == '\0' && ctl.arg < ep) {
 484                         if (kill_verbose(&ctl) != 0)
 485                                 nerrs++;
 486                         ct++;
 487                 } else {
 488                         struct proc_processes *ps = proc_open_processes();
 489                         int found = 0;
 490
 491                         if (!ps)
 492                                 continue;
 493                         if (!ctl.check_all)
 494                                 proc_processes_filter_by_uid(ps, getuid());
 495
 496                         proc_processes_filter_by_name(ps, ctl.arg);
 497                         while (proc_next_pid(ps, &ctl.pid) == 0) {
 498                                 if (kill_verbose(&ctl) != 0)
 499                                         nerrs++;
 500                                 ct++;
 501                                 found = 1;
 502                         }
 503                         proc_close_processes(ps);
 504
 505                         if (!found) {
 506                                 nerrs++, ct++;
 507                                 warnx(_("cannot find process \"%s\""), ctl.arg);
 508                         }
 509                 }
 510         }
 511
 512         if (ct && nerrs == 0)
 513                 return EXIT_SUCCESS;    /* full success */
 514         else if (ct == nerrs)
 515                 return EXIT_FAILURE;    /* all failed */
 516
 517         return KILL_EXIT_SOMEOK;        /* partial success */
 518 }
 519