X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=procps%2Fkill.c;h=c5c7a8d7290f7d8798ff071793d7a2a84cb1f944;hb=662634b82902afa84a8c978c259fa0bbd7bc8c09;hp=caaa52a5b041645f9183fc3d2d02a9c910e227f1;hpb=f57c944e09417edcbcd69f2b01b937cadef39db2;p=oweals%2Fbusybox.git diff --git a/procps/kill.c b/procps/kill.c index caaa52a5b..c5c7a8d72 100644 --- a/procps/kill.c +++ b/procps/kill.c @@ -1,249 +1,285 @@ /* vi: set sw=4 ts=4: */ /* - * Mini kill/killall implementation for busybox + * Mini kill/killall[5] implementation for busybox * * Copyright (C) 1995, 1996 by Bruce Perens . + * Copyright (C) 1999-2004 by Erik Andersen * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. + * Licensed under GPLv2 or later, see file LICENSE in this source tree. + */ + +//usage:#define kill_trivial_usage +//usage: "[-l] [-SIG] PID..." +//usage:#define kill_full_usage "\n\n" +//usage: "Send a signal (default: TERM) to given PIDs\n" +//usage: "\n -l List all signal names and numbers" +/* //usage: "\n -s SIG Yet another way of specifying SIG" */ +//usage: +//usage:#define kill_example_usage +//usage: "$ ps | grep apache\n" +//usage: "252 root root S [apache]\n" +//usage: "263 www-data www-data S [apache]\n" +//usage: "264 www-data www-data S [apache]\n" +//usage: "265 www-data www-data S [apache]\n" +//usage: "266 www-data www-data S [apache]\n" +//usage: "267 www-data www-data S [apache]\n" +//usage: "$ kill 252\n" +//usage: +//usage:#define killall_trivial_usage +//usage: "[-l] [-q] [-SIG] PROCESS_NAME..." +//usage:#define killall_full_usage "\n\n" +//usage: "Send a signal (default: TERM) to given processes\n" +//usage: "\n -l List all signal names and numbers" +/* //usage: "\n -s SIG Yet another way of specifying SIG" */ +//usage: "\n -q Don't complain if no processes were killed" +//usage: +//usage:#define killall_example_usage +//usage: "$ killall apache\n" +//usage: +//usage:#define killall5_trivial_usage +//usage: "[-l] [-SIG] [-o PID]..." +//usage:#define killall5_full_usage "\n\n" +//usage: "Send a signal (default: TERM) to all processes outside current session\n" +//usage: "\n -l List all signal names and numbers" +//usage: "\n -o PID Don't signal this PID" +/* //usage: "\n -s SIG Yet another way of specifying SIG" */ + +#include "libbb.h" + +/* Note: kill_main is directly called from shell in order to implement + * kill built-in. Shell substitutes job ids with process groups first. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. + * This brings some complications: * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + we can't use xfunc here + * + we can't use applet_name + * + we can't use bb_show_usage + * (Above doesn't apply for killall[5] cases) * + * kill %n gets translated into kill ' -' by shell (note space!) + * This is needed to avoid collision with kill -9 ... syntax */ - -#include "busybox.h" -#include -#include -#include -#include -#include -#include -#include - -#define KILL 0 -#define KILLALL 1 - -struct signal_name { - const char *name; - int number; -}; - -const struct signal_name signames[] = { - /* POSIX signals */ - { "HUP", SIGHUP }, /* 1 */ - { "INT", SIGINT }, /* 2 */ - { "QUIT", SIGQUIT }, /* 3 */ - { "ILL", SIGILL }, /* 4 */ - { "ABRT", SIGABRT }, /* 6 */ - { "FPE", SIGFPE }, /* 8 */ - { "KILL", SIGKILL }, /* 9 */ - { "SEGV", SIGSEGV }, /* 11 */ - { "PIPE", SIGPIPE }, /* 13 */ - { "ALRM", SIGALRM }, /* 14 */ - { "TERM", SIGTERM }, /* 15 */ - { "USR1", SIGUSR1 }, /* 10 (arm,i386,m68k,ppc), 30 (alpha,sparc*), 16 (mips) */ - { "USR2", SIGUSR2 }, /* 12 (arm,i386,m68k,ppc), 31 (alpha,sparc*), 17 (mips) */ - { "CHLD", SIGCHLD }, /* 17 (arm,i386,m68k,ppc), 20 (alpha,sparc*), 18 (mips) */ - { "CONT", SIGCONT }, /* 18 (arm,i386,m68k,ppc), 19 (alpha,sparc*), 25 (mips) */ - { "STOP", SIGSTOP }, /* 19 (arm,i386,m68k,ppc), 17 (alpha,sparc*), 23 (mips) */ - { "TSTP", SIGTSTP }, /* 20 (arm,i386,m68k,ppc), 18 (alpha,sparc*), 24 (mips) */ - { "TTIN", SIGTTIN }, /* 21 (arm,i386,m68k,ppc,alpha,sparc*), 26 (mips) */ - { "TTOU", SIGTTOU }, /* 22 (arm,i386,m68k,ppc,alpha,sparc*), 27 (mips) */ - /* Miscellaneous other signals */ -#ifdef SIGTRAP - { "TRAP", SIGTRAP }, /* 5 */ -#endif -#ifdef SIGIOT - { "IOT", SIGIOT }, /* 6, same as SIGABRT */ -#endif -#ifdef SIGEMT - { "EMT", SIGEMT }, /* 7 (mips,alpha,sparc*) */ -#endif -#ifdef SIGBUS - { "BUS", SIGBUS }, /* 7 (arm,i386,m68k,ppc), 10 (mips,alpha,sparc*) */ -#endif -#ifdef SIGSYS - { "SYS", SIGSYS }, /* 12 (mips,alpha,sparc*) */ -#endif -#ifdef SIGSTKFLT - { "STKFLT", SIGSTKFLT }, /* 16 (arm,i386,m68k,ppc) */ -#endif -#ifdef SIGURG - { "URG", SIGURG }, /* 23 (arm,i386,m68k,ppc), 16 (alpha,sparc*), 21 (mips) */ -#endif -#ifdef SIGIO - { "IO", SIGIO }, /* 29 (arm,i386,m68k,ppc), 23 (alpha,sparc*), 22 (mips) */ -#endif -#ifdef SIGPOLL - { "POLL", SIGPOLL }, /* same as SIGIO */ -#endif -#ifdef SIGCLD - { "CLD", SIGCLD }, /* same as SIGCHLD (mips) */ -#endif -#ifdef SIGXCPU - { "XCPU", SIGXCPU }, /* 24 (arm,i386,m68k,ppc,alpha,sparc*), 30 (mips) */ -#endif -#ifdef SIGXFSZ - { "XFSZ", SIGXFSZ }, /* 25 (arm,i386,m68k,ppc,alpha,sparc*), 31 (mips) */ -#endif -#ifdef SIGVTALRM - { "VTALRM", SIGVTALRM }, /* 26 (arm,i386,m68k,ppc,alpha,sparc*), 28 (mips) */ -#endif -#ifdef SIGPROF - { "PROF", SIGPROF }, /* 27 (arm,i386,m68k,ppc,alpha,sparc*), 29 (mips) */ -#endif -#ifdef SIGPWR - { "PWR", SIGPWR }, /* 30 (arm,i386,m68k,ppc), 29 (alpha,sparc*), 19 (mips) */ -#endif -#ifdef SIGINFO - { "INFO", SIGINFO }, /* 29 (alpha) */ -#endif -#ifdef SIGLOST - { "LOST", SIGLOST }, /* 29 (arm,i386,m68k,ppc,sparc*) */ -#endif -#ifdef SIGWINCH - { "WINCH", SIGWINCH }, /* 28 (arm,i386,m68k,ppc,alpha,sparc*), 20 (mips) */ -#endif -#ifdef SIGUNUSED - { "UNUSED", SIGUNUSED }, /* 31 (arm,i386,m68k,ppc) */ -#endif - {0, 0} -}; - -extern int kill_main(int argc, char **argv) +int kill_main(int argc UNUSED_PARAM, char **argv) { - int whichApp, sig = SIGTERM; - const char *appUsage; - -#ifdef BB_KILLALL - /* Figure out what we are trying to do here */ - whichApp = (strcmp(applet_name, "killall") == 0)? KILLALL : KILL; - appUsage = (whichApp == KILLALL)? killall_usage : kill_usage; + char *arg; + pid_t pid; + int signo = SIGTERM, errors = 0, quiet = 0; +#if !ENABLE_KILLALL && !ENABLE_KILLALL5 +#define killall 0 +#define killall5 0 #else - whichApp = KILL; - appUsage = kill_usage; +/* How to determine who we are? find 3rd char from the end: + * kill, killall, killall5 + * ^i ^a ^l - it's unique + * (checking from the start is complicated by /bin/kill... case) */ + const char char3 = argv[0][strlen(argv[0]) - 3]; +#define killall (ENABLE_KILLALL && char3 == 'a') +#define killall5 (ENABLE_KILLALL5 && char3 == 'l') #endif - argc--; - argv++; /* Parse any options */ - if (argc < 1) - usage(appUsage); - - while (argc > 0 && **argv == '-') { - while (*++(*argv)) { - switch (**argv) { - case 'l': - { - int col = 0; - const struct signal_name *s = signames; - - while (s->name != 0) { - col += - fprintf(stderr, "%2d) %-8s", s->number, - (s++)->name); - if (col > 60) { - fprintf(stderr, "\n"); - col = 0; - } - } - fprintf(stderr, "\n\n"); - return EXIT_SUCCESS; + arg = *++argv; + + if (!arg || arg[0] != '-') { + goto do_it_now; + } + + /* The -l option, which prints out signal names. + * Intended usage in shell: + * echo "Died of SIG`kill -l $?`" + * We try to mimic what kill from coreutils-6.8 does */ + if (arg[1] == 'l' && arg[2] == '\0') { + arg = *++argv; + if (!arg) { + /* Print the whole signal list */ + print_signames(); + return 0; + } + /* -l */ + do { + if (isdigit(arg[0])) { + signo = bb_strtou(arg, NULL, 10); + if (errno) { + bb_error_msg("unknown signal '%s'", arg); + return EXIT_FAILURE; } - break; - case '-': - usage(appUsage); - default: - { - if (isdigit(**argv)) { - sig = atoi(*argv); - if (sig < 0 || sig >= NSIG) - goto end; - else { - argc--; - argv++; - goto do_it_now; - } - } else { - const struct signal_name *s = signames; - - while (s->name != 0) { - if (strcasecmp(s->name, *argv) == 0) { - sig = s->number; - argc--; - argv++; - goto do_it_now; - } - s++; - } - if (s->name == 0) - goto end; - } + /* Exitcodes >= 0x80 are to be treated + * as "killed by signal (exitcode & 0x7f)" */ + puts(get_signame(signo & 0x7f)); + /* TODO: 'bad' signal# - coreutils says: + * kill: 127: invalid signal + * we just print "127" instead */ + } else { + signo = get_signum(arg); + if (signo < 0) { + bb_error_msg("unknown signal '%s'", arg); + return EXIT_FAILURE; } + printf("%d\n", signo); } - argc--; - argv++; - } + arg = *++argv; + } while (arg); + return EXIT_SUCCESS; } - do_it_now: + /* The -q quiet option */ + if (killall && arg[1] == 'q' && arg[2] == '\0') { + quiet = 1; + arg = *++argv; + if (!arg) + bb_show_usage(); + if (arg[0] != '-') + goto do_it_now; + } - if (whichApp == KILL) { - /* Looks like they want to do a kill. Do that */ - while (--argc >= 0) { - int pid; + arg++; /* skip '-' */ - if (!isdigit(**argv)) - error_msg_and_die( "Bad PID: %s\n", strerror(errno)); - pid = strtol(*argv, NULL, 0); - if (kill(pid, sig) != 0) - error_msg_and_die( "Could not kill pid '%d': %s\n", pid, strerror(errno)); - argv++; - } - } -#ifdef BB_KILLALL - else { - int all_found = TRUE; - pid_t myPid=getpid(); - /* Looks like they want to do a killall. Do that */ - while (--argc >= 0) { - pid_t* pidList; + /* -o PID? (if present, it always is at the end of command line) */ + if (killall5 && arg[0] == 'o') + goto do_it_now; + + if (argv[1] && arg[0] == 's' && arg[1] == '\0') { /* -s SIG? */ + arg = *++argv; + } /* else it must be -SIG */ + signo = get_signum(arg); + if (signo < 0) { /* || signo > MAX_SIGNUM ? */ + bb_error_msg("bad signal name '%s'", arg); + return EXIT_FAILURE; + } + arg = *++argv; + + do_it_now: + pid = getpid(); - pidList = find_pid_by_name( *argv); - if (!pidList) { - all_found = FALSE; - error_msg( "%s: no process killed\n", *argv); + if (killall5) { + pid_t sid; + procps_status_t* p = NULL; + /* compat: exitcode 2 is "no one was signaled" */ + int ret = 2; + + /* Find out our session id */ + sid = getsid(pid); + /* Stop all processes */ + if (signo != SIGSTOP && signo != SIGCONT) + kill(-1, SIGSTOP); + /* Signal all processes except those in our session */ + while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_SID)) != NULL) { + char **args; + + if (p->sid == (unsigned)sid + || p->sid == 0 /* compat: kernel thread, don't signal it */ + || p->pid == (unsigned)pid + || p->pid == 1 + ) { + continue; } - for(; pidList && *pidList!=0; pidList++) { - if (*pidList==myPid) - continue; - if (kill(*pidList, sig) != 0) - error_msg_and_die( "Could not kill pid '%d': %s\n", *pidList, strerror(errno)); + /* All remaining args must be -o PID options. + * Check p->pid against them. */ + args = argv; + while (*args) { + pid_t omit; + + arg = *args++; + if (arg[0] != '-' || arg[1] != 'o') { + bb_error_msg("bad option '%s'", arg); + ret = 1; + goto resume; + } + arg += 2; + if (!arg[0] && *args) + arg = *args++; + omit = bb_strtoi(arg, NULL, 10); + if (errno) { + bb_error_msg("invalid number '%s'", arg); + ret = 1; + goto resume; + } + if (p->pid == omit) + goto dont_kill; } - /* Note that we don't bother to free the memory - * allocated in find_pid_by_name(). It will be freed - * upon exit, so we can save a byte or two */ - argv++; + kill(p->pid, signo); + ret = 0; + dont_kill: ; } - if (all_found == FALSE) - return EXIT_FAILURE; + resume: + /* And let them continue */ + if (signo != SIGSTOP && signo != SIGCONT) + kill(-1, SIGCONT); + return ret; } -#endif - return EXIT_SUCCESS; + /* Pid or name is required for kill/killall */ + if (!arg) { + bb_error_msg("you need to specify whom to kill"); + return EXIT_FAILURE; + } + + if (killall) { + /* Looks like they want to do a killall. Do that */ + do { + pid_t* pidList; + + pidList = find_pid_by_name(arg); + if (*pidList == 0) { + errors++; + if (!quiet) + bb_error_msg("%s: no process killed", arg); + } else { + pid_t *pl; + for (pl = pidList; *pl; pl++) { + if (*pl == pid) + continue; + if (kill(*pl, signo) == 0) + continue; + errors++; + if (!quiet) + bb_perror_msg("can't kill pid %d", (int)*pl); + } + } + free(pidList); + arg = *++argv; + } while (arg); + return errors; + } - end: - error_msg_and_die( "bad signal name: %s\n", *argv); + /* Looks like they want to do a kill. Do that */ + while (arg) { +#if ENABLE_ASH || ENABLE_HUSH + /* + * We need to support shell's "hack formats" of + * " -PRGP_ID" (yes, with a leading space) + * and " PID1 PID2 PID3" (with degenerate case "") + */ + while (*arg != '\0') { + char *end; + if (*arg == ' ') + arg++; + pid = bb_strtoi(arg, &end, 10); + if (errno && (errno != EINVAL || *end != ' ')) { + bb_error_msg("invalid number '%s'", arg); + errors++; + break; + } + if (kill(pid, signo) != 0) { + bb_perror_msg("can't kill pid %d", (int)pid); + errors++; + } + arg = end; /* can only point to ' ' or '\0' now */ + } +#else + pid = bb_strtoi(arg, NULL, 10); + if (errno) { + bb_error_msg("invalid number '%s'", arg); + errors++; + } else if (kill(pid, signo) != 0) { + bb_perror_msg("can't kill pid %d", (int)pid); + errors++; + } +#endif + arg = *++argv; + } + return errors; }