busybox/procps/kill.c

/* vi: set sw=4 ts=4: */
/*
 * Mini kill/killall[5] implementation for busybox
 *
 * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
 *
 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
 */

#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 brings some complications:
 *
 * + 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 ' -<process group>' by shell (note space!)
 * This is needed to avoid collision with kill -9 ... syntax
 */

int kill_main(int argc, char **argv)
{
	char *arg;
	pid_t pid;
	int signo = SIGTERM, errors = 0, quiet = 0;
#if !ENABLE_KILLALL && !ENABLE_KILLALL5
#define killall 0
#define killall5 0
#else
/* 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

	/* Parse any options */
	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 <sig list> */
		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;
				}
				/* 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);
			}
		}
		/* If they specified -l, we are all done */
		return EXIT_SUCCESS;
	}

	/* 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;
	}

	arg++; /* skip '-' */
	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--;

do_it_now:
	pid = getpid();

	if (killall5) {
		pid_t sid;
		procps_status_t* p = NULL;

		/* Find out our own session id */
		sid = getsid(pid);
		/* Now stop all processes */
		kill(-1, SIGSTOP);
		/* Now kill all processes except our session */
		while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_SID))) {
			if (p->sid != (unsigned)sid && p->pid != (unsigned)pid && p->pid != 1)
				kill(p->pid, signo);
		}
		/* And let them continue */
		kill(-1, SIGCONT);
		return 0;
	}

	/* Pid or name is required for kill/killall */
	if (argc < 1) {
		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 */
		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("cannot kill pid %u", (unsigned)*pl);
				}
			}
			free(pidList);
			arg = *++argv;
		}
		return errors;
	}

	/* 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("bad pid '%s'", arg);
			errors++;
		} else if (kill(pid, signo) != 0) {
			bb_perror_msg("cannot kill pid %d", (int)pid);
			errors++;
		}
		arg = *++argv;
	}
	return errors;
}
1	/* vi: set sw=4 ts=4: */
2	/*
3	* Mini kill/killall[5] implementation for busybox
4	*
5	* Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
6	* Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
7	*
8	* Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
9	*/
10
11	#include "libbb.h"
12
13	/* Note: kill_main is directly called from shell in order to implement
14	* kill built-in. Shell substitutes job ids with process groups first.
15	*
16	* This brings some complications:
17	*
18	* + we can't use xfunc here
19	* + we can't use applet_name
20	* + we can't use bb_show_usage
21	* (Above doesn't apply for killall[5] cases)
22	*
23	* kill %n gets translated into kill ' -<process group>' by shell (note space!)
24	* This is needed to avoid collision with kill -9 ... syntax
25	*/
26
27	int kill_main(int argc, char **argv)
28	{
29	char *arg;
30	pid_t pid;
31	int signo = SIGTERM, errors = 0, quiet = 0;
32	#if !ENABLE_KILLALL && !ENABLE_KILLALL5
33	#define killall 0
34	#define killall5 0
35	#else
36	/* How to determine who we are? find 3rd char from the end:
37	* kill, killall, killall5
38	* ^i ^a ^l - it's unique
39	* (checking from the start is complicated by /bin/kill... case) */
40	const char char3 = argv[0][strlen(argv[0]) - 3];
41	#define killall (ENABLE_KILLALL && char3 == 'a')
42	#define killall5 (ENABLE_KILLALL5 && char3 == 'l')
43	#endif
44
45	/* Parse any options */
46	argc--;
47	arg = *++argv;
48
49	if (argc < 1 \|\| arg[0] != '-') {
50	goto do_it_now;
51	}
52
53	/* The -l option, which prints out signal names.
54	* Intended usage in shell:
55	* echo "Died of SIG`kill -l $?`"
56	* We try to mimic what kill from coreutils-6.8 does */
57	if (arg[1] == 'l' && arg[2] == '\0') {
58	if (argc == 1) {
59	/* Print the whole signal list */
60	print_signames();
61	return 0;
62	}
63	/* -l <sig list> */
64	while ((arg = *++argv)) {
65	if (isdigit(arg[0])) {
66	signo = bb_strtou(arg, NULL, 10);
67	if (errno) {
68	bb_error_msg("unknown signal '%s'", arg);
69	return EXIT_FAILURE;
70	}
71	/* Exitcodes >= 0x80 are to be treated
72	* as "killed by signal (exitcode & 0x7f)" */
73	puts(get_signame(signo & 0x7f));
74	/* TODO: 'bad' signal# - coreutils says:
75	* kill: 127: invalid signal
76	* we just print "127" instead */
77	} else {
78	signo = get_signum(arg);
79	if (signo < 0) {
80	bb_error_msg("unknown signal '%s'", arg);
81	return EXIT_FAILURE;
82	}
83	printf("%d\n", signo);
84	}
85	}
86	/* If they specified -l, we are all done */
87	return EXIT_SUCCESS;
88	}
89
90	/* The -q quiet option */
91	if (killall && arg[1] == 'q' && arg[2] == '\0') {
92	quiet = 1;
93	arg = *++argv;
94	argc--;
95	if (argc < 1) bb_show_usage();
96	if (arg[0] != '-') goto do_it_now;
97	}
98
99	arg++; /* skip '-' */
100	if (argc > 1 && arg[0] == 's' && arg[1] == '\0') { /* -s SIG? */
101	argc--;
102	arg = *++argv;
103	} /* else it must be -SIG */
104	signo = get_signum(arg);
105	if (signo < 0) { /* \|\| signo > MAX_SIGNUM ? */
106	bb_error_msg("bad signal name '%s'", arg);
107	return EXIT_FAILURE;
108	}
109	arg = *++argv;
110	argc--;
111
112	do_it_now:
113	pid = getpid();
114
115	if (killall5) {
116	pid_t sid;
117	procps_status_t* p = NULL;
118
119	/* Find out our own session id */
120	sid = getsid(pid);
121	/* Now stop all processes */
122	kill(-1, SIGSTOP);
123	/* Now kill all processes except our session */
124	while ((p = procps_scan(p, PSSCAN_PID\|PSSCAN_SID))) {
125	if (p->sid != (unsigned)sid && p->pid != (unsigned)pid && p->pid != 1)
126	kill(p->pid, signo);
127	}
128	/* And let them continue */
129	kill(-1, SIGCONT);
130	return 0;
131	}
132
133	/* Pid or name is required for kill/killall */
134	if (argc < 1) {
135	bb_error_msg("you need to specify whom to kill");
136	return EXIT_FAILURE;
137	}
138
139	if (killall) {
140	/* Looks like they want to do a killall. Do that */
141	while (arg) {
142	pid_t* pidList;
143
144	pidList = find_pid_by_name(arg);
145	if (*pidList == 0) {
146	errors++;
147	if (!quiet)
148	bb_error_msg("%s: no process killed", arg);
149	} else {
150	pid_t *pl;
151
152	for (pl = pidList; *pl; pl++) {
153	if (*pl == pid)
154	continue;
155	if (kill(*pl, signo) == 0)
156	continue;
157	errors++;
158	if (!quiet)
159	bb_perror_msg("cannot kill pid %u", (unsigned)*pl);
160	}
161	}
162	free(pidList);
163	arg = *++argv;
164	}
165	return errors;
166	}
167
168	/* Looks like they want to do a kill. Do that */
169	while (arg) {
170	/* Support shell 'space' trick */
171	if (arg[0] == ' ')
172	arg++;
173	pid = bb_strtoi(arg, NULL, 10);
174	if (errno) {
175	bb_error_msg("bad pid '%s'", arg);
176	errors++;
177	} else if (kill(pid, signo) != 0) {
178	bb_perror_msg("cannot kill pid %d", (int)pid);
179	errors++;
180	}
181	arg = *++argv;
182	}
183	return errors;
184	}