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 "pidfd-utils.h"
  58 #include "procutils.h"
  59 #include "signames.h"
  60 #include "strutils.h"
  61 #include "ttyutils.h"
  62 #include "xalloc.h"
  63
  64 /* partial success, otherwise we return regular EXIT_{SUCCESS,FAILURE} */
  65 #define KILL_EXIT_SOMEOK        64
  66
  67 enum {
  68         KILL_FIELD_WIDTH = 11,
  69         KILL_OUTPUT_WIDTH = 72
  70 };
  71
  72 #ifdef UL_HAVE_PIDFD
  73 # include <poll.h>
  74 # include "list.h"
  75 struct timeouts {
  76         int period;
  77         int sig;
  78         struct list_head follow_ups;
  79 };
  80 #endif
  81
  82 struct kill_control {
  83         char *arg;
  84         pid_t pid;
  85         int numsig;
  86 #ifdef HAVE_SIGQUEUE
  87         union sigval sigdata;
  88 #endif
  89 #ifdef UL_HAVE_PIDFD
  90         struct list_head follow_ups;
  91 #endif
  92         unsigned int
  93                 check_all:1,
  94                 do_kill:1,
  95                 do_pid:1,
  96                 use_sigval:1,
  97 #ifdef UL_HAVE_PIDFD
  98                 timeout:1,
  99 #endif
 100                 verbose:1;
 101 };
 102
 103 static void print_signal_name(int signum)
 104 {
 105         const char *name = signum_to_signame(signum);
 106
 107         if (name) {
 108                 printf("%s\n", name);
 109                 return;
 110         }
 111 #ifdef SIGRTMIN
 112         if (SIGRTMIN <= signum && signum <= SIGRTMAX) {
 113                 printf("RT%d\n", signum - SIGRTMIN);
 114                 return;
 115         }
 116 #endif
 117         printf("%d\n", signum);
 118 }
 119
 120 static void pretty_print_signal(FILE *fp, size_t term_width, size_t *lpos,
 121                                 int signum, const char *name)
 122 {
 123         if (term_width < (*lpos + KILL_FIELD_WIDTH)) {
 124                 fputc('\n', fp);
 125                 *lpos = 0;
 126         }
 127         *lpos += KILL_FIELD_WIDTH;
 128         fprintf(fp, "%2d %-8s", signum, name);
 129 }
 130
 131 static void print_all_signals(FILE *fp, int pretty)
 132 {
 133         size_t n, lth, lpos = 0, width;
 134         const char *signame = NULL;
 135         int signum = 0;
 136
 137         if (!pretty) {
 138                 for (n = 0; get_signame_by_idx(n, &signame, NULL) == 0; n++) {
 139                         lth = 1 + strlen(signame);
 140                         if (KILL_OUTPUT_WIDTH < lpos + lth) {
 141                                 fputc('\n', fp);
 142                                 lpos = 0;
 143                         } else if (lpos)
 144                                 fputc(' ', fp);
 145                         lpos += lth;
 146                         fputs(signame, fp);
 147                 }
 148 #ifdef SIGRTMIN
 149                 fputs(" RT<N> RTMIN+<N> RTMAX-<N>", fp);
 150 #endif
 151                 fputc('\n', fp);
 152                 return;
 153         }
 154
 155         /* pretty print */
 156         width = get_terminal_width(KILL_OUTPUT_WIDTH + 1) - 1;
 157         for (n = 0; get_signame_by_idx(n, &signame, &signum) == 0; n++)
 158                 pretty_print_signal(fp, width, &lpos, signum, signame);
 159 #ifdef SIGRTMIN
 160         pretty_print_signal(fp, width, &lpos, SIGRTMIN, "RTMIN");
 161         pretty_print_signal(fp, width, &lpos, SIGRTMAX, "RTMAX");
 162 #endif
 163         fputc('\n', fp);
 164 }
 165
 166 static void err_nosig(char *name)
 167 {
 168         warnx(_("unknown signal %s; valid signals:"), name);
 169         print_all_signals(stderr, 1);
 170         exit(EXIT_FAILURE);
 171 }
 172
 173 static int arg_to_signum(char *arg, int maskbit)
 174 {
 175         int numsig;
 176         char *ep;
 177
 178         if (isdigit(*arg)) {
 179                 numsig = strtol(arg, &ep, 10);
 180                 if (NSIG <= numsig && maskbit && (numsig & 128) != 0)
 181                         numsig -= 128;
 182                 if (*ep != 0 || numsig < 0 || NSIG <= numsig)
 183                         return -1;
 184                 return numsig;
 185         }
 186         return signame_to_signum(arg);
 187 }
 188
 189 static void __attribute__((__noreturn__)) usage(void)
 190 {
 191         FILE *out = stdout;
 192         fputs(USAGE_HEADER, out);
 193         fprintf(out, _(" %s [options] <pid>|<name>...\n"), program_invocation_short_name);
 194
 195         fputs(USAGE_SEPARATOR, out);
 196         fputs(_("Forcibly terminate a process.\n"), out);
 197
 198         fputs(USAGE_OPTIONS, out);
 199         fputs(_(" -a, --all              do not restrict the name-to-pid conversion to processes\n"
 200                 "                          with the same uid as the present process\n"), out);
 201         fputs(_(" -s, --signal <signal>  send this <signal> instead of SIGTERM\n"), out);
 202 #ifdef HAVE_SIGQUEUE
 203         fputs(_(" -q, --queue <value>    use sigqueue(2), not kill(2), and pass <value> as data\n"), out);
 204 #endif
 205 #ifdef UL_HAVE_PIDFD
 206         fputs(_("     --timeout <milliseconds> <follow-up signal>\n"
 207                 "                        wait up to timeout and send follow-up signal\n"), out);
 208 #endif
 209         fputs(_(" -p, --pid              print pids without signaling them\n"), out);
 210         fputs(_(" -l, --list[=<signal>]  list signal names, or convert a signal number to a name\n"), out);
 211         fputs(_(" -L, --table            list signal names and numbers\n"), out);
 212         fputs(_("     --verbose          print pids that will be signaled\n"), out);
 213
 214         fputs(USAGE_SEPARATOR, out);
 215         printf(USAGE_HELP_OPTIONS(24));
 216         printf(USAGE_MAN_TAIL("kill(1)"));
 217
 218         exit(EXIT_SUCCESS);
 219 }
 220
 221 static char **parse_arguments(int argc, char **argv, struct kill_control *ctl)
 222 {
 223         char *arg;
 224
 225         /* Loop through the arguments.  Actually, -a is the only option
 226          * can be used with other options.  The 'kill' is basically a
 227          * one-option-at-most program. */
 228         for (argc--, argv++; 0 < argc; argc--, argv++) {
 229                 arg = *argv;
 230                 if (*arg != '-')
 231                         break;
 232                 if (!strcmp(arg, "--")) {
 233                         argc--, argv++;
 234                         break;
 235                 }
 236                 if (!strcmp(arg, "-v") || !strcmp(arg, "-V") ||
 237                     !strcmp(arg, "--version"))
 238                         print_version(EXIT_SUCCESS);
 239                 if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
 240                         usage();
 241                 if (!strcmp(arg, "--verbose")) {
 242                         ctl->verbose = 1;
 243                         continue;
 244                 }
 245                 if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
 246                         ctl->check_all = 1;
 247                         continue;
 248                 }
 249                 if (!strcmp(arg, "-l") || !strcmp(arg, "--list")) {
 250                         if (argc < 2) {
 251                                 print_all_signals(stdout, 0);
 252                                 exit(EXIT_SUCCESS);
 253                         }
 254                         if (2 < argc)
 255                                 errx(EXIT_FAILURE, _("too many arguments"));
 256                         /* argc == 2, accept "kill -l $?" */
 257                         arg = argv[1];
 258                         if ((ctl->numsig = arg_to_signum(arg, 1)) < 0)
 259                                 errx(EXIT_FAILURE, _("unknown signal: %s"),
 260                                      arg);
 261                         print_signal_name(ctl->numsig);
 262                         exit(EXIT_SUCCESS);
 263                 }
 264                 /* for compatibility with procps kill(1) */
 265                 if (!strncmp(arg, "--list=", 7) || !strncmp(arg, "-l=", 3)) {
 266                         char *p = strchr(arg, '=') + 1;
 267                         if ((ctl->numsig = arg_to_signum(p, 1)) < 0)
 268                                 errx(EXIT_FAILURE, _("unknown signal: %s"), p);
 269                         print_signal_name(ctl->numsig);
 270                         exit(EXIT_SUCCESS);
 271                 }
 272                 if (!strcmp(arg, "-L") || !strcmp(arg, "--table")) {
 273                         print_all_signals(stdout, 1);
 274                         exit(EXIT_SUCCESS);
 275                 }
 276                 if (!strcmp(arg, "-p") || !strcmp(arg, "--pid")) {
 277                         ctl->do_pid = 1;
 278                         if (ctl->do_kill)
 279                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
 280 #ifdef HAVE_SIGQUEUE
 281                         if (ctl->use_sigval)
 282                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
 283 #endif
 284                         continue;
 285                 }
 286                 if (!strcmp(arg, "-s") || !strcmp(arg, "--signal")) {
 287                         if (argc < 2)
 288                                 errx(EXIT_FAILURE, _("not enough arguments"));
 289                         ctl->do_kill = 1;
 290                         if (ctl->do_pid)
 291                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
 292                         argc--, argv++;
 293                         arg = *argv;
 294                         if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
 295                                 err_nosig(arg);
 296                         continue;
 297                 }
 298 #ifdef HAVE_SIGQUEUE
 299                 if (!strcmp(arg, "-q") || !strcmp(arg, "--queue")) {
 300                         if (argc < 2)
 301                                 errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
 302                         if (ctl->do_pid)
 303                                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
 304                         argc--, argv++;
 305                         arg = *argv;
 306                         ctl->sigdata.sival_int = strtos32_or_err(arg, _("argument error"));
 307                         ctl->use_sigval = 1;
 308                         continue;
 309                 }
 310 #endif
 311 #ifdef UL_HAVE_PIDFD
 312                 if (!strcmp(arg, "--timeout")) {
 313                         struct timeouts *next;
 314
 315                         ctl->timeout = 1;
 316                         if (argc < 2)
 317                                 errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
 318                         argc--, argv++;
 319                         arg = *argv;
 320                         next = xcalloc(1, sizeof(*next));
 321                         next->period = strtos32_or_err(arg, _("argument error"));
 322                         argc--, argv++;
 323                         arg = *argv;
 324                         if ((next->sig = arg_to_signum(arg, 0)) < 0)
 325                                 err_nosig(arg);
 326                         list_add_tail(&next->follow_ups, &ctl->follow_ups);
 327                         continue;
 328                 }
 329 #endif
 330                 /* 'arg' begins with a dash but is not a known option.
 331                  * So it's probably something like -HUP, or -1/-n try to
 332                  * deal with it.
 333                  *
 334                  * -n could be either signal n or pid -n (a process group
 335                  * number).  In case of doubt, POSIX tells us to assume a
 336                  * signal.  But if a signal has already been parsed, then
 337                  * assume it is a process group, so stop parsing options. */
 338                 if (ctl->do_kill)
 339                         break;
 340                 arg++;
 341                 if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
 342                         errx(EXIT_FAILURE, _("invalid signal name or number: %s"), arg);
 343                 ctl->do_kill = 1;
 344                 if (ctl->do_pid)
 345                         errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
 346                 continue;
 347         }
 348         if (!*argv)
 349                 errx(EXIT_FAILURE, _("not enough arguments"));
 350         return argv;
 351 }
 352
 353 #ifdef UL_HAVE_PIDFD
 354 static int kill_with_timeout(const struct kill_control *ctl)
 355 {
 356         int pfd, n;
 357         struct pollfd p = { 0 };
 358         siginfo_t info = { 0 };
 359         struct list_head *entry;
 360
 361         info.si_code = SI_QUEUE;
 362         info.si_signo = ctl->numsig;
 363         info.si_uid = getuid();
 364         info.si_pid = getpid();
 365         info.si_value.sival_int =
 366             ctl->use_sigval != 0 ? ctl->use_sigval : ctl->numsig;
 367
 368         if ((pfd = pidfd_open(ctl->pid, 0)) < 0)
 369                 err(EXIT_FAILURE, _("pidfd_open() failed: %d"), ctl->pid);
 370         p.fd = pfd;
 371         p.events = POLLIN;
 372
 373         if (pidfd_send_signal(pfd, ctl->numsig, &info, 0) < 0)
 374                 err(EXIT_FAILURE, _("pidfd_send_signal() failed"));
 375         list_for_each(entry, &ctl->follow_ups) {
 376                 struct timeouts *timeout;
 377
 378                 timeout = list_entry(entry, struct timeouts, follow_ups);
 379                 n = poll(&p, 1, timeout->period);
 380                 if (n < 0)
 381                         err(EXIT_FAILURE, _("poll() failed"));
 382                 if (n == 0) {
 383                         info.si_signo = timeout->sig;
 384                         if (ctl->verbose)
 385                                 printf(_("timeout, sending signal %d to pid %d\n"),
 386                                          timeout->sig, ctl->pid);
 387                         if (pidfd_send_signal(pfd, timeout->sig, &info, 0) < 0)
 388                                 err(EXIT_FAILURE, _("pidfd_send_signal() failed"));
 389                 }
 390         }
 391         return 0;
 392 }
 393 #endif
 394
 395 static int kill_verbose(const struct kill_control *ctl)
 396 {
 397         int rc = 0;
 398
 399         if (ctl->verbose)
 400                 printf(_("sending signal %d to pid %d\n"), ctl->numsig, ctl->pid);
 401         if (ctl->do_pid) {
 402                 printf("%ld\n", (long) ctl->pid);
 403                 return 0;
 404         }
 405 #ifdef UL_HAVE_PIDFD
 406         if (ctl->timeout) {
 407                 rc = kill_with_timeout(ctl);
 408         } else
 409 #endif
 410 #ifdef HAVE_SIGQUEUE
 411         if (ctl->use_sigval)
 412                 rc = sigqueue(ctl->pid, ctl->numsig, ctl->sigdata);
 413         else
 414 #endif
 415                 rc = kill(ctl->pid, ctl->numsig);
 416
 417         if (rc < 0)
 418                 warn(_("sending signal to %s failed"), ctl->arg);
 419         return rc;
 420 }
 421
 422 int main(int argc, char **argv)
 423 {
 424         struct kill_control ctl = { .numsig = SIGTERM };
 425         int nerrs = 0, ct = 0;
 426
 427         setlocale(LC_ALL, "");
 428         bindtextdomain(PACKAGE, LOCALEDIR);
 429         textdomain(PACKAGE);
 430         close_stdout_atexit();
 431
 432         INIT_LIST_HEAD(&ctl.follow_ups);
 433         argv = parse_arguments(argc, argv, &ctl);
 434
 435         /* The rest of the arguments should be process ids and names. */
 436         for ( ; (ctl.arg = *argv) != NULL; argv++) {
 437                 char *ep = NULL;
 438
 439                 errno = 0;
 440                 ctl.pid = strtol(ctl.arg, &ep, 10);
 441                 if (errno == 0 && ep && *ep == '\0' && ctl.arg < ep) {
 442                         if (kill_verbose(&ctl) != 0)
 443                                 nerrs++;
 444                         ct++;
 445                 } else {
 446                         struct proc_processes *ps = proc_open_processes();
 447                         int found = 0;
 448
 449                         if (!ps)
 450                                 continue;
 451                         if (!ctl.check_all)
 452                                 proc_processes_filter_by_uid(ps, getuid());
 453
 454                         proc_processes_filter_by_name(ps, ctl.arg);
 455                         while (proc_next_pid(ps, &ctl.pid) == 0) {
 456                                 if (kill_verbose(&ctl) != 0)
 457                                         nerrs++;
 458                                 ct++;
 459                                 found = 1;
 460                         }
 461                         proc_close_processes(ps);
 462
 463                         if (!found) {
 464                                 nerrs++, ct++;
 465                                 warnx(_("cannot find process \"%s\""), ctl.arg);
 466                         }
 467                 }
 468         }
 469
 470         if (ct && nerrs == 0)
 471                 return EXIT_SUCCESS;    /* full success */
 472         else if (ct == nerrs)
 473                 return EXIT_FAILURE;    /* all failed */
 474
 475         return KILL_EXIT_SOMEOK;        /* partial success */
 476 }
 477