plugins/check_procs.c

   1 /*****************************************************************************
   2 *
   3 * Nagios check_procs plugin
   4 *
   5 * License: GPL
   6 * Copyright (c) 2000-2008 Nagios Plugins Development Team
   7 *
   8 * Last Modified: $Date$
   9 *
  10 * Description:
  11 *
  12 * This file contains the check_procs plugin
  13 *
  14 * Checks all processes and generates WARNING or CRITICAL states if the
  15 * specified metric is outside the required threshold ranges. The metric
  16 * defaults to number of processes.  Search filters can be applied to limit
  17 * the processes to check.
  18 *
  19 *
  20 * This program is free software: you can redistribute it and/or modify
  21 * it under the terms of the GNU General Public License as published by
  22 * the Free Software Foundation, either version 3 of the License, or
  23 * (at your option) any later version.
  24 *
  25 * This program is distributed in the hope that it will be useful,
  26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28 * GNU General Public License for more details.
  29 *
  30 * You should have received a copy of the GNU General Public License
  31 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  32 *
  33 * $Id$
  34 *
  35 *****************************************************************************/
  36
  37 const char *progname = "check_procs";
  38 const char *program_name = "check_procs";  /* Required for coreutils libs */
  39 const char *revision = "$Revision$";
  40 const char *copyright = "2000-2008";
  41 const char *email = "nagiosplug-devel@lists.sourceforge.net";
  42
  43 #include "common.h"
  44 #include "popen.h"
  45 #include "utils.h"
  46 #include "regex.h"
  47
  48 #include <pwd.h>
  49
  50 int process_arguments (int, char **);
  51 int validate_arguments (void);
  52 int check_thresholds (int);
  53 int convert_to_seconds (char *);
  54 void print_help (void);
  55 void print_usage (void);
  56
  57 int wmax = -1;
  58 int cmax = -1;
  59 int wmin = -1;
  60 int cmin = -1;
  61
  62 int options = 0; /* bitmask of filter criteria to test against */
  63 #define ALL 1
  64 #define STAT 2
  65 #define PPID 4
  66 #define USER 8
  67 #define PROG 16
  68 #define ARGS 32
  69 #define VSZ  64
  70 #define RSS  128
  71 #define PCPU 256
  72 #define ELAPSED 512
  73 #define EREG_ARGS 1024
  74 /* Different metrics */
  75 char *metric_name;
  76 enum metric {
  77         METRIC_PROCS,
  78         METRIC_VSZ,
  79         METRIC_RSS,
  80         METRIC_CPU,
  81         METRIC_ELAPSED
  82 };
  83 enum metric metric = METRIC_PROCS;
  84
  85 int verbose = 0;
  86 int uid;
  87 pid_t ppid;
  88 int vsz;
  89 int rss;
  90 float pcpu;
  91 char *statopts;
  92 char *prog;
  93 char *args;
  94 regex_t re_args;
  95 char *fmt;
  96 char *fails;
  97 char tmp[MAX_INPUT_BUFFER];
  98
  99
 100
 101 int
 102 main (int argc, char **argv)
 103 {
 104         char *input_buffer;
 105         char *input_line;
 106         char *procprog;
 107
 108         pid_t mypid = 0;
 109         int procuid = 0;
 110         pid_t procpid = 0;
 111         pid_t procppid = 0;
 112         int procvsz = 0;
 113         int procrss = 0;
 114         int procseconds = 0;
 115         float procpcpu = 0;
 116         char procstat[8];
 117         char procetime[MAX_INPUT_BUFFER] = { '\0' };
 118         char *procargs;
 119
 120         const char *zombie = "Z";
 121
 122         int resultsum = 0; /* bitmask of the filter criteria met by a process */
 123         int found = 0; /* counter for number of lines returned in `ps` output */
 124         int procs = 0; /* counter for number of processes meeting filter criteria */
 125         int pos; /* number of spaces before 'args' in `ps` output */
 126         int cols; /* number of columns in ps output */
 127         int expected_cols = PS_COLS - 1;
 128         int warn = 0; /* number of processes in warn state */
 129         int crit = 0; /* number of processes in crit state */
 130         int i = 0;
 131         int result = STATE_UNKNOWN;
 132
 133         setlocale (LC_ALL, "");
 134         bindtextdomain (PACKAGE, LOCALEDIR);
 135         textdomain (PACKAGE);
 136         setlocale(LC_NUMERIC, "POSIX");
 137
 138         input_buffer = malloc (MAX_INPUT_BUFFER);
 139         procprog = malloc (MAX_INPUT_BUFFER);
 140
 141         asprintf (&metric_name, "PROCS");
 142         metric = METRIC_PROCS;
 143
 144         if (process_arguments (argc, argv) == ERROR)
 145                 usage4 (_("Could not parse arguments"));
 146
 147         /* get our pid */
 148         mypid = getpid();
 149
 150         /* Set signal handling and alarm timeout */
 151         if (signal (SIGALRM, popen_timeout_alarm_handler) == SIG_ERR) {
 152                 usage4 (_("Cannot catch SIGALRM"));
 153         }
 154         alarm (timeout_interval);
 155
 156         if (verbose >= 2)
 157                 printf (_("CMD: %s\n"), PS_COMMAND);
 158
 159         child_process = spopen (PS_COMMAND);
 160         if (child_process == NULL) {
 161                 printf (_("Could not open pipe: %s\n"), PS_COMMAND);
 162                 return STATE_UNKNOWN;
 163         }
 164
 165         child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r");
 166         if (child_stderr == NULL)
 167                 printf (_("Could not open stderr for %s\n"), PS_COMMAND);
 168
 169         /* flush first line */
 170         fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
 171         while ( input_buffer[strlen(input_buffer)-1] != '\n' )
 172                 fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
 173
 174         while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
 175                 asprintf (&input_line, "%s", input_buffer);
 176                 while ( input_buffer[strlen(input_buffer)-1] != '\n' ) {
 177                         fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
 178                         asprintf (&input_line, "%s%s", input_line, input_buffer);
 179                 }
 180
 181                 if (verbose >= 3)
 182                         printf ("%s", input_line);
 183
 184                 strcpy (procprog, "");
 185                 asprintf (&procargs, "%s", "");
 186
 187                 cols = sscanf (input_line, PS_FORMAT, PS_VARLIST);
 188
 189                 /* Zombie processes do not give a procprog command */
 190                 if ( cols < expected_cols && strstr(procstat, zombie) ) {
 191                         cols = expected_cols;
 192                 }
 193                 if ( cols >= expected_cols ) {
 194                         resultsum = 0;
 195                         asprintf (&procargs, "%s", input_line + pos);
 196                         strip (procargs);
 197
 198                         /* Some ps return full pathname for command. This removes path */
 199                         strcpy(procprog, base_name(procprog));
 200
 201                         /* we need to convert the elapsed time to seconds */
 202                         procseconds = convert_to_seconds(procetime);
 203
 204                         if (verbose >= 3)
 205                                 printf ("proc#=%d uid=%d vsz=%d rss=%d pid=%d ppid=%d pcpu=%.2f stat=%s etime=%s prog=%s args=%s\n",
 206                                         procs, procuid, procvsz, procrss,
 207                                         procpid, procppid, procpcpu, procstat,
 208                                         procetime, procprog, procargs);
 209
 210                         /* Ignore self */
 211                         if (mypid == procpid) continue;
 212
 213                         if ((options & STAT) && (strstr (statopts, procstat)))
 214                                 resultsum |= STAT;
 215                         if ((options & ARGS) && procargs && (strstr (procargs, args) != NULL))
 216                                 resultsum |= ARGS;
 217                         if ((options & EREG_ARGS) && procargs && (regexec(&re_args, procargs, (size_t) 0, NULL, 0) == 0))
 218                                 resultsum |= EREG_ARGS;
 219                         if ((options & PROG) && procprog && (strcmp (prog, procprog) == 0))
 220                                 resultsum |= PROG;
 221                         if ((options & PPID) && (procppid == ppid))
 222                                 resultsum |= PPID;
 223                         if ((options & USER) && (procuid == uid))
 224                                 resultsum |= USER;
 225                         if ((options & VSZ)  && (procvsz >= vsz))
 226                                 resultsum |= VSZ;
 227                         if ((options & RSS)  && (procrss >= rss))
 228                                 resultsum |= RSS;
 229                         if ((options & PCPU)  && (procpcpu >= pcpu))
 230                                 resultsum |= PCPU;
 231
 232                         found++;
 233
 234                         /* Next line if filters not matched */
 235                         if (!(options == resultsum || options == ALL))
 236                                 continue;
 237
 238                         procs++;
 239                         if (verbose >= 2) {
 240                                 printf ("Matched: uid=%d vsz=%d rss=%d pid=%d ppid=%d pcpu=%.2f stat=%s etime=%s prog=%s args=%s\n",
 241                                         procuid, procvsz, procrss,
 242                                         procpid, procppid, procpcpu, procstat,
 243                                         procetime, procprog, procargs);
 244                         }
 245
 246                         if (metric == METRIC_VSZ)
 247                                 i = check_thresholds (procvsz);
 248                         else if (metric == METRIC_RSS)
 249                                 i = check_thresholds (procrss);
 250                         /* TODO? float thresholds for --metric=CPU */
 251                         else if (metric == METRIC_CPU)
 252                                 i = check_thresholds ((int)procpcpu);
 253                         else if (metric == METRIC_ELAPSED)
 254                                 i = check_thresholds (procseconds);
 255
 256                         if (metric != METRIC_PROCS) {
 257                                 if (i == STATE_WARNING) {
 258                                         warn++;
 259                                         asprintf (&fails, "%s%s%s", fails, (strcmp(fails,"") ? ", " : ""), procprog);
 260                                         result = max_state (result, i);
 261                                 }
 262                                 if (i == STATE_CRITICAL) {
 263                                         crit++;
 264                                         asprintf (&fails, "%s%s%s", fails, (strcmp(fails,"") ? ", " : ""), procprog);
 265                                         result = max_state (result, i);
 266                                 }
 267                         }
 268                 }
 269                 /* This should not happen */
 270                 else if (verbose) {
 271                         printf(_("Not parseable: %s"), input_buffer);
 272                 }
 273         }
 274
 275         /* If we get anything on STDERR, at least set warning */
 276         while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
 277                 if (verbose)
 278                         printf ("STDERR: %s", input_buffer);
 279                 result = max_state (result, STATE_WARNING);
 280                 printf (_("System call sent warnings to stderr\n"));
 281         }
 282
 283         (void) fclose (child_stderr);
 284
 285         /* close the pipe */
 286         if (spclose (child_process)) {
 287                 printf (_("System call returned nonzero status\n"));
 288                 result = max_state (result, STATE_WARNING);
 289         }
 290
 291         if (found == 0) {                                                       /* no process lines parsed so return STATE_UNKNOWN */
 292                 printf (_("Unable to read output\n"));
 293                 return result;
 294         }
 295
 296         if ( result == STATE_UNKNOWN )
 297                 result = STATE_OK;
 298
 299         /* Needed if procs found, but none match filter */
 300         if ( metric == METRIC_PROCS ) {
 301                 result = max_state (result, check_thresholds (procs) );
 302         }
 303
 304         if ( result == STATE_OK ) {
 305                 printf ("%s %s: ", metric_name, _("OK"));
 306         } else if (result == STATE_WARNING) {
 307                 printf ("%s %s: ", metric_name, _("WARNING"));
 308                 if ( metric != METRIC_PROCS ) {
 309                         printf (_("%d warn out of "), warn);
 310                 }
 311         } else if (result == STATE_CRITICAL) {
 312                 printf ("%s %s: ", metric_name, _("CRITICAL"));
 313                 if (metric != METRIC_PROCS) {
 314                         printf (_("%d crit, %d warn out of "), crit, warn);
 315                 }
 316         }
 317         printf (ngettext ("%d process", "%d processes", (unsigned long) procs), procs);
 318
 319         if (strcmp(fmt,"") != 0) {
 320                 printf (_(" with %s"), fmt);
 321         }
 322
 323         if ( verbose >= 1 && strcmp(fails,"") )
 324                 printf (" [%s]", fails);
 325
 326         printf ("\n");
 327         return result;
 328 }
 329
 330
 331
 332 /* process command-line arguments */
 333 int
 334 process_arguments (int argc, char **argv)
 335 {
 336         int c = 1;
 337         char *user;
 338         struct passwd *pw;
 339         int option = 0;
 340         int err;
 341         int cflags = REG_NOSUB | REG_EXTENDED;
 342         char errbuf[MAX_INPUT_BUFFER];
 343         static struct option longopts[] = {
 344                 {"warning", required_argument, 0, 'w'},
 345                 {"critical", required_argument, 0, 'c'},
 346                 {"metric", required_argument, 0, 'm'},
 347                 {"timeout", required_argument, 0, 't'},
 348                 {"status", required_argument, 0, 's'},
 349                 {"ppid", required_argument, 0, 'p'},
 350                 {"command", required_argument, 0, 'C'},
 351                 {"vsz", required_argument, 0, 'z'},
 352                 {"rss", required_argument, 0, 'r'},
 353                 {"pcpu", required_argument, 0, 'P'},
 354                 {"elapsed", required_argument, 0, 'e'},
 355                 {"argument-array", required_argument, 0, 'a'},
 356                 {"help", no_argument, 0, 'h'},
 357                 {"version", no_argument, 0, 'V'},
 358                 {"verbose", no_argument, 0, 'v'},
 359                 {"ereg-argument-array", required_argument, 0, CHAR_MAX+1},
 360                 {0, 0, 0, 0}
 361         };
 362
 363         for (c = 1; c < argc; c++)
 364                 if (strcmp ("-to", argv[c]) == 0)
 365                         strcpy (argv[c], "-t");
 366
 367         while (1) {
 368                 c = getopt_long (argc, argv, "Vvht:c:w:p:s:u:C:a:z:r:m:P:",
 369                         longopts, &option);
 370
 371                 if (c == -1 || c == EOF)
 372                         break;
 373
 374                 switch (c) {
 375                 case '?':                                                                       /* help */
 376                         usage5 ();
 377                 case 'h':                                                                       /* help */
 378                         print_help ();
 379                         exit (STATE_OK);
 380                 case 'V':                                                                       /* version */
 381                         print_revision (progname, revision);
 382                         exit (STATE_OK);
 383                 case 't':                                                                       /* timeout period */
 384                         if (!is_integer (optarg))
 385                                 usage2 (_("Timeout interval must be a positive integer"), optarg);
 386                         else
 387                                 timeout_interval = atoi (optarg);
 388                         break;
 389                 case 'c':                                                                       /* critical threshold */
 390                         if (is_integer (optarg))
 391                                 cmax = atoi (optarg);
 392                         else if (sscanf (optarg, ":%d", &cmax) == 1)
 393                                 break;
 394                         else if (sscanf (optarg, "%d:%d", &cmin, &cmax) == 2)
 395                                 break;
 396                         else if (sscanf (optarg, "%d:", &cmin) == 1)
 397                                 break;
 398                         else
 399                                 usage4 (_("Critical Process Count must be an integer!"));
 400                         break;
 401                 case 'w':                                                                       /* warning threshold */
 402                         if (is_integer (optarg))
 403                                 wmax = atoi (optarg);
 404                         else if (sscanf (optarg, ":%d", &wmax) == 1)
 405                                 break;
 406                         else if (sscanf (optarg, "%d:%d", &wmin, &wmax) == 2)
 407                                 break;
 408                         else if (sscanf (optarg, "%d:", &wmin) == 1)
 409                                 break;
 410                         else
 411                                 usage4 (_("Warning Process Count must be an integer!"));
 412                         break;
 413                 case 'p':                                                                       /* process id */
 414                         if (sscanf (optarg, "%d%[^0-9]", &ppid, tmp) == 1) {
 415                                 asprintf (&fmt, "%s%sPPID = %d", (fmt ? fmt : "") , (options ? ", " : ""), ppid);
 416                                 options |= PPID;
 417                                 break;
 418                         }
 419                         usage4 (_("Parent Process ID must be an integer!"));
 420                 case 's':                                                                       /* status */
 421                         if (statopts)
 422                                 break;
 423                         else
 424                                 statopts = optarg;
 425                         asprintf (&fmt, _("%s%sSTATE = %s"), (fmt ? fmt : ""), (options ? ", " : ""), statopts);
 426                         options |= STAT;
 427                         break;
 428                 case 'u':                                                                       /* user or user id */
 429                         if (is_integer (optarg)) {
 430                                 uid = atoi (optarg);
 431                                 pw = getpwuid ((uid_t) uid);
 432                                 /*  check to be sure user exists */
 433                                 if (pw == NULL)
 434                                         usage2 (_("UID was not found"), optarg);
 435                         }
 436                         else {
 437                                 pw = getpwnam (optarg);
 438                                 /*  check to be sure user exists */
 439                                 if (pw == NULL)
 440                                         usage2 (_("User name was not found"), optarg);
 441                                 /*  then get uid */
 442                                 uid = pw->pw_uid;
 443                         }
 444                         user = pw->pw_name;
 445                         asprintf (&fmt, "%s%sUID = %d (%s)", (fmt ? fmt : ""), (options ? ", " : ""),
 446                                   uid, user);
 447                         options |= USER;
 448                         break;
 449                 case 'C':                                                                       /* command */
 450                         /* TODO: allow this to be passed in with --metric */
 451                         if (prog)
 452                                 break;
 453                         else
 454                                 prog = optarg;
 455                         asprintf (&fmt, _("%s%scommand name '%s'"), (fmt ? fmt : ""), (options ? ", " : ""),
 456                                   prog);
 457                         options |= PROG;
 458                         break;
 459                 case 'a':                                                                       /* args (full path name with args) */
 460                         /* TODO: allow this to be passed in with --metric */
 461                         if (args)
 462                                 break;
 463                         else
 464                                 args = optarg;
 465                         asprintf (&fmt, "%s%sargs '%s'", (fmt ? fmt : ""), (options ? ", " : ""), args);
 466                         options |= ARGS;
 467                         break;
 468                 case CHAR_MAX+1:
 469                         err = regcomp(&re_args, optarg, cflags);
 470                         if (err != 0) {
 471                                 regerror (err, &re_args, errbuf, MAX_INPUT_BUFFER);
 472                                 die (STATE_UNKNOWN, "PROCS %s: %s - %s\n", _("UNKNOWN"), _("Could not compile regular expression"), errbuf);
 473                         }
 474                         asprintf (&fmt, "%s%sregex args '%s'", (fmt ? fmt : ""), (options ? ", " : ""), optarg);
 475                         options |= EREG_ARGS;
 476                         break;
 477                 case 'r':                                       /* RSS */
 478                         if (sscanf (optarg, "%d%[^0-9]", &rss, tmp) == 1) {
 479                                 asprintf (&fmt, "%s%sRSS >= %d", (fmt ? fmt : ""), (options ? ", " : ""), rss);
 480                                 options |= RSS;
 481                                 break;
 482                         }
 483                         usage4 (_("RSS must be an integer!"));
 484                 case 'z':                                       /* VSZ */
 485                         if (sscanf (optarg, "%d%[^0-9]", &vsz, tmp) == 1) {
 486                                 asprintf (&fmt, "%s%sVSZ >= %d", (fmt ? fmt : ""), (options ? ", " : ""), vsz);
 487                                 options |= VSZ;
 488                                 break;
 489                         }
 490                         usage4 (_("VSZ must be an integer!"));
 491                 case 'P':                                       /* PCPU */
 492                         /* TODO: -P 1.5.5 is accepted */
 493                         if (sscanf (optarg, "%f%[^0-9.]", &pcpu, tmp) == 1) {
 494                                 asprintf (&fmt, "%s%sPCPU >= %.2f", (fmt ? fmt : ""), (options ? ", " : ""), pcpu);
 495                                 options |= PCPU;
 496                                 break;
 497                         }
 498                         usage4 (_("PCPU must be a float!"));
 499                 case 'm':
 500                         asprintf (&metric_name, "%s", optarg);
 501                         if ( strcmp(optarg, "PROCS") == 0) {
 502                                 metric = METRIC_PROCS;
 503                                 break;
 504                         }
 505                         else if ( strcmp(optarg, "VSZ") == 0) {
 506                                 metric = METRIC_VSZ;
 507                                 break;
 508                         }
 509                         else if ( strcmp(optarg, "RSS") == 0 ) {
 510                                 metric = METRIC_RSS;
 511                                 break;
 512                         }
 513                         else if ( strcmp(optarg, "CPU") == 0 ) {
 514                                 metric = METRIC_CPU;
 515                                 break;
 516                         }
 517                         else if ( strcmp(optarg, "ELAPSED") == 0) {
 518                                 metric = METRIC_ELAPSED;
 519                                 break;
 520                         }
 521
 522                         usage4 (_("Metric must be one of PROCS, VSZ, RSS, CPU, ELAPSED!"));
 523                 case 'v':                                                                       /* command */
 524                         verbose++;
 525                         break;
 526                 }
 527         }
 528
 529         c = optind;
 530         if (wmax == -1 && argv[c])
 531                 wmax = atoi (argv[c++]);
 532         if (cmax == -1 && argv[c])
 533                 cmax = atoi (argv[c++]);
 534         if (statopts == NULL && argv[c]) {
 535                 asprintf (&statopts, "%s", argv[c++]);
 536                 asprintf (&fmt, _("%s%sSTATE = %s"), (fmt ? fmt : ""), (options ? ", " : ""), statopts);
 537                 options |= STAT;
 538         }
 539
 540         return validate_arguments ();
 541 }
 542
 543
 544
 545 int
 546 validate_arguments ()
 547 {
 548
 549         if (wmax >= 0 && wmin == -1)
 550                 wmin = 0;
 551         if (cmax >= 0 && cmin == -1)
 552                 cmin = 0;
 553         if (wmax >= wmin && cmax >= cmin) {     /* standard ranges */
 554                 if (wmax > cmax && cmax != -1) {
 555                         printf (_("wmax (%d) cannot be greater than cmax (%d)\n"), wmax, cmax);
 556                         return ERROR;
 557                 }
 558                 if (cmin > wmin && wmin != -1) {
 559                         printf (_("wmin (%d) cannot be less than cmin (%d)\n"), wmin, cmin);
 560                         return ERROR;
 561                 }
 562         }
 563
 564 /*      if (wmax == -1 && cmax == -1 && wmin == -1 && cmin == -1) { */
 565 /*              printf ("At least one threshold must be set\n"); */
 566 /*              return ERROR; */
 567 /*      } */
 568
 569         if (options == 0)
 570                 options = ALL;
 571
 572         if (statopts==NULL)
 573                 statopts = strdup("");
 574
 575         if (prog==NULL)
 576                 prog = strdup("");
 577
 578         if (args==NULL)
 579                 args = strdup("");
 580
 581         if (fmt==NULL)
 582                 fmt = strdup("");
 583
 584         if (fails==NULL)
 585                 fails = strdup("");
 586
 587         return options;
 588 }
 589
 590
 591
 592 /* Check thresholds against value */
 593 int
 594 check_thresholds (int value)
 595 {
 596         if (wmax == -1 && cmax == -1 && wmin == -1 && cmin == -1) {
 597                 return OK;
 598         }
 599         else if (cmax >= 0 && cmin >= 0 && cmax < cmin) {
 600                 if (value > cmax && value < cmin)
 601                         return STATE_CRITICAL;
 602         }
 603         else if (cmax >= 0 && value > cmax) {
 604                 return STATE_CRITICAL;
 605         }
 606         else if (cmin >= 0 && value < cmin) {
 607                 return STATE_CRITICAL;
 608         }
 609
 610         if (wmax >= 0 && wmin >= 0 && wmax < wmin) {
 611                 if (value > wmax && value < wmin) {
 612                         return STATE_WARNING;
 613                 }
 614         }
 615         else if (wmax >= 0 && value > wmax) {
 616                 return STATE_WARNING;
 617         }
 618         else if (wmin >= 0 && value < wmin) {
 619                 return STATE_WARNING;
 620         }
 621         return STATE_OK;
 622 }
 623
 624
 625 /* convert the elapsed time to seconds */
 626 int
 627 convert_to_seconds(char *etime) {
 628
 629         char *ptr;
 630         int total;
 631
 632         int hyphcnt;
 633         int coloncnt;
 634         int days;
 635         int hours;
 636         int minutes;
 637         int seconds;
 638
 639         hyphcnt = 0;
 640         coloncnt = 0;
 641         days = 0;
 642         hours = 0;
 643         minutes = 0;
 644         seconds = 0;
 645
 646         for (ptr = etime; *ptr != '\0'; ptr++) {
 647
 648                 if (*ptr == '-') {
 649                         hyphcnt++;
 650                         continue;
 651                 }
 652                 if (*ptr == ':') {
 653                         coloncnt++;
 654                         continue;
 655                 }
 656         }
 657
 658         if (hyphcnt > 0) {
 659                 sscanf(etime, "%d-%d:%d:%d",
 660                                 &days, &hours, &minutes, &seconds);
 661                 /* linux 2.6.5/2.6.6 reporting some processes with infinite
 662                  * elapsed times for some reason */
 663                 if (days == 49710) {
 664                         return 0;
 665                 }
 666         } else {
 667                 if (coloncnt == 2) {
 668                         sscanf(etime, "%d:%d:%d",
 669                                 &hours, &minutes, &seconds);
 670                 } else if (coloncnt == 1) {
 671                         sscanf(etime, "%d:%d",
 672                                 &minutes, &seconds);
 673                 }
 674         }
 675
 676         total = (days * 86400) +
 677                 (hours * 3600) +
 678                 (minutes * 60) +
 679                 seconds;
 680
 681         if (verbose >= 3 && metric == METRIC_ELAPSED) {
 682                         printf("seconds: %d\n", total);
 683         }
 684         return total;
 685 }
 686
 687
 688 void
 689 print_help (void)
 690 {
 691         print_revision (progname, revision);
 692
 693         printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>");
 694         printf (COPYRIGHT, copyright, email);
 695
 696         printf ("%s\n", _("Checks all processes and generates WARNING or CRITICAL states if the specified"));
 697   printf ("%s\n", _("metric is outside the required threshold ranges. The metric defaults to number"));
 698   printf ("%s\n", _("of processes.  Search filters can be applied to limit the processes to check."));
 699
 700   printf ("\n\n");
 701
 702         print_usage ();
 703
 704         printf ("%s\n", _("Required Arguments:"));
 705   printf (" %s\n", "-w, --warning=RANGE");
 706   printf ("   %s\n", _("Generate warning state if metric is outside this range"));
 707   printf (" %s\n", "-c, --critical=RANGE");
 708   printf ("   %s\n", _("Generate critical state if metric is outside this range"));
 709
 710         printf ("%s\n", _("Optional Arguments:"));
 711   printf (" %s\n", "-m, --metric=TYPE");
 712   printf ("  %s\n", _("Check thresholds against metric. Valid types:"));
 713   printf ("  %s\n", _("PROCS   - number of processes (default)"));
 714   printf ("  %s\n", _("VSZ     - virtual memory size"));
 715   printf ("  %s\n", _("RSS     - resident set memory size"));
 716   printf ("  %s\n", _("CPU     - percentage cpu"));
 717 /* only linux etime is support currently */
 718 #if defined( __linux__ )
 719         printf ("  %s\n", _("ELAPSED - time elapsed in seconds"));
 720 #endif /* defined(__linux__) */
 721         printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
 722
 723         printf (" %s\n", "-v, --verbose");
 724   printf ("    %s\n", _("Extra information. Up to 3 verbosity levels"));
 725
 726         printf ("%s\n", "Optional Filters:");
 727   printf (" %s\n", "-s, --state=STATUSFLAGS");
 728   printf ("   %s\n", _("Only scan for processes that have, in the output of `ps`, one or"));
 729   printf ("   %s\n", _("more of the status flags you specify (for example R, Z, S, RS,"));
 730   printf ("   %s\n", _("RSZDT, plus others based on the output of your 'ps' command)."));
 731   printf (" %s\n", "-p, --ppid=PPID");
 732   printf ("   %s\n", _("Only scan for children of the parent process ID indicated."));
 733   printf (" %s\n", "-z, --vsz=VSZ");
 734   printf ("   %s\n", _("Only scan for processes with vsz higher than indicated."));
 735   printf (" %s\n", "-r, --rss=RSS");
 736   printf ("   %s\n", _("Only scan for processes with rss higher than indicated."));
 737         printf (" %s\n", "-P, --pcpu=PCPU");
 738   printf ("   %s\n", _("Only scan for processes with pcpu higher than indicated."));
 739   printf (" %s\n", "-u, --user=USER");
 740   printf ("   %s\n", _("Only scan for processes with user name or ID indicated."));
 741   printf (" %s\n", "-a, --argument-array=STRING");
 742   printf ("   %s\n", _("Only scan for processes with args that contain STRING."));
 743   printf (" %s\n", "--ereg-argument-array=STRING");
 744   printf ("   %s\n", _("Only scan for processes with args that contain the regex STRING."));
 745   printf (" %s\n", "-C, --command=COMMAND");
 746   printf ("   %s\n", _("Only scan for exact matches of COMMAND (without path)."));
 747
 748         printf(_("\n\
 749 RANGEs are specified 'min:max' or 'min:' or ':max' (or 'max'). If\n\
 750 specified 'max:min', a warning status will be generated if the\n\
 751 count is inside the specified range\n\n"));
 752
 753         printf(_("\
 754 This plugin checks the number of currently running processes and\n\
 755 generates WARNING or CRITICAL states if the process count is outside\n\
 756 the specified threshold ranges. The process count can be filtered by\n\
 757 process owner, parent process PID, current state (e.g., 'Z'), or may\n\
 758 be the total number of running processes\n\n"));
 759
 760         printf ("%s\n", _("Examples:"));
 761   printf (" %s\n", "check_procs -w 2:2 -c 2:1024 -C portsentry");
 762   printf ("  %s\n", _("Warning if not two processes with command name portsentry."));
 763   printf ("  %s\n\n", _("Critical if < 2 or > 1024 processes"));
 764   printf (" %s\n", "check_procs -w 10 -a '/usr/local/bin/perl' -u root");
 765   printf ("  %s\n", _("Warning alert if > 10 processes with command arguments containing"));
 766   printf ("  %s\n\n", _("'/usr/local/bin/perl' and owned by root"));
 767   printf (" %s\n", "check_procs -w 50000 -c 100000 --metric=VSZ");
 768   printf ("  %s\n\n", _("Alert if vsz of any processes over 50K or 100K"));
 769   printf (" %s\n", "check_procs -w 10 -c 20 --metric=CPU");
 770   printf ("  %s\n\n", _("Alert if cpu of any processes over 10%% or 20%%"));
 771
 772         printf (_(UT_SUPPORT));
 773 }
 774
 775 void
 776 print_usage (void)
 777 {
 778   printf (_("Usage: "));
 779         printf ("%s -w <range> -c <range> [-m metric] [-s state] [-p ppid]\n", progname);
 780   printf (" [-u user] [-r rss] [-z vsz] [-P %%cpu] [-a argument-array]\n");
 781   printf (" [-C command] [-t timeout] [-v]\n");
 782 }