1 /* $NetBSD: pkill.c,v 1.7 2004/02/15 17:03:30 soren Exp $ */ 2 /* $DragonFly: src/usr.bin/pkill/pkill.c,v 1.7 2005/02/15 20:31:29 cpressey Exp $ */ 3 4 /*- 5 * Copyright (c) 2002 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Andrew Doran. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <sys/types.h> 41 #include <sys/param.h> 42 #include <sys/sysctl.h> 43 #include <sys/user.h> 44 #include <sys/queue.h> 45 #include <sys/stat.h> 46 #include <sys/fcntl.h> 47 48 #include <stdio.h> 49 #include <stdlib.h> 50 #include <limits.h> 51 #include <paths.h> 52 #include <string.h> 53 #include <unistd.h> 54 #include <signal.h> 55 #include <regex.h> 56 #include <ctype.h> 57 #include <kvm.h> 58 #include <err.h> 59 #include <pwd.h> 60 #include <grp.h> 61 #include <errno.h> 62 63 #define STATUS_MATCH 0 64 #define STATUS_NOMATCH 1 65 #define STATUS_BADUSAGE 2 66 #define STATUS_ERROR 3 67 68 enum listtype { 69 LT_USER, 70 LT_GROUP, 71 LT_TTY, 72 LT_PPID, 73 LT_PGRP, 74 LT_SID 75 }; 76 77 struct list { 78 SLIST_ENTRY(list) li_chain; 79 union { 80 uid_t ld_uid; 81 gid_t ld_gid; 82 pid_t ld_pid; 83 dev_t ld_dev; 84 } li_datum; 85 }; 86 87 SLIST_HEAD(listhead, list); 88 89 struct kinfo_proc *plist; 90 char *selected; 91 const char *delim = "\n"; 92 int nproc; 93 int pgrep; 94 int signum = SIGTERM; 95 int newest; 96 int inverse; 97 int longfmt; 98 int matchargs; 99 int fullmatch; 100 kvm_t *kd; 101 pid_t mypid; 102 103 struct listhead euidlist = SLIST_HEAD_INITIALIZER(list); 104 struct listhead ruidlist = SLIST_HEAD_INITIALIZER(list); 105 struct listhead rgidlist = SLIST_HEAD_INITIALIZER(list); 106 struct listhead pgrplist = SLIST_HEAD_INITIALIZER(list); 107 struct listhead ppidlist = SLIST_HEAD_INITIALIZER(list); 108 struct listhead tdevlist = SLIST_HEAD_INITIALIZER(list); 109 struct listhead sidlist = SLIST_HEAD_INITIALIZER(list); 110 111 void usage(void); 112 void killact(struct kinfo_proc *, int); 113 void grepact(struct kinfo_proc *, int); 114 int parse_pid(const char *, char **, struct list *, pid_t); 115 void makelist(struct listhead *, enum listtype, char *); 116 117 int 118 main(int argc, char **argv) 119 { 120 char buf[_POSIX2_LINE_MAX], *mstr, **pargv, *p, *q; 121 int i, ch, bestidx, rv, criteria; 122 unsigned int j; 123 void (*action)(struct kinfo_proc *, int); 124 struct kinfo_proc *kp; 125 struct list *li; 126 struct timeval best; 127 regex_t reg; 128 regmatch_t regmatch; 129 const char *kvmf = _PATH_DEVNULL; 130 131 if (strcmp(getprogname(), "pgrep") == 0) { 132 action = grepact; 133 pgrep = 1; 134 } else { 135 action = killact; 136 p = argv[1]; 137 138 if (argc > 1 && p[0] == '-') { 139 p++; 140 i = (int)strtol(p, &q, 10); 141 if (*q == '\0') { 142 signum = i; 143 argv++; 144 argc--; 145 } else { 146 if (strncasecmp(p, "sig", 3) == 0) 147 p += 3; 148 for (i = 1; i < NSIG; i++) { 149 if (strcasecmp(sys_signame[i], p) == 0) 150 break; 151 } 152 if (i != NSIG) { 153 signum = i; 154 argv++; 155 argc--; 156 } 157 } 158 } 159 } 160 161 criteria = 0; 162 163 while ((ch = getopt(argc, argv, "G:P:U:d:fg:lns:t:u:vx")) != -1) { 164 switch (ch) { 165 case 'G': 166 makelist(&rgidlist, LT_GROUP, optarg); 167 criteria = 1; 168 break; 169 case 'P': 170 makelist(&ppidlist, LT_PPID, optarg); 171 criteria = 1; 172 break; 173 case 'U': 174 makelist(&ruidlist, LT_USER, optarg); 175 criteria = 1; 176 break; 177 case 'd': 178 if (!pgrep) 179 usage(); 180 delim = optarg; 181 break; 182 case 'f': 183 matchargs = 1; 184 break; 185 case 'g': 186 makelist(&pgrplist, LT_PGRP, optarg); 187 criteria = 1; 188 break; 189 case 'l': 190 if (!pgrep) 191 usage(); 192 longfmt = 1; 193 break; 194 case 'n': 195 newest = 1; 196 criteria = 1; 197 break; 198 case 's': 199 makelist(&sidlist, LT_SID, optarg); 200 criteria = 1; 201 break; 202 case 't': 203 makelist(&tdevlist, LT_TTY, optarg); 204 criteria = 1; 205 break; 206 case 'u': 207 makelist(&euidlist, LT_USER, optarg); 208 criteria = 1; 209 break; 210 case 'v': 211 inverse = 1; 212 break; 213 case 'x': 214 fullmatch = 1; 215 break; 216 default: 217 usage(); 218 /* NOTREACHED */ 219 } 220 } 221 222 argc -= optind; 223 argv += optind; 224 if (argc != 0) 225 criteria = 1; 226 if (!criteria) 227 usage(); 228 229 mypid = getpid(); 230 231 /* 232 * Retrieve the list of running processes from the kernel. 233 */ 234 kd = kvm_openfiles(kvmf, kvmf, NULL, O_RDONLY, buf); 235 if (kd == NULL) 236 errx(STATUS_ERROR, "kvm_openfiles(): %s", buf); 237 238 plist = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc); 239 if (plist == NULL) 240 errx(STATUS_ERROR, "cannot list processes"); 241 242 /* 243 * Allocate memory which will be used to keep track of the 244 * selection. 245 */ 246 if ((selected = malloc(nproc)) == NULL) 247 errx(STATUS_ERROR, "memory allocation failure"); 248 memset(selected, 0, nproc); 249 250 /* 251 * Refine the selection. 252 */ 253 for (; *argv != NULL; argv++) { 254 if ((rv = regcomp(®, *argv, REG_EXTENDED)) != 0) { 255 regerror(rv, ®, buf, sizeof(buf)); 256 errx(STATUS_BADUSAGE, "bad expression: %s", buf); 257 } 258 259 for (i = 0, kp = plist; i < nproc; i++, kp++) { 260 if ((kp->kp_proc.p_flag & P_SYSTEM) != 0 || kp->kp_proc.p_pid == mypid) 261 continue; 262 263 if (matchargs) { 264 if ((pargv = kvm_getargv(kd, kp, 0)) == NULL) 265 continue; 266 267 j = 0; 268 while (j < sizeof(buf) && *pargv != NULL) { 269 j += snprintf(buf + j, sizeof(buf) - j, 270 pargv[1] != NULL ? "%s " : "%s", 271 pargv[0]); 272 pargv++; 273 } 274 275 mstr = buf; 276 } else 277 mstr = kp->kp_thread.td_comm; 278 279 rv = regexec(®, mstr, 1, ®match, 0); 280 if (rv == 0) { 281 if (fullmatch) { 282 if (regmatch.rm_so == 0 && 283 regmatch.rm_eo == strlen(mstr)) 284 selected[i] = 1; 285 } else 286 selected[i] = 1; 287 } else if (rv != REG_NOMATCH) { 288 regerror(rv, ®, buf, sizeof(buf)); 289 errx(STATUS_ERROR, "regexec(): %s", buf); 290 } 291 } 292 293 regfree(®); 294 } 295 296 for (i = 0, kp = plist; i < nproc; i++, kp++) { 297 if ((kp->kp_proc.p_flag & P_SYSTEM) != 0) 298 continue; 299 300 SLIST_FOREACH(li, &ruidlist, li_chain) { 301 if (kp->kp_eproc.e_ucred.cr_ruid == li->li_datum.ld_uid) 302 break; 303 } 304 if (SLIST_FIRST(&ruidlist) != NULL && li == NULL) { 305 selected[i] = 0; 306 continue; 307 } 308 309 SLIST_FOREACH(li, &rgidlist, li_chain) { 310 if (kp->kp_eproc.e_ucred.cr_rgid == li->li_datum.ld_gid) 311 break; 312 } 313 if (SLIST_FIRST(&rgidlist) != NULL && li == NULL) { 314 selected[i] = 0; 315 continue; 316 } 317 318 SLIST_FOREACH(li, &euidlist, li_chain) { 319 if (kp->kp_eproc.e_ucred.cr_uid == li->li_datum.ld_uid) 320 break; 321 } 322 if (SLIST_FIRST(&euidlist) != NULL && li == NULL) { 323 selected[i] = 0; 324 continue; 325 } 326 327 SLIST_FOREACH(li, &ppidlist, li_chain) { 328 if (kp->kp_eproc.e_ppid == li->li_datum.ld_pid) 329 break; 330 } 331 if (SLIST_FIRST(&ppidlist) != NULL && li == NULL) { 332 selected[i] = 0; 333 continue; 334 } 335 336 SLIST_FOREACH(li, &pgrplist, li_chain) { 337 if (kp->kp_eproc.e_pgid == li->li_datum.ld_pid) 338 break; 339 } 340 if (SLIST_FIRST(&pgrplist) != NULL && li == NULL) { 341 selected[i] = 0; 342 continue; 343 } 344 345 SLIST_FOREACH(li, &tdevlist, li_chain) { 346 if (li->li_datum.ld_dev == NODEV && 347 (kp->kp_proc.p_flag & P_CONTROLT) == 0) 348 break; 349 if (kp->kp_eproc.e_tdev == li->li_datum.ld_dev) 350 break; 351 } 352 if (SLIST_FIRST(&tdevlist) != NULL && li == NULL) { 353 selected[i] = 0; 354 continue; 355 } 356 357 SLIST_FOREACH(li, &sidlist, li_chain) { 358 if (kp->kp_eproc.e_sess->s_sid == li->li_datum.ld_pid) 359 break; 360 } 361 if (SLIST_FIRST(&sidlist) != NULL && li == NULL) { 362 selected[i] = 0; 363 continue; 364 } 365 366 if (argc == 0) 367 selected[i] = 1; 368 } 369 370 if (newest) { 371 best.tv_sec = 0; 372 best.tv_usec = 0; 373 bestidx = -1; 374 375 for (i = 0, kp = plist; i < nproc; i++, kp++) { 376 if (!selected[i]) 377 continue; 378 379 if (kp->kp_thread.td_start.tv_sec > best.tv_sec || 380 (kp->kp_thread.td_start.tv_sec == best.tv_sec 381 && kp->kp_thread.td_start.tv_usec > best.tv_usec)) { 382 best.tv_sec = kp->kp_thread.td_start.tv_sec; 383 best.tv_usec = kp->kp_thread.td_start.tv_usec; 384 bestidx = i; 385 } 386 } 387 388 memset(selected, 0, nproc); 389 if (bestidx != -1) 390 selected[bestidx] = 1; 391 } 392 393 /* 394 * Take the appropriate action for each matched process, if any. 395 */ 396 for (i = 0, j = 0, rv = 0, kp = plist; i < nproc; i++, kp++) { 397 if (kp->kp_proc.p_pid == mypid) 398 continue; 399 if (selected[i]) { 400 if (inverse) 401 continue; 402 } else if (!inverse) 403 continue; 404 405 if ((kp->kp_proc.p_flag & P_SYSTEM) != 0) 406 continue; 407 408 rv = 1; 409 (*action)(kp, j++); 410 } 411 412 if (pgrep) 413 putchar('\n'); 414 415 exit(rv ? STATUS_MATCH : STATUS_NOMATCH); 416 } 417 418 void 419 usage(void) 420 { 421 const char *ustr; 422 423 if (pgrep) 424 ustr = "[-flnvx] [-d delim]"; 425 else 426 ustr = "[-signal] [-fnvx]"; 427 428 fprintf(stderr, 429 "usage: %s %s [-G gid] [-P ppid] [-U uid] [-g pgrp] [-s sid]\n" 430 " [-t tty] [-u euid] pattern ...\n", getprogname(), 431 ustr); 432 433 exit(STATUS_ERROR); 434 } 435 436 void 437 killact(struct kinfo_proc *kp, int dummy) 438 { 439 dummy = 0; /* unused */ 440 441 if (kill(kp->kp_proc.p_pid, signum) == -1) 442 err(STATUS_ERROR, "signalling pid %d", (int)kp->kp_proc.p_pid); 443 } 444 445 void 446 grepact(struct kinfo_proc *kp, int printdelim) 447 { 448 char **argv; 449 450 if (printdelim) 451 fputs(delim, stdout); 452 453 if (longfmt && matchargs) { 454 if ((argv = kvm_getargv(kd, kp, 0)) == NULL) 455 return; 456 457 printf("%d ", (int)kp->kp_proc.p_pid); 458 for (; *argv != NULL; argv++) { 459 printf("%s", *argv); 460 if (argv[1] != NULL) 461 putchar(' '); 462 } 463 } else if (longfmt) 464 printf("%d %s", (int)kp->kp_proc.p_pid, kp->kp_thread.td_comm); 465 else 466 printf("%d", (int)kp->kp_proc.p_pid); 467 468 } 469 470 int 471 parse_pid(const char *string, char **p, struct list *li, pid_t default_pid) 472 { 473 long l; 474 475 l = strtol(string, p, 0); 476 li->li_datum.ld_pid = (l == 0 ? default_pid : (pid_t)l); 477 return(**p == '\0'); 478 } 479 480 void 481 makelist(struct listhead *head, enum listtype type, char *src) 482 { 483 struct list *li; 484 struct passwd *pw; 485 struct group *gr; 486 struct stat st; 487 const char *sp, *tty_name; 488 char *p, buf[MAXPATHLEN]; 489 int empty; 490 491 empty = 1; 492 493 while ((sp = strsep(&src, ",")) != NULL) { 494 if (*sp == '\0') 495 usage(); 496 497 if ((li = malloc(sizeof(*li))) == NULL) 498 errx(STATUS_ERROR, "memory allocation failure"); 499 SLIST_INSERT_HEAD(head, li, li_chain); 500 empty = 0; 501 502 switch (type) { 503 case LT_PPID: 504 if (!parse_pid(sp, &p, li, (pid_t)0)) 505 usage(); 506 break; 507 case LT_PGRP: 508 if (!parse_pid(sp, &p, li, getpgrp())) 509 usage(); 510 break; 511 case LT_SID: 512 if (!parse_pid(sp, &p, li, getsid(mypid))) 513 usage(); 514 break; 515 case LT_USER: 516 li->li_datum.ld_uid = (uid_t)strtol(sp, &p, 0); 517 if (*p != '\0') { 518 if ((pw = getpwnam(sp)) == NULL) { 519 errx(STATUS_BADUSAGE, 520 "unknown user `%s'", optarg); 521 } 522 li->li_datum.ld_uid = pw->pw_uid; 523 } 524 break; 525 case LT_GROUP: 526 li->li_datum.ld_gid = (gid_t)strtol(sp, &p, 0); 527 if (*p != '\0') { 528 if ((gr = getgrnam(sp)) == NULL) { 529 errx(STATUS_BADUSAGE, 530 "unknown group `%s'", optarg); 531 } 532 li->li_datum.ld_gid = gr->gr_gid; 533 } 534 break; 535 case LT_TTY: 536 if (strcmp(sp, "-") == 0) { 537 li->li_datum.ld_dev = NODEV; 538 break; 539 } else if (strcmp(sp, "co") == 0) 540 tty_name = "console"; 541 else if (strncmp(sp, "tty", 3) == 0) 542 tty_name = sp; 543 else 544 tty_name = NULL; 545 546 if (tty_name == NULL) 547 snprintf(buf, sizeof(buf), "/dev/tty%s", sp); 548 else 549 snprintf(buf, sizeof(buf), "/dev/%s", tty_name); 550 551 if (stat(buf, &st) < 0) { 552 if (errno == ENOENT) 553 errx(STATUS_BADUSAGE, 554 "no such tty: `%s'", sp); 555 err(STATUS_ERROR, "stat(%s)", sp); 556 } 557 558 if ((st.st_mode & S_IFCHR) == 0) 559 errx(STATUS_BADUSAGE, "not a tty: `%s'", sp); 560 561 li->li_datum.ld_dev = st.st_rdev; 562 break; 563 default: 564 usage(); 565 } 566 } 567 568 if (empty) 569 usage(); 570 } 571