X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=procps%2Fkill.c;h=b51d44a70a1837b7dd51779f356f3e804a387b7f;hb=b507cc3aceda26eff851230223a62c6fb471573c;hp=8fa9da77d278f1a598561fe826da4415ca5047f5;hpb=1fa1adea2ae16d4f4c82d7466905dce4c6edd5f5;p=oweals%2Fbusybox.git diff --git a/procps/kill.c b/procps/kill.c index 8fa9da77d..b51d44a70 100644 --- a/procps/kill.c +++ b/procps/kill.c @@ -1,249 +1,223 @@ /* 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. + */ + +#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, 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; + argc--; + arg = *++argv; + + if (argc < 1 || 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') { + if (argc == 1) { + /* Print the whole signal list */ + print_signames(); + return 0; + } + /* -l */ + while ((arg = *++argv)) { + 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++; } + /* If they specified -l, we are all done */ + return EXIT_SUCCESS; } - do_it_now: + /* The -q quiet option */ + if (killall && arg[1] == 'q' && arg[2] == '\0') { + quiet = 1; + arg = *++argv; + argc--; + if (argc < 1) + 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)) - perror_msg_and_die( "Bad PID"); - pid = strtol(*argv, NULL, 0); - if (kill(pid, sig) != 0) - perror_msg_and_die( "Could not kill pid '%d'", pid); - 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; - pidList = find_pid_by_name( *argv); - if (!pidList) { - all_found = FALSE; - error_msg( "%s: no process killed\n", *argv); - } + if (argc > 1 && arg[0] == 's' && arg[1] == '\0') { /* -s SIG? */ + argc--; + 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; + argc--; - for(; pidList && *pidList!=0; pidList++) { - if (*pidList==myPid) - continue; - if (kill(*pidList, sig) != 0) - perror_msg_and_die( "Could not kill pid '%d'", *pidList); + do_it_now: + pid = getpid(); + + if (killall5) { + pid_t sid; + procps_status_t* p = NULL; + int ret = 0; + + /* Find out our session id */ + sid = getsid(pid); + /* Stop all processes */ + kill(-1, SIGSTOP); + /* Signal all processes except those in our session */ + while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_SID))) { + int i; + + if (p->sid == (unsigned)sid + || p->pid == (unsigned)pid + || p->pid == 1) + continue; + + /* All remaining args must be -o PID options. + * Check p->pid against them. */ + for (i = 0; i < argc; i++) { + pid_t omit; + + arg = argv[i]; + if (arg[0] != '-' || arg[1] != 'o') { + bb_error_msg("bad option '%s'", arg); + ret = 1; + goto resume; + } + arg += 2; + if (!arg[0] && argv[++i]) + arg = argv[i]; + 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); + dont_kill: ; } - if (all_found == FALSE) - return EXIT_FAILURE; + resume: + /* And let them continue */ + kill(-1, SIGCONT); + return ret; + } + + /* Pid or name is required for kill/killall */ + if (argc < 1) { + bb_error_msg("you need to specify whom to kill"); + return EXIT_FAILURE; } -#endif - return EXIT_SUCCESS; + if (killall) { + /* Looks like they want to do a killall. Do that */ + while (arg) { + 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; + } + 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) { + /* Support shell 'space' trick */ + if (arg[0] == ' ') + arg++; + 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++; + } + arg = *++argv; + } + return errors; }