procps/pgrep.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini pgrep/pkill implementation for busybox
   4  *
   5  * Copyright (C) 2007 Loic Grenie <loic.grenie@gmail.com>
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8  */
   9 //config:config PGREP
  10 //config:       bool "pgrep (6.5 kb)"
  11 //config:       default y
  12 //config:       help
  13 //config:       Look for processes by name.
  14 //config:
  15 //config:config PKILL
  16 //config:       bool "pkill (7.5 kb)"
  17 //config:       default y
  18 //config:       help
  19 //config:       Send signals to processes by name.
  20
  21 //applet:IF_PGREP(APPLET_ODDNAME(pgrep, pgrep, BB_DIR_USR_BIN, BB_SUID_DROP, pgrep))
  22 //                APPLET_ODDNAME:name   main   location        suid_type     help
  23 //applet:IF_PKILL(APPLET_ODDNAME(pkill, pgrep, BB_DIR_USR_BIN, BB_SUID_DROP, pkill))
  24 /* can't be noexec: can find _itself_ under wrong name, since after fork only,
  25  * /proc/PID/cmdline and comm are wrong! Can fix comm (prctl(PR_SET_NAME)),
  26  * but cmdline?
  27  */
  28
  29 //kbuild:lib-$(CONFIG_PGREP) += pgrep.o
  30 //kbuild:lib-$(CONFIG_PKILL) += pgrep.o
  31
  32 //usage:#define pgrep_trivial_usage
  33 //usage:       "[-flanovx] [-s SID|-P PPID|PATTERN]"
  34 //usage:#define pgrep_full_usage "\n\n"
  35 //usage:       "Display process(es) selected by regex PATTERN\n"
  36 //usage:     "\n        -l      Show command name too"
  37 //usage:     "\n        -a      Show command line too"
  38 //usage:     "\n        -f      Match against entire command line"
  39 //usage:     "\n        -n      Show the newest process only"
  40 //usage:     "\n        -o      Show the oldest process only"
  41 //usage:     "\n        -v      Negate the match"
  42 //usage:     "\n        -x      Match whole name (not substring)"
  43 //usage:     "\n        -s      Match session ID (0 for current)"
  44 //usage:     "\n        -P      Match parent process ID"
  45 //usage:
  46 //usage:#define pkill_trivial_usage
  47 //usage:       "[-l|-SIGNAL] [-fnovx] [-s SID|-P PPID|PATTERN]"
  48 //usage:#define pkill_full_usage "\n\n"
  49 //usage:       "Send a signal to process(es) selected by regex PATTERN\n"
  50 //usage:     "\n        -l      List all signals"
  51 //usage:     "\n        -f      Match against entire command line"
  52 //usage:     "\n        -n      Signal the newest process only"
  53 //usage:     "\n        -o      Signal the oldest process only"
  54 //usage:     "\n        -v      Negate the match"
  55 //usage:     "\n        -x      Match whole name (not substring)"
  56 //usage:     "\n        -s      Match session ID (0 for current)"
  57 //usage:     "\n        -P      Match parent process ID"
  58
  59 #include "libbb.h"
  60 #include "xregex.h"
  61
  62 /* Idea taken from kill.c */
  63 #define pgrep (ENABLE_PGREP && (!ENABLE_PKILL || applet_name[1] == 'g'))
  64 #define pkill (ENABLE_PKILL && (!ENABLE_PGREP || applet_name[1] == 'k'))
  65
  66 enum {
  67         /* "vlafxons:+P:+" */
  68         OPTBIT_V = 0, /* must be first, we need OPT_INVERT = 0/1 */
  69         OPTBIT_L,
  70         OPTBIT_A,
  71         OPTBIT_F,
  72         OPTBIT_X,
  73         OPTBIT_O,
  74         OPTBIT_N,
  75         OPTBIT_S,
  76         OPTBIT_P,
  77 };
  78
  79 #define OPT_INVERT      (opt & (1 << OPTBIT_V))
  80 #define OPT_LIST        (opt & (1 << OPTBIT_L))
  81 #define OPT_LISTFULL    (opt & (1 << OPTBIT_A))
  82 #define OPT_FULL        (opt & (1 << OPTBIT_F))
  83 #define OPT_ANCHOR      (opt & (1 << OPTBIT_X))
  84 #define OPT_FIRST       (opt & (1 << OPTBIT_O))
  85 #define OPT_LAST        (opt & (1 << OPTBIT_N))
  86 #define OPT_SID         (opt & (1 << OPTBIT_S))
  87 #define OPT_PPID        (opt & (1 << OPTBIT_P))
  88
  89 static void act(unsigned pid, char *cmd, int signo)
  90 {
  91         if (pgrep) {
  92                 if (option_mask32 & ((1 << OPTBIT_L)|(1 << OPTBIT_A))) /* -l or -a */
  93                         printf("%u %s\n", pid, cmd);
  94                 else
  95                         printf("%u\n", pid);
  96         } else
  97                 kill(pid, signo);
  98 }
  99
 100 int pgrep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 101 int pgrep_main(int argc UNUSED_PARAM, char **argv)
 102 {
 103         unsigned pid;
 104         int signo;
 105         unsigned opt;
 106         int scan_mask;
 107         int matched_pid;
 108         int sid2match, ppid2match;
 109         char *cmd_last;
 110         procps_status_t *proc;
 111         /* These are initialized to 0 */
 112         struct {
 113                 regex_t re_buffer;
 114                 regmatch_t re_match[1];
 115         } Z;
 116 #define re_buffer (Z.re_buffer)
 117 #define re_match  (Z.re_match )
 118
 119         memset(&Z, 0, sizeof(Z));
 120
 121         /* Parse -SIGNAL for pkill. Must be first option, if present */
 122         signo = SIGTERM;
 123         if (pkill && argv[1] && argv[1][0] == '-') {
 124                 int temp = get_signum(argv[1]+1);
 125                 if (temp != -1) {
 126                         signo = temp;
 127                         argv++;
 128                 }
 129         }
 130
 131         /* Parse remaining options */
 132         ppid2match = -1;
 133         sid2match = -1;
 134         opt = getopt32(argv, "vlafxons:+P:+", &sid2match, &ppid2match);
 135         argv += optind;
 136
 137         if (pkill && OPT_LIST) { /* -l: print the whole signal list */
 138                 print_signames();
 139                 return 0;
 140         }
 141
 142         pid = getpid();
 143         if (sid2match == 0)
 144                 sid2match = getsid(pid);
 145
 146         scan_mask = PSSCAN_COMM | PSSCAN_ARGV0;
 147         if (OPT_FULL)
 148                 scan_mask |= PSSCAN_ARGVN;
 149
 150         /* One pattern is required, if no -s and no -P */
 151         if ((sid2match & ppid2match) < 0 && (!argv[0] || argv[1]))
 152                 bb_show_usage();
 153
 154         if (argv[0])
 155                 xregcomp(&re_buffer, argv[0], OPT_ANCHOR ? REG_EXTENDED : (REG_EXTENDED|REG_NOSUB));
 156
 157         matched_pid = 0;
 158         cmd_last = NULL;
 159         proc = NULL;
 160         while ((proc = procps_scan(proc, scan_mask)) != NULL) {
 161                 char *cmd;
 162                 int cmdlen, match;
 163
 164                 if (proc->pid == pid)
 165                         continue;
 166
 167                 if (!OPT_INVERT) {
 168                         /* Quickly reject -sN -PN mismatches... unless -v */
 169                         if (ppid2match >= 0 && ppid2match != proc->ppid)
 170                                 continue;
 171                         if (sid2match >= 0 && sid2match != proc->sid)
 172                                 continue;
 173                 }
 174
 175                 cmdlen = -1;
 176                 cmd = proc->argv0;
 177                 if (!cmd) {
 178                         cmd = proc->comm;
 179                 } else {
 180                         int i = proc->argv_len;
 181
 182                         if (!OPT_LISTFULL)
 183                                 cmdlen = strlen(cmd); /* not -a: find first NUL */
 184                         /*
 185                          * "sleep 11" looks like "sleep""\0""11""\0" in argv0.
 186                          * Make sure last "\0" does not get converted to " ":
 187                          */
 188                         if (i && cmd[i-1] == '\0')
 189                                 i--;
 190                         while (--i >= 0) {
 191                                 if ((unsigned char)cmd[i] < ' ')
 192                                         cmd[i] = ' ';
 193                         }
 194                 }
 195
 196                 if (OPT_INVERT) {
 197                         /* "pgrep -v -P1 firefox" means "not (ppid=1 AND name=firefox)"
 198                          * or equivalently "ppid!=1 OR name!=firefox".
 199                          * Check the first condition and if true, skip matching.
 200                          */
 201                         if (ppid2match >= 0 && ppid2match != proc->ppid)
 202                                 goto got_it;
 203                         if (sid2match >= 0 && sid2match != proc->sid)
 204                                 goto got_it;
 205                 }
 206
 207                 match = !argv[0]; /* if no PATTERN, then it's a match, else... */
 208                 if (!match) {
 209  again:
 210                         match = (regexec(&re_buffer, cmd, 1, re_match, 0) == 0);
 211                         if (!match && cmd != proc->comm) {
 212                                 /* if argv[] did not match, try comm */
 213                                 cmdlen = -1;
 214                                 cmd = proc->comm;
 215                                 goto again;
 216                         }
 217                         if (match && OPT_ANCHOR) {
 218                                 /* -x requires full string match */
 219                                 match = (re_match[0].rm_so == 0 && cmd[re_match[0].rm_eo] == '\0');
 220                         }
 221                 }
 222
 223                 /* NB: OPT_INVERT is always 0 or 1 */
 224                 if (match ^ OPT_INVERT) {
 225  got_it:
 226                         matched_pid = proc->pid;
 227                         if (OPT_LAST) {
 228                                 free(cmd_last);
 229                                 cmd_last = xstrdup(cmd);
 230                                 continue;
 231                         }
 232                         if (cmdlen >= 0)
 233                                 cmd[cmdlen] = '\0';
 234                         act(proc->pid, cmd, signo);
 235                         if (OPT_FIRST)
 236                                 break;
 237                 }
 238         }
 239
 240         if (cmd_last) {
 241                 act(matched_pid, cmd_last, signo);
 242                 if (ENABLE_FEATURE_CLEAN_UP)
 243                         free(cmd_last);
 244         }
 245         return matched_pid == 0; /* return 1 if no processes listed/signaled */
 246 }