usr.bin/pkill/pkill.c

   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.3 2004/10/25 21:48:37 liamfoy 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_GENERIC,
  70         LT_USER,
  71         LT_GROUP,
  72         LT_TTY,
  73         LT_PGRP,
  74         LT_SID
  75 };
  76
  77 struct list {
  78         SLIST_ENTRY(list) li_chain;
  79         long    li_number;
  80 };
  81
  82 SLIST_HEAD(listhead, list);
  83
  84 struct kinfo_proc       *plist;
  85 char    *selected;
  86 char    *delim = "\n";
  87 int     nproc;
  88 int     pgrep;
  89 int     signum = SIGTERM;
  90 int     newest;
  91 int     inverse;
  92 int     longfmt;
  93 int     matchargs;
  94 int     fullmatch;
  95 kvm_t   *kd;
  96 pid_t   mypid;
  97
  98 struct listhead euidlist = SLIST_HEAD_INITIALIZER(list);
  99 struct listhead ruidlist = SLIST_HEAD_INITIALIZER(list);
 100 struct listhead rgidlist = SLIST_HEAD_INITIALIZER(list);
 101 struct listhead pgrplist = SLIST_HEAD_INITIALIZER(list);
 102 struct listhead ppidlist = SLIST_HEAD_INITIALIZER(list);
 103 struct listhead tdevlist = SLIST_HEAD_INITIALIZER(list);
 104 struct listhead sidlist = SLIST_HEAD_INITIALIZER(list);
 105
 106 void    usage(void);
 107 void    killact(struct kinfo_proc *);
 108 void    grepact(struct kinfo_proc *);
 109 void    makelist(struct listhead *, enum listtype, char *);
 110
 111 int
 112 main(int argc, char **argv)
 113 {
 114         extern char *optarg;
 115         extern int optind;
 116         char buf[_POSIX2_LINE_MAX], *mstr, **pargv, *p, *q;
 117         int i, j, ch, bestidx, rv, criteria;
 118         void (*action)(struct kinfo_proc *);
 119         struct kinfo_proc *kp;
 120         struct list *li;
 121         u_int32_t bestsec, bestusec;
 122         regex_t reg;
 123         regmatch_t regmatch;
 124         const char *kvmf = _PATH_DEVNULL;
 125
 126         if (strcmp(getprogname(), "pgrep") == 0) {
 127                 action = grepact;
 128                 pgrep = 1;
 129         } else {
 130                 action = killact;
 131                 p = argv[1];
 132
 133                 if (argc > 1 && p[0] == '-') {
 134                         p++;
 135                         i = (int)strtol(p, &q, 10);
 136                         if (*q == '\0') {
 137                                 signum = i;
 138                                 argv++;
 139                                 argc--;
 140                         } else {
 141                                 if (strncasecmp(p, "sig", 3) == 0)
 142                                         p += 3;
 143                                 for (i = 1; i < NSIG; i++)
 144                                         if (strcasecmp(sys_signame[i], p) == 0)
 145                                                 break;
 146                                 if (i != NSIG) {
 147                                         signum = i;
 148                                         argv++;
 149                                         argc--;
 150                                 }
 151                         }
 152                 }
 153         }
 154
 155         criteria = 0;
 156
 157         while ((ch = getopt(argc, argv, "G:P:U:d:fg:lns:t:u:vx")) != -1)
 158                 switch (ch) {
 159                 case 'G':
 160                         makelist(&rgidlist, LT_GROUP, optarg);
 161                         criteria = 1;
 162                         break;
 163                 case 'P':
 164                         makelist(&ppidlist, LT_GENERIC, optarg);
 165                         criteria = 1;
 166                         break;
 167                 case 'U':
 168                         makelist(&ruidlist, LT_USER, optarg);
 169                         criteria = 1;
 170                         break;
 171                 case 'd':
 172                         if (!pgrep)
 173                                 usage();
 174                         delim = optarg;
 175                         break;
 176                 case 'f':
 177                         matchargs = 1;
 178                         break;
 179                 case 'g':
 180                         makelist(&pgrplist, LT_PGRP, optarg);
 181                         criteria = 1;
 182                         break;
 183                 case 'l':
 184                         if (!pgrep)
 185                                 usage();
 186                         longfmt = 1;
 187                         break;
 188                 case 'n':
 189                         newest = 1;
 190                         criteria = 1;
 191                         break;
 192                 case 's':
 193                         makelist(&sidlist, LT_SID, optarg);
 194                         criteria = 1;
 195                         break;
 196                 case 't':
 197                         makelist(&tdevlist, LT_TTY, optarg);
 198                         criteria = 1;
 199                         break;
 200                 case 'u':
 201                         makelist(&euidlist, LT_USER, optarg);
 202                         criteria = 1;
 203                         break;
 204                 case 'v':
 205                         inverse = 1;
 206                         break;
 207                 case 'x':
 208                         fullmatch = 1;
 209                         break;
 210                 default:
 211                         usage();
 212                         /* NOTREACHED */
 213                 }
 214
 215         argc -= optind;
 216         argv += optind;
 217         if (argc != 0)
 218                 criteria = 1;
 219         if (!criteria)
 220                 usage();
 221
 222         mypid = getpid();
 223
 224         /*
 225          * Retrieve the list of running processes from the kernel.
 226          */
 227         kd = kvm_openfiles(kvmf, kvmf, NULL, O_RDONLY, buf);
 228         if (kd == NULL)
 229                 errx(STATUS_ERROR, "kvm_openfiles(): %s", buf);
 230
 231         plist = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc);
 232         if (plist == NULL)
 233                 errx(STATUS_ERROR, "cannot list processes");
 234
 235         /*
 236          * Allocate memory which will be used to keep track of the
 237          * selection.
 238          */
 239         if ((selected = malloc(nproc)) == NULL)
 240                 errx(STATUS_ERROR, "memory allocation failure");
 241         memset(selected, 0, nproc);
 242
 243         /*
 244          * Refine the selection.
 245          */
 246         for (; *argv != NULL; argv++) {
 247                 if ((rv = regcomp(&reg, *argv, REG_EXTENDED)) != 0) {
 248                         regerror(rv, &reg, buf, sizeof(buf));
 249                         errx(STATUS_BADUSAGE, "bad expression: %s", buf);
 250                 }
 251
 252                 for (i = 0, kp = plist; i < nproc; i++, kp++) {
 253                         if ((kp->kp_proc.p_flag & P_SYSTEM) != 0 || kp->kp_proc.p_pid == mypid)
 254                                 continue;
 255
 256                         if (matchargs) {
 257                                 if ((pargv = kvm_getargv(kd, kp, 0)) == NULL)
 258                                         continue;
 259
 260                                 j = 0;
 261                                 while (j < sizeof(buf) && *pargv != NULL) {
 262                                         j += snprintf(buf + j, sizeof(buf) - j,
 263                                             pargv[1] != NULL ? "%s " : "%s",
 264                                             pargv[0]);
 265                                         pargv++;
 266                                 }
 267
 268                                 mstr = buf;
 269                         } else
 270                                 mstr = kp->kp_thread.td_comm;
 271
 272                         rv = regexec(&reg, mstr, 1, &regmatch, 0);
 273                         if (rv == 0) {
 274                                 if (fullmatch) {
 275                                         if (regmatch.rm_so == 0 &&
 276                                             regmatch.rm_eo == strlen(mstr))
 277                                                 selected[i] = 1;
 278                                 } else
 279                                         selected[i] = 1;
 280                         } else if (rv != REG_NOMATCH) {
 281                                 regerror(rv, &reg, buf, sizeof(buf));
 282                                 errx(STATUS_ERROR, "regexec(): %s", buf);
 283                         }
 284                 }
 285
 286                 regfree(&reg);
 287         }
 288
 289         for (i = 0, kp = plist; i < nproc; i++, kp++) {
 290                 if ((kp->kp_proc.p_flag & P_SYSTEM) != 0)
 291                         continue;
 292
 293                 SLIST_FOREACH(li, &ruidlist, li_chain)
 294                         if (kp->kp_eproc.e_ucred.cr_ruid == (uid_t)li->li_number)
 295                                 break;
 296                 if (SLIST_FIRST(&ruidlist) != NULL && li == NULL) {
 297                         selected[i] = 0;
 298                         continue;
 299                 }
 300
 301                 SLIST_FOREACH(li, &rgidlist, li_chain)
 302                         if (kp->kp_eproc.e_ucred.cr_rgid == (gid_t)li->li_number)
 303                                 break;
 304                 if (SLIST_FIRST(&rgidlist) != NULL && li == NULL) {
 305                         selected[i] = 0;
 306                         continue;
 307                 }
 308
 309                 SLIST_FOREACH(li, &euidlist, li_chain)
 310                         if (kp->kp_eproc.e_ucred.cr_uid == (uid_t)li->li_number)
 311                                 break;
 312                 if (SLIST_FIRST(&euidlist) != NULL && li == NULL) {
 313                         selected[i] = 0;
 314                         continue;
 315                 }
 316
 317                 SLIST_FOREACH(li, &ppidlist, li_chain)
 318                         if (kp->kp_eproc.e_ppid == (uid_t)li->li_number)
 319                                 break;
 320                 if (SLIST_FIRST(&ppidlist) != NULL && li == NULL) {
 321                         selected[i] = 0;
 322                         continue;
 323                 }
 324
 325                 SLIST_FOREACH(li, &pgrplist, li_chain)
 326                         if (kp->kp_eproc.e_pgid == (uid_t)li->li_number)
 327                                 break;
 328                 if (SLIST_FIRST(&pgrplist) != NULL && li == NULL) {
 329                         selected[i] = 0;
 330                         continue;
 331                 }
 332
 333                 SLIST_FOREACH(li, &tdevlist, li_chain) {
 334                         if (li->li_number == -1 &&
 335                             (kp->kp_proc.p_flag & P_CONTROLT) == 0)
 336                                 break;
 337                         if (kp->kp_eproc.e_tdev == (uid_t)li->li_number)
 338                                 break;
 339                 }
 340                 if (SLIST_FIRST(&tdevlist) != NULL && li == NULL) {
 341                         selected[i] = 0;
 342                         continue;
 343                 }
 344
 345                 SLIST_FOREACH(li, &sidlist, li_chain)
 346                         if (kp->kp_eproc.e_sess->s_sid == (uid_t)li->li_number)
 347                                 break;
 348                 if (SLIST_FIRST(&sidlist) != NULL && li == NULL) {
 349                         selected[i] = 0;
 350                         continue;
 351                 }
 352
 353                 if (argc == 0)
 354                         selected[i] = 1;
 355         }
 356
 357         if (newest) {
 358                 bestsec = 0;
 359                 bestusec = 0;
 360                 bestidx = -1;
 361
 362                 for (i = 0, kp = plist; i < nproc; i++, kp++) {
 363                         if (!selected[i])
 364                                 continue;
 365
 366                         if (kp->kp_thread.td_start.tv_sec > bestsec ||
 367                             (kp->kp_thread.td_start.tv_sec == bestsec
 368                             && kp->kp_thread.td_start.tv_usec > bestusec)) {
 369                                 bestsec = kp->kp_thread.td_start.tv_sec;
 370                                 bestusec = kp->kp_thread.td_start.tv_usec;
 371                                 bestidx = i;
 372                         }
 373                 }
 374
 375                 memset(selected, 0, nproc);
 376                 if (bestidx != -1)
 377                         selected[bestidx] = 1;
 378         }
 379
 380         /*
 381          * Take the appropriate action for each matched process, if any.
 382          */
 383         for (i = 0, rv = 0, kp = plist; i < nproc; i++, kp++) {
 384                 if (kp->kp_proc.p_pid == mypid)
 385                         continue;
 386                 if (selected[i]) {
 387                         if (inverse)
 388                                 continue;
 389                 } else if (!inverse)
 390                         continue;
 391
 392                 if ((kp->kp_proc.p_flag & P_SYSTEM) != 0)
 393                         continue;
 394
 395                 rv = 1;
 396                 (*action)(kp);
 397         }
 398
 399         exit(rv ? STATUS_MATCH : STATUS_NOMATCH);
 400 }
 401
 402 void
 403 usage(void)
 404 {
 405         const char *ustr;
 406
 407         if (pgrep)
 408                 ustr = "[-flnvx] [-d delim]";
 409         else
 410                 ustr = "[-signal] [-fnvx]";
 411
 412         fprintf(stderr,
 413                 "usage: %s %s [-G gid] [-P ppid] [-U uid] [-g pgrp] [-s sid]\n"
 414                 "             [-t tty] [-u euid] pattern ...\n", getprogname(),
 415                 ustr);
 416
 417         exit(STATUS_ERROR);
 418 }
 419
 420 void
 421 killact(struct kinfo_proc *kp)
 422 {
 423
 424         if (kill(kp->kp_proc.p_pid, signum) == -1)
 425                 err(STATUS_ERROR, "signalling pid %d", (int)kp->kp_proc.p_pid);
 426 }
 427
 428 void
 429 grepact(struct kinfo_proc *kp)
 430 {
 431         char **argv;
 432
 433         if (longfmt && matchargs) {
 434                 if ((argv = kvm_getargv(kd, kp, 0)) == NULL)
 435                         return;
 436
 437                 printf("%d ", (int)kp->kp_proc.p_pid);
 438                 for (; *argv != NULL; argv++) {
 439                         printf("%s", *argv);
 440                         if (argv[1] != NULL)
 441                                 putchar(' ');
 442                 }
 443         } else if (longfmt)
 444                 printf("%d %s", (int)kp->kp_proc.p_pid, kp->kp_thread.td_comm);
 445         else
 446                 printf("%d", (int)kp->kp_proc.p_pid);
 447
 448         printf("%s", delim);
 449 }
 450
 451 void
 452 makelist(struct listhead *head, enum listtype type, char *src)
 453 {
 454         struct list *li;
 455         struct passwd *pw;
 456         struct group *gr;
 457         struct stat st;
 458         char *sp, *p, buf[MAXPATHLEN];
 459         int empty;
 460
 461         empty = 1;
 462
 463         while ((sp = strsep(&src, ",")) != NULL) {
 464                 if (*sp == '\0')
 465                         usage();
 466
 467                 if ((li = malloc(sizeof(*li))) == NULL)
 468                         errx(STATUS_ERROR, "memory allocation failure");
 469                 SLIST_INSERT_HEAD(head, li, li_chain);
 470                 empty = 0;
 471
 472                 li->li_number = (uid_t)strtol(sp, &p, 0);
 473                 if (*p == '\0') {
 474                         switch (type) {
 475                         case LT_PGRP:
 476                                 if (li->li_number == 0)
 477                                         li->li_number = getpgrp();
 478                                 break;
 479                         case LT_SID:
 480                                 if (li->li_number == 0)
 481                                         li->li_number = getsid(mypid);
 482                                 break;
 483                         case LT_TTY:
 484                                 usage();
 485                         default:
 486                                 break;
 487                         }
 488                         continue;
 489                 }
 490
 491                 switch (type) {
 492                 case LT_USER:
 493                         if ((pw = getpwnam(sp)) == NULL)
 494                                 errx(STATUS_BADUSAGE, "unknown user `%s'",
 495                                     optarg);
 496                         li->li_number = pw->pw_uid;
 497                         break;
 498                 case LT_GROUP:
 499                         if ((gr = getgrnam(sp)) == NULL)
 500                                 errx(STATUS_BADUSAGE, "unknown group `%s'",
 501                                     optarg);
 502                         li->li_number = gr->gr_gid;
 503                         break;
 504                 case LT_TTY:
 505                         if (strcmp(sp, "-") == 0) {
 506                                 li->li_number = -1;
 507                                 break;
 508                         } else if (strcmp(sp, "co") == 0)
 509                                 p = "console";
 510                         else if (strncmp(sp, "tty", 3) == 0)
 511                                 p = sp;
 512                         else
 513                                 p = NULL;
 514
 515                         if (p == NULL)
 516                                 snprintf(buf, sizeof(buf), "/dev/tty%s", sp);
 517                         else
 518                                 snprintf(buf, sizeof(buf), "/dev/%s", p);
 519
 520                         if (stat(buf, &st) < 0) {
 521                                 if (errno == ENOENT)
 522                                         errx(STATUS_BADUSAGE,
 523                                             "no such tty: `%s'", sp);
 524                                 err(STATUS_ERROR, "stat(%s)", sp);
 525                         }
 526
 527                         if ((st.st_mode & S_IFCHR) == 0)
 528                                 errx(STATUS_BADUSAGE, "not a tty: `%s'", sp);
 529
 530                         li->li_number = st.st_rdev;
 531                         break;
 532                 default:
 533                         usage();
 534                 };
 535         }
 536
 537         if (empty)
 538                 usage();
 539 }