?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel/mrsas: Fix a double assignment.
[dragonfly.git] / usr.bin / killall / killall.c
blobd4d5bf353a0f9cc331be78e51fdb1ad8edddf2af
1 /*-
2 * Copyright (c) 2000 Peter Wemm <peter@FreeBSD.org>
3 * Copyright (c) 2000 Paul Saab <ps@FreeBSD.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: src/usr.bin/killall/killall.c,v 1.5.2.4 2001/05/19 19:22:49 phk Exp $
28 */
29
30 #include <sys/user.h>
31 #include <sys/param.h>
32 #include <sys/stat.h>
33 #include <sys/sysctl.h>
34 #include <fcntl.h>
35 #include <dirent.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <pwd.h>
40 #include <signal.h>
41 #include <regex.h>
42 #include <ctype.h>
43 #include <err.h>
44 #include <errno.h>
45 #include <unistd.h>
46
47 #define PHASH_SIZE 1024
48
49 struct pchain {
50 struct pchain *next;
51 struct kinfo_proc *proc;
52 struct pchain *parent;
53 };
54
55 static char *prog;
56 static struct pchain *phash[PHASH_SIZE];
57
58 static struct pchain *saveparents(struct kinfo_proc *procs, int nprocs,
59 pid_t mypid);
60 static int checkparent(struct pchain *mychain, pid_t pid);
61
62 static void __dead2
63 usage(void)
64 {
65
66 fprintf(stderr, "usage: %s [-l] [-v] [-m] [-sig] "
67 "[-u user] [-j jail] [-t tty] [-T] "
68 "[-c cmd] [cmd]...\n", prog);
69 fprintf(stderr, "At least one option or argument to specify "
70 "processes must be given.\n");
71 exit(1);
72 }
73
74 static char *
75 upper(const char *str)
76 {
77 static char buf[80];
78 char *s;
79
80 strlcpy(buf, str, sizeof(buf));
81 for (s = buf; *s; s++)
82 *s = toupper((unsigned char)*s);
83 return buf;
84 }
85
86
87 static void
88 printsig(FILE *fp)
89 {
90 const char *const * p;
91 int cnt;
92 int offset = 0;
93
94 for (cnt = NSIG, p = sys_signame + 1; --cnt; ++p) {
95 offset += fprintf(fp, "%s ", upper(*p));
96 if (offset >= 75 && cnt > 1) {
97 offset = 0;
98 fprintf(fp, "\n");
99 }
100 }
101 fprintf(fp, "\n");
102 }
103
104 static void
105 nosig(char *name)
106 {
107
108 warnx("unknown signal %s; valid signals:", name);
109 printsig(stderr);
110 exit(1);
111 }
112
113 int
114 main(int ac, char **av)
115 {
116 struct kinfo_proc *procs = NULL, *newprocs;
117 struct pchain *mychain;
118 struct stat sb;
119 struct passwd *pw;
120 regex_t rgx;
121 regmatch_t pmatch;
122 int i, j;
123 char buf[256];
124 char *user = NULL;
125 char *tty = NULL;
126 char *cmd = NULL;
127 int qflag = 0;
128 int vflag = 0;
129 int sflag = 0;
130 int jflag = 0, jailid = 0;
131 int dflag = 0;
132 int mflag = 0;
133 int Tflag = 0;
134 uid_t uid = 0;
135 dev_t tdev = 0;
136 pid_t mypid;
137 char thiscmd[MAXCOMLEN + 1];
138 pid_t thispid;
139 uid_t thisuid;
140 dev_t thistdev;
141 int sig = SIGTERM;
142 const char *const *p;
143 char *ep;
144 int errors = 0;
145 int mib[4];
146 size_t miblen;
147 int st, nprocs;
148 size_t size;
149 int matched;
150 int killed = 0;
151
152 prog = av[0];
153 av++;
154 ac--;
155
156 while (ac > 0) {
157 if (strcmp(*av, "-l") == 0) {
158 printsig(stdout);
159 exit(0);
160 }
161 if (strcmp(*av, "-help") == 0)
162 usage();
163 if (**av == '-') {
164 ++*av;
165 switch (**av) {
166 case 'u':
167 ++*av;
168 if (**av == '\0')
169 ++av;
170 --ac;
171 user = *av;
172 break;
173 case 't':
174 ++*av;
175 if (**av == '\0')
176 ++av;
177 --ac;
178 tty = *av;
179 break;
180 case 'c':
181 ++*av;
182 if (**av == '\0')
183 ++av;
184 --ac;
185 cmd = *av;
186 break;
187 case 'j':
188 {
189 const char *errstr;
190 ++*av;
191 if (**av == '\0')
192 ++av;
193 --ac;
194 jailid = strtonum(*av, 1, INT_MAX, &errstr);
195
196 if (errstr)
197 errx(1, "jail id is %s: %s", errstr, *av);
198 jflag++;
199 break;
200 }
201 case 'q':
202 qflag++;
203 break;
204 case 'v':
205 vflag++;
206 break;
207 case 's':
208 sflag++;
209 break;
210 case 'd':
211 dflag++;
212 break;
213 case 'm':
214 mflag++;
215 break;
216 case 'T':
217 Tflag++;
218 break;
219 default:
220 if (isalpha((unsigned char)**av)) {
221 if (strncasecmp(*av, "sig", 3) == 0)
222 *av += 3;
223 for (sig = NSIG, p = sys_signame + 1;
224 --sig; ++p)
225 if (strcasecmp(*p, *av) == 0) {
226 sig = p - sys_signame;
227 break;
228 }
229 if (!sig)
230 nosig(*av);
231 } else if (isdigit((unsigned char)**av)) {
232 sig = strtol(*av, &ep, 10);
233 if (!*av || *ep)
234 errx(1, "illegal signal number: %s", *av);
235 if (sig < 0 || sig >= NSIG)
236 nosig(*av);
237 } else
238 nosig(*av);
239 }
240 ++av;
241 --ac;
242 } else {
243 break;
244 }
245 }
246
247 if (user == NULL && tty == NULL && cmd == NULL &&
248 jflag == 0 && Tflag == 0 && ac == 0) {
249 usage();
250 }
251
252 if (Tflag) {
253 tty = ttyname(0);
254 if (tty)
255 tty = strdup(tty);
256 }
257
258 if (tty) {
259 if (strncmp(tty, "/dev/", 5) == 0)
260 snprintf(buf, sizeof(buf), "%s", tty);
261 else if (strncmp(tty, "tty", 3) == 0)
262 snprintf(buf, sizeof(buf), "/dev/%s", tty);
263 else if (isdigit(tty[0]))
264 snprintf(buf, sizeof(buf), "/dev/pts/%s", tty);
265 else
266 snprintf(buf, sizeof(buf), "/dev/tty%s", tty);
267 if (stat(buf, &sb) < 0)
268 err(1, "stat(%s)", buf);
269 if (!S_ISCHR(sb.st_mode))
270 errx(1, "%s: not a character device", buf);
271 tdev = sb.st_rdev;
272 if (dflag)
273 printf("ttydev:0x%x\n", tdev);
274 }
275 if (user) {
276 pw = getpwnam(user);
277 if (pw == NULL)
278 errx(1, "user %s does not exist", user);
279 uid = pw->pw_uid;
280 if (dflag)
281 printf("uid:%d\n", uid);
282 } else {
283 uid = getuid();
284 if (uid != 0) {
285 pw = getpwuid(uid);
286 if (pw)
287 user = pw->pw_name;
288 if (dflag)
289 printf("uid:%d\n", uid);
290 }
291 }
292 size = 0;
293 mib[0] = CTL_KERN;
294 mib[1] = KERN_PROC;
295 mib[2] = KERN_PROC_ALL;
296 mib[3] = 0;
297 miblen = 3;
298
299 if (user && mib[2] == KERN_PROC_ALL) {
300 mib[2] = KERN_PROC_RUID;
301 mib[3] = uid;
302 miblen = 4;
303 }
304 if (tty && mib[2] == KERN_PROC_ALL) {
305 mib[2] = KERN_PROC_TTY;
306 mib[3] = tdev;
307 miblen = 4;
308 }
309
310 st = sysctl(mib, miblen, NULL, &size, NULL, 0);
311 do {
312 size += size / 10;
313 newprocs = realloc(procs, size);
314 if (newprocs == NULL) {
315 if (procs)
316 free(procs);
317 errx(1, "could not reallocate memory");
318 }
319 procs = newprocs;
320 st = sysctl(mib, miblen, procs, &size, NULL, 0);
321 } while (st == -1 && errno == ENOMEM);
322 if (st == -1)
323 err(1, "could not sysctl(KERN_PROC)");
324 if (size % sizeof(struct kinfo_proc) != 0) {
325 fprintf(stderr, "proc size mismatch (%zu total, %zu chunks)\n",
326 size, sizeof(struct kinfo_proc));
327 fprintf(stderr, "userland out of sync with kernel, recompile libkvm etc\n");
328 exit(1);
329 }
330 nprocs = size / sizeof(struct kinfo_proc);
331 if (dflag)
332 printf("nprocs %d\n", nprocs);
333 mypid = getpid();
334
335 /*
336 * Record parent chain if Tflag
337 */
338 if (Tflag && tty)
339 mychain = saveparents(procs, nprocs, mypid);
340 else
341 mychain = NULL;
342
343 /*
344 * Final scan
345 */
346 for (i = 0; i < nprocs; i++) {
347 thispid = procs[i].kp_pid;
348 strncpy(thiscmd, procs[i].kp_comm, MAXCOMLEN);
349 thiscmd[MAXCOMLEN] = '\0';
350 thistdev = procs[i].kp_tdev;
351 thisuid = procs[i].kp_ruid; /* real uid */
352
353 if (thispid == mypid)
354 continue;
355 matched = 1;
356 if ((int)procs[i].kp_pid < 0)
357 matched = 0;
358 if (user) {
359 if (thisuid != uid)
360 matched = 0;
361 }
362 if (tty) {
363 if (thistdev != tdev)
364 matched = 0;
365 if (Tflag && checkparent(mychain, procs[i].kp_pid))
366 matched = 0;
367 }
368 if (jflag) {
369 if (procs[i].kp_jailid != jailid)
370 matched = 0;
371 }
372 if (cmd) {
373 if (mflag) {
374 if (regcomp(&rgx, cmd,
375 REG_EXTENDED|REG_NOSUB) != 0) {
376 mflag = 0;
377 warnx("%s: illegal regexp", cmd);
378 }
379 }
380 if (mflag) {
381 pmatch.rm_so = 0;
382 pmatch.rm_eo = strlen(thiscmd);
383 if (regexec(&rgx, thiscmd, 0, &pmatch,
384 REG_STARTEND) != 0)
385 matched = 0;
386 regfree(&rgx);
387 } else {
388 if (strcmp(thiscmd, cmd) != 0)
389 matched = 0;
390 }
391 }
392 if (matched == 0)
393 continue;
394 if (ac > 0) {
395 matched = 0;
396 for (j = 0; j < ac; j++) {
397 if (mflag) {
398 if (regcomp(&rgx, av[j],
399 REG_EXTENDED|REG_NOSUB) != 0) {
400 mflag = 0;
401 warnx("%s: illegal regexp", av[j]);
402 }
403 }
404 if (mflag) {
405 pmatch.rm_so = 0;
406 pmatch.rm_eo = strlen(thiscmd);
407 if (regexec(&rgx, thiscmd, 0, &pmatch,
408 REG_STARTEND) == 0)
409 matched = 1;
410 regfree(&rgx);
411 } else {
412 if (strcmp(thiscmd, av[j]) == 0)
413 matched = 1;
414 }
415 if (matched)
416 break;
417 }
418 if (matched == 0)
419 continue;
420 }
421 if (dflag)
422 printf("sig:%d, cmd:%s, pid:%d, dev:0x%x uid:%d\n", sig,
423 thiscmd, thispid, thistdev, thisuid);
424
425 if (vflag || sflag)
426 printf("kill -%s %d\n", upper(sys_signame[sig]),
427 thispid);
428
429 killed++;
430 if (!dflag && !sflag) {
431 if (kill(thispid, sig) < 0 /* && errno != ESRCH */ ) {
432 warn("kill -%s %d", upper(sys_signame[sig]),
433 thispid);
434 errors = 1;
435 }
436 }
437 }
438 if (!qflag && killed == 0) {
439 fprintf(stderr, "No matching processes %swere found\n",
440 getuid() != 0 ? "belonging to you " : "");
441 errors = 1;
442 }
443 exit(errors);
444 }
445
446
447 static
448 struct pchain *
449 saveparents(struct kinfo_proc *procs, int nprocs, pid_t mypid)
450 {
451 struct pchain *rchain = NULL;
452 struct pchain *chain;
453 struct pchain *pchain;
454 int i;
455 int hv;
456
457 for (i = 0; i < nprocs; ++i) {
458 if ((int)procs[i].kp_pid < 0)
459 continue;
460 hv = (int)procs[i].kp_pid & 1023;
461 chain = malloc(sizeof(*chain));
462 chain->proc = &procs[i];
463 chain->parent = NULL;
464 chain->next = phash[hv];
465 phash[hv] = chain;
466 if (mypid == procs[i].kp_pid)
467 rchain = chain;
468 }
469 for (i = 0; i < nprocs; ++i) {
470 if ((int)procs[i].kp_pid < 0)
471 continue;
472 if ((int)procs[i].kp_ppid < 0)
473 continue;
474 hv = (int)procs[i].kp_pid & 1023;
475 for (chain = phash[hv]; chain; chain = chain->next) {
476 if (chain->proc->kp_pid == procs[i].kp_pid)
477 break;
478 }
479 hv = (int)procs[i].kp_ppid & 1023;
480 for (pchain = phash[hv]; pchain; pchain = pchain->next) {
481 if (pchain->proc->kp_pid == procs[i].kp_ppid) {
482 if (chain)
483 chain->parent = pchain;
484 break;
485 }
486 }
487 }
488 return (rchain);
489 }
490
491 static
492 int
493 checkparent(struct pchain *chain, pid_t pid)
494 {
495 while (chain) {
496 if (chain->proc->kp_pid == pid)
497 return(1);
498 chain = chain->parent;
499 }
500 return(0);
501 }
DragonFly BSD