plugins/check_nagios.c

   1 /*****************************************************************************
   2 *
   3 * Nagios check_nagios plugin
   4 *
   5 * License: GPL
   6 * Copyright (c) 1999-2007 Nagios Plugins Development Team
   7 *
   8 * Last Modified: $Date$
   9 *
  10 * Description:
  11 *
  12 * This file contains the check_nagios plugin
  13 *
  14 * This plugin checks the status of the Nagios process on the local machine.
  15 * The plugin will check to make sure the Nagios status log is no older than
  16 * the number of minutes specified by the expires option.
  17 * It also checks the process table for a process matching the command
  18 * argument.
  19 *
  20 *
  21 * This program is free software: you can redistribute it and/or modify
  22 * it under the terms of the GNU General Public License as published by
  23 * the Free Software Foundation, either version 3 of the License, or
  24 * (at your option) any later version.
  25 *
  26 * This program is distributed in the hope that it will be useful,
  27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29 * GNU General Public License for more details.
  30 *
  31 * You should have received a copy of the GNU General Public License
  32 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  33 *
  34 * $Id$
  35 *
  36 *****************************************************************************/
  37
  38 const char *progname = "check_nagios";
  39 const char *revision = "$Revision$";
  40 const char *copyright = "1999-2007";
  41 const char *email = "nagiosplug-devel@lists.sourceforge.net";
  42
  43 #include "common.h"
  44 #include "runcmd.h"
  45 #include "utils.h"
  46
  47 int process_arguments (int, char **);
  48 void print_help (void);
  49 void print_usage (void);
  50
  51 char *status_log = NULL;
  52 char *process_string = NULL;
  53 int expire_minutes = 0;
  54
  55 int verbose = 0;
  56
  57 int
  58 main (int argc, char **argv)
  59 {
  60         int result = STATE_UNKNOWN;
  61         char input_buffer[MAX_INPUT_BUFFER];
  62         unsigned long latest_entry_time = 0L;
  63         unsigned long temp_entry_time = 0L;
  64         int proc_entries = 0;
  65         time_t current_time;
  66         char *temp_ptr;
  67         FILE *fp;
  68         int procuid = 0;
  69         int procpid = 0;
  70         int procppid = 0;
  71         int procvsz = 0;
  72         int procrss = 0;
  73         float procpcpu = 0;
  74         char procstat[8];
  75 #ifdef PS_USES_PROCETIME
  76         char procetime[MAX_INPUT_BUFFER];
  77 #endif /* PS_USES_PROCETIME */
  78         char procprog[MAX_INPUT_BUFFER];
  79         char *procargs;
  80         int pos, cols;
  81         int expected_cols = PS_COLS - 1;
  82         const char *zombie = "Z";
  83         char *temp_string;
  84         output chld_out, chld_err;
  85         size_t i;
  86
  87         setlocale (LC_ALL, "");
  88         bindtextdomain (PACKAGE, LOCALEDIR);
  89         textdomain (PACKAGE);
  90
  91         /* Parse extra opts if any */
  92         argv=np_extra_opts (&argc, argv, progname);
  93
  94         if (process_arguments (argc, argv) == ERROR)
  95                 usage_va(_("Could not parse arguments"));
  96
  97         /* Set signal handling and alarm timeout */
  98         if (signal (SIGALRM, timeout_alarm_handler) == SIG_ERR) {
  99                 usage_va(_("Cannot catch SIGALRM"));
 100         }
 101
 102         /* handle timeouts gracefully... */
 103         alarm (timeout_interval);
 104
 105         /* open the status log */
 106         fp = fopen (status_log, "r");
 107         if (fp == NULL) {
 108                 die (STATE_CRITICAL, "NAGIOS %s: %s\n", _("CRITICAL"), _("Cannot open status log for reading!"));
 109         }
 110
 111         /* get the date/time of the last item updated in the log */
 112         while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
 113                 if ((temp_ptr = strstr (input_buffer, "created=")) != NULL) {
 114                         temp_entry_time = strtoul (temp_ptr + 8, NULL, 10);
 115                         latest_entry_time = temp_entry_time;
 116                         break;
 117                 } else if ((temp_ptr = strtok (input_buffer, "]")) != NULL) {
 118                         temp_entry_time = strtoul (temp_ptr + 1, NULL, 10);
 119                         if (temp_entry_time > latest_entry_time)
 120                                 latest_entry_time = temp_entry_time;
 121                 }
 122         }
 123         fclose (fp);
 124
 125         if (verbose >= 2)
 126                 printf("command: %s\n", PS_COMMAND);
 127
 128         /* run the command to check for the Nagios process.. */
 129         if((result = np_runcmd(PS_COMMAND, &chld_out, &chld_err, 0)) != 0)
 130                 result = STATE_WARNING;
 131
 132         /* count the number of matching Nagios processes... */
 133         for(i = 0; i < chld_out.lines; i++) {
 134                 cols = sscanf (chld_out.line[i], PS_FORMAT, PS_VARLIST);
 135                 /* Zombie processes do not give a procprog command */
 136                 if ( cols == (expected_cols - 1) && strstr(procstat, zombie) ) {
 137                         cols = expected_cols;
 138                         /* Set some value for procargs for the strip command further below
 139                          * Seen to be a problem on some Solaris 7 and 8 systems */
 140                         chld_out.line[i][pos] = '\n';
 141                         chld_out.line[i][pos+1] = 0x0;
 142                 }
 143                 if ( cols >= expected_cols ) {
 144                         asprintf (&procargs, "%s", chld_out.line[i] + pos);
 145                         strip (procargs);
 146
 147                         /* Some ps return full pathname for command. This removes path */
 148                         temp_string = strtok ((char *)procprog, "/");
 149                         while (temp_string) {
 150                                 strcpy(procprog, temp_string);
 151                                 temp_string = strtok (NULL, "/");
 152                         }
 153
 154                         /* May get empty procargs */
 155                         if (!strstr(procargs, argv[0]) && strstr(procargs, process_string) && strcmp(procargs,"")) {
 156                                 proc_entries++;
 157                                 if (verbose >= 2) {
 158                                         printf (_("Found process: %s %s\n"), procprog, procargs);
 159                                 }
 160                         }
 161                 }
 162         }
 163
 164         /* If we get anything on stderr, at least set warning */
 165         if(chld_err.buflen)
 166                 result = max_state (result, STATE_WARNING);
 167
 168         /* reset the alarm handler */
 169         alarm (0);
 170
 171         if (proc_entries == 0) {
 172                 die (STATE_CRITICAL, "NAGIOS %s: %s\n", _("CRITICAL"), _("Could not locate a running Nagios process!"));
 173         }
 174
 175         if (latest_entry_time == 0L) {
 176                 die (STATE_CRITICAL, "NAGIOS %s: %s\n", _("CRITICAL"), _("Cannot parse Nagios log file for valid time"));
 177         }
 178
 179         time (&current_time);
 180         if ((int)(current_time - latest_entry_time) > (expire_minutes * 60)) {
 181                 result = STATE_WARNING;
 182         } else {
 183                 result = STATE_OK;
 184         }
 185
 186         printf ("NAGIOS %s: ", (result == STATE_OK) ? _("OK") : _("WARNING"));
 187         printf (ngettext ("%d process", "%d processes", proc_entries), proc_entries);
 188         printf (", ");
 189         printf (
 190           ngettext ("status log updated %d second ago",
 191             "status log updated %d seconds ago",
 192             (int) (current_time - latest_entry_time) ),
 193             (int) (current_time - latest_entry_time) );
 194         printf ("\n");
 195
 196         return result;
 197 }
 198
 199
 200
 201 /* process command-line arguments */
 202 int
 203 process_arguments (int argc, char **argv)
 204 {
 205         int c;
 206
 207         int option = 0;
 208         static struct option longopts[] = {
 209                 {"filename", required_argument, 0, 'F'},
 210                 {"expires", required_argument, 0, 'e'},
 211                 {"command", required_argument, 0, 'C'},
 212                 {"version", no_argument, 0, 'V'},
 213                 {"help", no_argument, 0, 'h'},
 214                 {"verbose", no_argument, 0, 'v'},
 215                 {0, 0, 0, 0}
 216         };
 217
 218         if (argc < 2)
 219                 return ERROR;
 220
 221         if (!is_option (argv[1])) {
 222                 status_log = argv[1];
 223                 if (is_intnonneg (argv[2]))
 224                         expire_minutes = atoi (argv[2]);
 225                 else
 226                         die (STATE_UNKNOWN,
 227                                                                  _("Expiration time must be an integer (seconds)\n"));
 228                 process_string = argv[3];
 229                 return OK;
 230         }
 231
 232         while (1) {
 233                 c = getopt_long (argc, argv, "+hVvF:C:e:", longopts, &option);
 234
 235                 if (c == -1 || c == EOF || c == 1)
 236                         break;
 237
 238                 switch (c) {
 239                 case 'h':                                                                       /* help */
 240                         print_help ();
 241                         exit (STATE_OK);
 242                 case 'V':                                                                       /* version */
 243                         print_revision (progname, revision);
 244                         exit (STATE_OK);
 245                 case 'F':                                                                       /* status log */
 246                         status_log = optarg;
 247                         break;
 248                 case 'C':                                                                       /* command */
 249                         process_string = optarg;
 250                         break;
 251                 case 'e':                                                                       /* expiry time */
 252                         if (is_intnonneg (optarg))
 253                                 expire_minutes = atoi (optarg);
 254                         else
 255                                 die (STATE_UNKNOWN,
 256                                      _("Expiration time must be an integer (seconds)\n"));
 257                         break;
 258                 case 'v':
 259                         verbose++;
 260                         break;
 261                 default:                                                                        /* print short usage_va statement if args not parsable */
 262                         usage5();
 263                 }
 264         }
 265
 266
 267         if (status_log == NULL)
 268                 die (STATE_UNKNOWN, _("You must provide the status_log\n"));
 269
 270         if (process_string == NULL)
 271                 die (STATE_UNKNOWN, _("You must provide a process string\n"));
 272
 273         return OK;
 274 }
 275
 276
 277
 278 void
 279 print_help (void)
 280 {
 281         print_revision (progname, revision);
 282
 283         printf (_(COPYRIGHT), copyright, email);
 284
 285         printf ("%s\n", _("This plugin checks the status of the Nagios process on the local machine"));
 286   printf ("%s\n", _("The plugin will check to make sure the Nagios status log is no older than"));
 287   printf ("%s\n", _("the number of minutes specified by the expires option."));
 288   printf ("%s\n", _("It also checks the process table for a process matching the command argument."));
 289
 290   printf ("\n\n");
 291
 292         print_usage ();
 293
 294         printf (_(UT_HELP_VRSN));
 295         printf (_(UT_EXTRA_OPTS));
 296
 297         printf (" %s\n", "-F, --filename=FILE");
 298   printf ("    %s\n", _("Name of the log file to check"));
 299   printf (" %s\n", "-e, --expires=INTEGER");
 300   printf ("    %s\n", _("Minutes aging after which logfile is considered stale"));
 301   printf (" %s\n", "-C, --command=STRING");
 302   printf ("    %s\n", _("Substring to search for in process arguments"));
 303   printf (_(UT_VERBOSE));
 304
 305 #ifdef NP_EXTRA_OPTS
 306   printf ("\n");
 307   printf ("%s\n", _("Notes:"));
 308   printf (_(UT_EXTRA_OPTS_NOTES));
 309 #endif
 310
 311   printf ("\n");
 312   printf ("%s\n", _("Examples:"));
 313   printf (" %s\n", "check_nagios -e 5 -F /usr/local/nagios/var/status.log -C /usr/local/nagios/bin/nagios");
 314
 315   printf (_(UT_SUPPORT));
 316 }
 317
 318
 319
 320 void
 321 print_usage (void)
 322 {
 323   printf (_("Usage:"));
 324         printf ("%s -F <status log file> -e <expire_minutes> -C <process_string>\n", progname);
 325 }