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
print_signal_name(int signum)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
pretty_print_signal(FILE * fp,size_t term_width,size_t * lpos,int signum,const char * name)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
print_all_signals(FILE * fp,int pretty)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
err_nosig(char * name)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
arg_to_signum(char * arg,int maskbit)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
usage(void)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
print_kill_version(void)221 static void __attribute__((__noreturn__)) print_kill_version(void)
222 {
223 static const char *features[] = {
224 #ifdef HAVE_SIGQUEUE
225 "sigqueue",
226 #endif
227 #ifdef UL_HAVE_PIDFD
228 "pidfd",
229 #endif
230 };
231
232 printf(_("%s from %s"), program_invocation_short_name, PACKAGE_STRING);
233
234 if (ARRAY_SIZE(features)) {
235 size_t i;
236 fputs(_(" (with: "), stdout);
237 for (i = 0; i < ARRAY_SIZE(features); i++) {
238 fputs(features[i], stdout);
239 if (i + 1 < ARRAY_SIZE(features))
240 fputs(", ", stdout);
241 }
242 fputs(")\n", stdout);
243 }
244 exit(EXIT_SUCCESS);
245 }
246
parse_arguments(int argc,char ** argv,struct kill_control * ctl)247 static char **parse_arguments(int argc, char **argv, struct kill_control *ctl)
248 {
249 char *arg;
250
251 /* Loop through the arguments. Actually, -a is the only option
252 * can be used with other options. The 'kill' is basically a
253 * one-option-at-most program. */
254 for (argc--, argv++; 0 < argc; argc--, argv++) {
255 arg = *argv;
256 if (*arg != '-')
257 break;
258 if (!strcmp(arg, "--")) {
259 argc--, argv++;
260 break;
261 }
262 if (!strcmp(arg, "-v") || !strcmp(arg, "-V") ||
263 !strcmp(arg, "--version"))
264 print_kill_version();
265 if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
266 usage();
267 if (!strcmp(arg, "--verbose")) {
268 ctl->verbose = 1;
269 continue;
270 }
271 if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
272 ctl->check_all = 1;
273 continue;
274 }
275 if (!strcmp(arg, "-l") || !strcmp(arg, "--list")) {
276 if (argc < 2) {
277 print_all_signals(stdout, 0);
278 exit(EXIT_SUCCESS);
279 }
280 if (2 < argc)
281 errx(EXIT_FAILURE, _("too many arguments"));
282 /* argc == 2, accept "kill -l $?" */
283 arg = argv[1];
284 if ((ctl->numsig = arg_to_signum(arg, 1)) < 0)
285 errx(EXIT_FAILURE, _("unknown signal: %s"),
286 arg);
287 print_signal_name(ctl->numsig);
288 exit(EXIT_SUCCESS);
289 }
290 /* for compatibility with procps kill(1) */
291 if (!strncmp(arg, "--list=", 7) || !strncmp(arg, "-l=", 3)) {
292 char *p = strchr(arg, '=') + 1;
293 if ((ctl->numsig = arg_to_signum(p, 1)) < 0)
294 errx(EXIT_FAILURE, _("unknown signal: %s"), p);
295 print_signal_name(ctl->numsig);
296 exit(EXIT_SUCCESS);
297 }
298 if (!strcmp(arg, "-L") || !strcmp(arg, "--table")) {
299 print_all_signals(stdout, 1);
300 exit(EXIT_SUCCESS);
301 }
302 if (!strcmp(arg, "-p") || !strcmp(arg, "--pid")) {
303 ctl->do_pid = 1;
304 if (ctl->do_kill)
305 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
306 #ifdef HAVE_SIGQUEUE
307 if (ctl->use_sigval)
308 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
309 #endif
310 continue;
311 }
312 if (!strcmp(arg, "-s") || !strcmp(arg, "--signal")) {
313 if (argc < 2)
314 errx(EXIT_FAILURE, _("not enough arguments"));
315 ctl->do_kill = 1;
316 if (ctl->do_pid)
317 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
318 argc--, argv++;
319 arg = *argv;
320 if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
321 err_nosig(arg);
322 continue;
323 }
324 #ifdef HAVE_SIGQUEUE
325 if (!strcmp(arg, "-q") || !strcmp(arg, "--queue")) {
326 if (argc < 2)
327 errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
328 if (ctl->do_pid)
329 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
330 argc--, argv++;
331 arg = *argv;
332 ctl->sigdata.sival_int = strtos32_or_err(arg, _("argument error"));
333 ctl->use_sigval = 1;
334 continue;
335 }
336 #endif
337 #ifdef UL_HAVE_PIDFD
338 if (!strcmp(arg, "--timeout")) {
339 struct timeouts *next;
340
341 ctl->timeout = 1;
342 if (argc < 2)
343 errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
344 argc--, argv++;
345 arg = *argv;
346 next = xcalloc(1, sizeof(*next));
347 next->period = strtos32_or_err(arg, _("argument error"));
348 INIT_LIST_HEAD(&next->follow_ups);
349 argc--, argv++;
350 arg = *argv;
351 if ((next->sig = arg_to_signum(arg, 0)) < 0)
352 err_nosig(arg);
353 list_add_tail(&next->follow_ups, &ctl->follow_ups);
354 continue;
355 }
356 #endif
357 /* 'arg' begins with a dash but is not a known option.
358 * So it's probably something like -HUP, or -1/-n try to
359 * deal with it.
360 *
361 * -n could be either signal n or pid -n (a process group
362 * number). In case of doubt, POSIX tells us to assume a
363 * signal. But if a signal has already been parsed, then
364 * assume it is a process group, so stop parsing options. */
365 if (ctl->do_kill)
366 break;
367 arg++;
368 if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
369 errx(EXIT_FAILURE, _("invalid signal name or number: %s"), arg);
370 ctl->do_kill = 1;
371 if (ctl->do_pid)
372 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
373 }
374 if (!*argv)
375 errx(EXIT_FAILURE, _("not enough arguments"));
376 return argv;
377 }
378
379 #ifdef UL_HAVE_PIDFD
kill_with_timeout(const struct kill_control * ctl)380 static int kill_with_timeout(const struct kill_control *ctl)
381 {
382 int pfd, n;
383 struct pollfd p = { 0 };
384 siginfo_t info = { 0 };
385 struct list_head *entry;
386
387 info.si_code = SI_QUEUE;
388 info.si_signo = ctl->numsig;
389 info.si_uid = getuid();
390 info.si_pid = getpid();
391 info.si_value.sival_int =
392 ctl->use_sigval != 0 ? ctl->use_sigval : ctl->numsig;
393
394 if ((pfd = pidfd_open(ctl->pid, 0)) < 0)
395 err(EXIT_FAILURE, _("pidfd_open() failed: %d"), ctl->pid);
396 p.fd = pfd;
397 p.events = POLLIN;
398
399 if (pidfd_send_signal(pfd, ctl->numsig, &info, 0) < 0)
400 err(EXIT_FAILURE, _("pidfd_send_signal() failed"));
401 list_for_each(entry, &ctl->follow_ups) {
402 struct timeouts *timeout;
403
404 timeout = list_entry(entry, struct timeouts, follow_ups);
405 n = poll(&p, 1, timeout->period);
406 if (n < 0)
407 err(EXIT_FAILURE, _("poll() failed"));
408 if (n == 0) {
409 info.si_signo = timeout->sig;
410 if (ctl->verbose)
411 printf(_("timeout, sending signal %d to pid %d\n"),
412 timeout->sig, ctl->pid);
413 if (pidfd_send_signal(pfd, timeout->sig, &info, 0) < 0)
414 err(EXIT_FAILURE, _("pidfd_send_signal() failed"));
415 }
416 }
417 return 0;
418 }
419 #endif
420
kill_verbose(const struct kill_control * ctl)421 static int kill_verbose(const struct kill_control *ctl)
422 {
423 int rc = 0;
424
425 if (ctl->verbose)
426 printf(_("sending signal %d to pid %d\n"), ctl->numsig, ctl->pid);
427 if (ctl->do_pid) {
428 printf("%ld\n", (long) ctl->pid);
429 return 0;
430 }
431 #ifdef UL_HAVE_PIDFD
432 if (ctl->timeout) {
433 rc = kill_with_timeout(ctl);
434 } else
435 #endif
436 #ifdef HAVE_SIGQUEUE
437 if (ctl->use_sigval)
438 rc = sigqueue(ctl->pid, ctl->numsig, ctl->sigdata);
439 else
440 #endif
441 rc = kill(ctl->pid, ctl->numsig);
442
443 if (rc < 0)
444 warn(_("sending signal to %s failed"), ctl->arg);
445 return rc;
446 }
447
main(int argc,char ** argv)448 int main(int argc, char **argv)
449 {
450 struct kill_control ctl = { .numsig = SIGTERM };
451 int nerrs = 0, ct = 0;
452
453 setlocale(LC_ALL, "");
454 bindtextdomain(PACKAGE, LOCALEDIR);
455 textdomain(PACKAGE);
456 close_stdout_atexit();
457
458 #ifdef UL_HAVE_PIDFD
459 INIT_LIST_HEAD(&ctl.follow_ups);
460 #endif
461 argv = parse_arguments(argc, argv, &ctl);
462
463 /* The rest of the arguments should be process ids and names. */
464 for ( ; (ctl.arg = *argv) != NULL; argv++) {
465 char *ep = NULL;
466
467 errno = 0;
468 ctl.pid = strtol(ctl.arg, &ep, 10);
469 if (errno == 0 && ep && *ep == '\0' && ctl.arg < ep) {
470 if (kill_verbose(&ctl) != 0)
471 nerrs++;
472 ct++;
473 } else {
474 struct proc_processes *ps = proc_open_processes();
475 int found = 0;
476
477 if (!ps)
478 continue;
479 if (!ctl.check_all)
480 proc_processes_filter_by_uid(ps, getuid());
481
482 proc_processes_filter_by_name(ps, ctl.arg);
483 while (proc_next_pid(ps, &ctl.pid) == 0) {
484 if (kill_verbose(&ctl) != 0)
485 nerrs++;
486 ct++;
487 found = 1;
488 }
489 proc_close_processes(ps);
490
491 if (!found) {
492 nerrs++, ct++;
493 warnx(_("cannot find process \"%s\""), ctl.arg);
494 }
495 }
496 }
497
498 #ifdef UL_HAVE_PIDFD
499 while (!list_empty(&ctl.follow_ups)) {
500 struct timeouts *x = list_entry(ctl.follow_ups.next,
501 struct timeouts, follow_ups);
502 list_del(&x->follow_ups);
503 free(x);
504 }
505 #endif
506 if (ct && nerrs == 0)
507 return EXIT_SUCCESS; /* full success */
508 if (ct == nerrs)
509 return EXIT_FAILURE; /* all failed */
510
511 return KILL_EXIT_SOMEOK; /* partial success */
512 }
513
514