plugins/check_snmp.c

   1 /*****************************************************************************
   2 *
   3 * Nagios check_snmp plugin
   4 *
   5 * License: GPL
   6 * Copyright (c) 1999-2007 Nagios Plugins Development Team
   7 *
   8 * Description:
   9 *
  10 * This file contains the check_snmp plugin
  11 *
  12 * Check status of remote machines and obtain system information via SNMP
  13 *
  14 *
  15 * This program is free software: you can redistribute it and/or modify
  16 * it under the terms of the GNU General Public License as published by
  17 * the Free Software Foundation, either version 3 of the License, or
  18 * (at your option) any later version.
  19 *
  20 * This program is distributed in the hope that it will be useful,
  21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 * GNU General Public License for more details.
  24 *
  25 * You should have received a copy of the GNU General Public License
  26 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27 *
  28 *
  29 *****************************************************************************/
  30
  31 const char *progname = "check_snmp";
  32 const char *copyright = "1999-2007";
  33 const char *email = "nagiosplug-devel@lists.sourceforge.net";
  34
  35 #include "common.h"
  36 #include "utils.h"
  37 #include "utils_cmd.h"
  38
  39 #define DEFAULT_COMMUNITY "public"
  40 #define DEFAULT_PORT "161"
  41 #define DEFAULT_MIBLIST "ALL"
  42 #define DEFAULT_PROTOCOL "1"
  43 #define DEFAULT_TIMEOUT 1
  44 #define DEFAULT_RETRIES 5
  45 #define DEFAULT_AUTH_PROTOCOL "MD5"
  46 #define DEFAULT_PRIV_PROTOCOL "DES"
  47 #define DEFAULT_DELIMITER "="
  48 #define DEFAULT_OUTPUT_DELIMITER " "
  49
  50 #define mark(a) ((a)!=0?"*":"")
  51
  52 #define CHECK_UNDEF 0
  53 #define CRIT_PRESENT 1
  54 #define CRIT_STRING 2
  55 #define CRIT_REGEX 4
  56 #define CRIT_GT 8
  57 #define CRIT_LT 16
  58 #define CRIT_GE 32
  59 #define CRIT_LE 64
  60 #define CRIT_EQ 128
  61 #define CRIT_NE 256
  62 #define CRIT_RANGE 512
  63 #define WARN_PRESENT 1024
  64 #define WARN_STRING 2048
  65 #define WARN_REGEX 4096
  66 #define WARN_GT 8192
  67 #define WARN_LT 16384
  68 #define WARN_GE 32768
  69 #define WARN_LE 65536
  70 #define WARN_EQ 131072
  71 #define WARN_NE 262144
  72 #define WARN_RANGE 524288
  73
  74 #define MAX_OIDS 8
  75 #define MAX_DELIM_LENGTH 8
  76
  77 int process_arguments (int, char **);
  78 int validate_arguments (void);
  79 char *clarify_message (char *);
  80 int check_num (int);
  81 int llu_getll (unsigned long long *, char *);
  82 int llu_getul (unsigned long long *, char *);
  83 char *thisarg (char *str);
  84 char *nextarg (char *str);
  85 void print_usage (void);
  86 void print_help (void);
  87
  88 #include "regex.h"
  89 char regex_expect[MAX_INPUT_BUFFER] = "";
  90 regex_t preg;
  91 regmatch_t pmatch[10];
  92 char timestamp[10] = "";
  93 char errbuf[MAX_INPUT_BUFFER] = "";
  94 char perfstr[MAX_INPUT_BUFFER] = "| ";
  95 int cflags = REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
  96 int eflags = 0;
  97 int errcode, excode;
  98
  99 char *server_address = NULL;
 100 char *community = NULL;
 101 char **authpriv = NULL;
 102 char *proto = NULL;
 103 char *seclevel = NULL;
 104 char *secname = NULL;
 105 char *authproto = NULL;
 106 char *privproto = NULL;
 107 char *authpasswd = NULL;
 108 char *privpasswd = NULL;
 109 char **oids = NULL;
 110 char *label;
 111 char *units;
 112 char *port;
 113 char *snmpcmd;
 114 char string_value[MAX_INPUT_BUFFER] = "";
 115 char **labels = NULL;
 116 char **unitv = NULL;
 117 size_t nlabels = 0;
 118 size_t labels_size = 8;
 119 size_t nunits = 0;
 120 size_t unitv_size = 8;
 121 int numoids = 0;
 122 int numauthpriv = 0;
 123 int verbose = FALSE;
 124 int usesnmpgetnext = FALSE;
 125 unsigned long long lower_warn_lim[MAX_OIDS];
 126 unsigned long long upper_warn_lim[MAX_OIDS];
 127 unsigned long long lower_crit_lim[MAX_OIDS];
 128 unsigned long long upper_crit_lim[MAX_OIDS];
 129 unsigned long long response_value[MAX_OIDS];
 130 int check_warning_value = FALSE;
 131 int check_critical_value = FALSE;
 132 int retries = 0;
 133 unsigned long long eval_method[MAX_OIDS];
 134 char *delimiter;
 135 char *output_delim;
 136 char *miblist = NULL;
 137 int needmibs = FALSE;
 138
 139
 140 int
 141 main (int argc, char **argv)
 142 {
 143         int i = 0;
 144         int iresult = STATE_UNKNOWN;
 145         int result = STATE_UNKNOWN;
 146         int return_code = 0;
 147         int external_error = 0;
 148         char **command_line = NULL;
 149         char *cl_hidden_auth = NULL;
 150         char *oidname = NULL;
 151         char *response = NULL;
 152         char *outbuff;
 153         char *ptr = NULL;
 154         char *show = NULL;
 155         char type[8] = "";
 156         output chld_out, chld_err;
 157
 158         setlocale (LC_ALL, "");
 159         bindtextdomain (PACKAGE, LOCALEDIR);
 160         textdomain (PACKAGE);
 161
 162         labels = malloc (labels_size);
 163         unitv = malloc (unitv_size);
 164         for (i = 0; i < MAX_OIDS; i++)
 165                 eval_method[i] = CHECK_UNDEF;
 166         i = 0;
 167
 168         label = strdup ("SNMP");
 169         units = strdup ("");
 170         port = strdup (DEFAULT_PORT);
 171         outbuff = strdup ("");
 172         delimiter = strdup (" = ");
 173         output_delim = strdup (DEFAULT_OUTPUT_DELIMITER);
 174         /* miblist = strdup (DEFAULT_MIBLIST); */
 175         timeout_interval = DEFAULT_TIMEOUT;
 176         retries = DEFAULT_RETRIES;
 177
 178         /* Parse extra opts if any */
 179         argv=np_extra_opts (&argc, argv, progname);
 180
 181         if (process_arguments (argc, argv) == ERROR)
 182                 usage4 (_("Could not parse arguments"));
 183
 184         /* Create the command array to execute */
 185         if(usesnmpgetnext == TRUE) {
 186                 snmpcmd = strdup (PATH_TO_SNMPGETNEXT);
 187         }else{
 188                 snmpcmd = strdup (PATH_TO_SNMPGET);
 189         }
 190
 191         /* 9 arguments to pass before authpriv options + 1 for host and numoids. Add one for terminating NULL */
 192         command_line = calloc (9 + numauthpriv + 1 + numoids + 1, sizeof (char *));
 193         command_line[0] = snmpcmd;
 194         command_line[1] = strdup ("-t");
 195         asprintf (&command_line[2], "%d", timeout_interval);
 196         command_line[3] = strdup ("-r");
 197         asprintf (&command_line[4], "%d", retries);
 198         command_line[5] = strdup ("-m");
 199         command_line[6] = strdup (miblist);
 200         command_line[7] = "-v";
 201         command_line[8] = strdup (proto);
 202
 203         for (i = 0; i < numauthpriv; i++) {
 204                 command_line[9 + i] = authpriv[i];
 205         }
 206
 207         asprintf (&command_line[9 + numauthpriv], "%s:%s", server_address, port);
 208
 209         /* This is just for display purposes, so it can remain a string */
 210         asprintf(&cl_hidden_auth, "%s -t %d -r %d -m %s -v %s %s %s:%s",
 211                 snmpcmd, timeout_interval, retries, miblist, proto, "[authpriv]",
 212                 server_address, port);
 213
 214         for (i = 0; i < numoids; i++) {
 215                 command_line[9 + numauthpriv + 1 + i] = oids[i];
 216                 asprintf(&cl_hidden_auth, "%s %s", cl_hidden_auth, oids[i]);
 217         }
 218
 219         command_line[9 + numauthpriv + 1 + numoids] = NULL;
 220
 221         if (verbose)
 222                 printf ("%s\n", cl_hidden_auth);
 223
 224         /* Run the command */
 225         return_code = cmd_run_array (command_line, &chld_out, &chld_err, 0);
 226
 227         /* Due to net-snmp sometimes showing stderr messages with poorly formed MIBs,
 228            only return state unknown if return code is non zero or there is no stdout.
 229            Do this way so that if there is stderr, will get added to output, which helps problem diagnosis
 230         */
 231         if (return_code != 0)
 232                 external_error=1;
 233         if (chld_out.lines == 0)
 234                 external_error=1;
 235         if (external_error) {
 236                 if (chld_err.lines > 0) {
 237                         printf (_("External command error: %s\n"), chld_err.line[0]);
 238                         for (i = 1; i < chld_err.lines; i++) {
 239                                 printf ("%s\n", chld_err.line[i]);
 240                         }
 241                 } else {
 242                         printf(_("External command error with no output (return code: %d)\n"), return_code);
 243                 }
 244                 exit (STATE_UNKNOWN);
 245         }
 246
 247         if (verbose) {
 248                 for (i = 0; i < chld_out.lines; i++) {
 249                         printf ("%s\n", chld_out.line[i]);
 250                 }
 251         }
 252
 253         for (i = 0; i < chld_out.lines; i++) {
 254                 ptr = chld_out.line[i];
 255                 oidname = strpcpy (oidname, ptr, delimiter);
 256                 response = strstr (ptr, delimiter);
 257
 258                 /* We strip out the datatype indicator for PHBs */
 259
 260                 /* Clean up type array - Sol10 does not necessarily zero it out */
 261                 bzero(type, sizeof(type));
 262
 263                 if (strstr (response, "Gauge: "))
 264                         show = strstr (response, "Gauge: ") + 7;
 265                 else if (strstr (response, "Gauge32: "))
 266                         show = strstr (response, "Gauge32: ") + 9;
 267                 else if (strstr (response, "Counter32: ")) {
 268                         show = strstr (response, "Counter32: ") + 11;
 269                         strcpy(type, "c");
 270                 }
 271                 else if (strstr (response, "Counter64: ")) {
 272                         show = strstr (response, "Counter64: ") + 11;
 273                         strcpy(type, "c");
 274                 }
 275                 else if (strstr (response, "INTEGER: "))
 276                         show = strstr (response, "INTEGER: ") + 9;
 277                 else if (strstr (response, "STRING: "))
 278                         show = strstr (response, "STRING: ") + 8;
 279                 else
 280                         show = response;
 281
 282                 iresult = STATE_DEPENDENT;
 283
 284                 /* Process this block for integer comparisons */
 285                 if (eval_method[i] & CRIT_GT ||
 286                     eval_method[i] & CRIT_LT ||
 287                     eval_method[i] & CRIT_GE ||
 288                     eval_method[i] & CRIT_LE ||
 289                     eval_method[i] & CRIT_EQ ||
 290                     eval_method[i] & CRIT_NE ||
 291                     eval_method[i] & WARN_GT ||
 292                     eval_method[i] & WARN_LT ||
 293                     eval_method[i] & WARN_GE ||
 294                     eval_method[i] & WARN_LE ||
 295                     eval_method[i] & WARN_EQ ||
 296                     eval_method[i] & WARN_NE) {
 297                         ptr = strpbrk (show, "0123456789");
 298                         if (ptr == NULL)
 299                                 die (STATE_UNKNOWN,_("No valid data returned"));
 300                         response_value[i] = strtoul (ptr, NULL, 10);
 301                         iresult = check_num (i);
 302                         asprintf (&show, "%llu", response_value[i]);
 303                 }
 304
 305                 /* Process this block for string matching */
 306                 else if (eval_method[i] & CRIT_STRING) {
 307                         if (strcmp (show, string_value))
 308                                 iresult = STATE_CRITICAL;
 309                         else
 310                                 iresult = STATE_OK;
 311                 }
 312
 313                 /* Process this block for regex matching */
 314                 else if (eval_method[i] & CRIT_REGEX) {
 315                         excode = regexec (&preg, response, 10, pmatch, eflags);
 316                         if (excode == 0) {
 317                                 iresult = STATE_OK;
 318                         }
 319                         else if (excode != REG_NOMATCH) {
 320                                 regerror (excode, &preg, errbuf, MAX_INPUT_BUFFER);
 321                                 printf (_("Execute Error: %s\n"), errbuf);
 322                                 exit (STATE_CRITICAL);
 323                         }
 324                         else {
 325                                 iresult = STATE_CRITICAL;
 326                         }
 327                 }
 328
 329                 /* Process this block for existence-nonexistence checks */
 330                 else {
 331                         if (eval_method[i] & CRIT_PRESENT)
 332                                 iresult = STATE_CRITICAL;
 333                         else if (eval_method[i] & WARN_PRESENT)
 334                                 iresult = STATE_WARNING;
 335                         else if (response && iresult == STATE_DEPENDENT)
 336                                 iresult = STATE_OK;
 337                 }
 338
 339                 /* Result is the worst outcome of all the OIDs tested */
 340                 result = max_state (result, iresult);
 341
 342                 /* Prepend a label for this OID if there is one */
 343                 if (nlabels > (size_t)1 && (size_t)i < nlabels && labels[i] != NULL)
 344                         asprintf (&outbuff, "%s%s%s %s%s%s", outbuff,
 345                                 (i == 0) ? " " : output_delim,
 346                                 labels[i], mark (iresult), show, mark (iresult));
 347                 else
 348                         asprintf (&outbuff, "%s%s%s%s%s", outbuff, (i == 0) ? " " : output_delim,
 349                                 mark (iresult), show, mark (iresult));
 350
 351                 /* Append a unit string for this OID if there is one */
 352                 if (nunits > (size_t)0 && (size_t)i < nunits && unitv[i] != NULL)
 353                         asprintf (&outbuff, "%s %s", outbuff, unitv[i]);
 354
 355                 if (is_numeric(show)) {
 356                         strncat(perfstr, oidname, sizeof(perfstr)-strlen(perfstr)-1);
 357                         strncat(perfstr, "=", sizeof(perfstr)-strlen(perfstr)-1);
 358                         strncat(perfstr, show, sizeof(perfstr)-strlen(perfstr)-1);
 359
 360                         if (type)
 361                                 strncat(perfstr, type, sizeof(perfstr)-strlen(perfstr)-1);
 362                         strncat(perfstr, " ", sizeof(perfstr)-strlen(perfstr)-1);
 363                 }
 364         }
 365
 366 /*      if (nunits == 1 || i == 1) */
 367 /*              printf ("%s %s -%s %s\n", label, state_text (result), outbuff, units); */
 368 /*      else */
 369         printf ("%s %s -%s %s \n", label, state_text (result), outbuff, perfstr);
 370
 371         return result;
 372 }
 373
 374
 375
 376 /* process command-line arguments */
 377 int
 378 process_arguments (int argc, char **argv)
 379 {
 380         char *ptr;
 381         int c = 1;
 382         int j = 0, jj = 0, ii = 0;
 383
 384         int option = 0;
 385         static struct option longopts[] = {
 386                 STD_LONG_OPTS,
 387                 {"community", required_argument, 0, 'C'},
 388                 {"oid", required_argument, 0, 'o'},
 389                 {"object", required_argument, 0, 'o'},
 390                 {"delimiter", required_argument, 0, 'd'},
 391                 {"output-delimiter", required_argument, 0, 'D'},
 392                 {"string", required_argument, 0, 's'},
 393                 {"timeout", required_argument, 0, 't'},
 394                 {"regex", required_argument, 0, 'r'},
 395                 {"ereg", required_argument, 0, 'r'},
 396                 {"eregi", required_argument, 0, 'R'},
 397                 {"label", required_argument, 0, 'l'},
 398                 {"units", required_argument, 0, 'u'},
 399                 {"port", required_argument, 0, 'p'},
 400                 {"retries", required_argument, 0, 'e'},
 401                 {"miblist", required_argument, 0, 'm'},
 402                 {"protocol", required_argument, 0, 'P'},
 403                 {"seclevel", required_argument, 0, 'L'},
 404                 {"secname", required_argument, 0, 'U'},
 405                 {"authproto", required_argument, 0, 'a'},
 406                 {"privproto", required_argument, 0, 'x'},
 407                 {"authpasswd", required_argument, 0, 'A'},
 408                 {"privpasswd", required_argument, 0, 'X'},
 409                 {"next", no_argument, 0, 'n'},
 410                 {0, 0, 0, 0}
 411         };
 412
 413         if (argc < 2)
 414                 return ERROR;
 415
 416         /* reverse compatibility for very old non-POSIX usage forms */
 417         for (c = 1; c < argc; c++) {
 418                 if (strcmp ("-to", argv[c]) == 0)
 419                         strcpy (argv[c], "-t");
 420                 if (strcmp ("-wv", argv[c]) == 0)
 421                         strcpy (argv[c], "-w");
 422                 if (strcmp ("-cv", argv[c]) == 0)
 423                         strcpy (argv[c], "-c");
 424         }
 425
 426         while (1) {
 427                 c = getopt_long (argc, argv, "nhvVt:c:w:H:C:o:e:E:d:D:s:t:R:r:l:u:p:m:P:L:U:a:x:A:X:",
 428                                                                          longopts, &option);
 429
 430                 if (c == -1 || c == EOF)
 431                         break;
 432
 433                 switch (c) {
 434                 case '?':       /* usage */
 435                         usage5 ();
 436                 case 'h':       /* help */
 437                         print_help ();
 438                         exit (STATE_OK);
 439                 case 'V':       /* version */
 440                         print_revision (progname, NP_VERSION);
 441                         exit (STATE_OK);
 442                 case 'v': /* verbose */
 443                         verbose = TRUE;
 444                         break;
 445
 446         /* Connection info */
 447                 case 'C':                                                                       /* group or community */
 448                         community = optarg;
 449                         break;
 450                 case 'H':                                                                       /* Host or server */
 451                         server_address = optarg;
 452                         break;
 453                 case 'p':       /* TCP port number */
 454                         port = optarg;
 455                         break;
 456                 case 'm':       /* List of MIBS */
 457                         miblist = optarg;
 458                         break;
 459                 case 'n':       /* usesnmpgetnext */
 460                         usesnmpgetnext = TRUE;
 461                         break;
 462                 case 'P':       /* SNMP protocol version */
 463                         proto = optarg;
 464                         break;
 465                 case 'L':       /* security level */
 466                         seclevel = optarg;
 467                         break;
 468                 case 'U':       /* security username */
 469                         secname = optarg;
 470                         break;
 471                 case 'a':       /* auth protocol */
 472                         authproto = optarg;
 473                         break;
 474                 case 'x':       /* priv protocol */
 475                         privproto = optarg;
 476                         break;
 477                 case 'A':       /* auth passwd */
 478                         authpasswd = optarg;
 479                         break;
 480                 case 'X':       /* priv passwd */
 481                         privpasswd = optarg;
 482                         break;
 483                 case 't':       /* timeout period */
 484                         if (!is_integer (optarg))
 485                                 usage2 (_("Timeout interval must be a positive integer"), optarg);
 486                         else
 487                                 timeout_interval = atoi (optarg);
 488                         break;
 489
 490         /* Test parameters */
 491                 case 'c':                                                                       /* critical time threshold */
 492                         if (strspn (optarg, "0123456789:,") < strlen (optarg))
 493                                 usage2 (_("Invalid critical threshold"), optarg);
 494                         for (ptr = optarg; ptr && jj < MAX_OIDS; jj++) {
 495                                 if (llu_getll (&lower_crit_lim[jj], ptr) == 1)
 496                                         eval_method[jj] |= CRIT_LT;
 497                                 if (llu_getul (&upper_crit_lim[jj], ptr) == 1)
 498                                         eval_method[jj] |= CRIT_GT;
 499                                 (ptr = index (ptr, ',')) ? ptr++ : ptr;
 500                         }
 501                         break;
 502                 case 'w':                                                                       /* warning time threshold */
 503                         if (strspn (optarg, "0123456789:,") < strlen (optarg))
 504                                 usage2 (_("Invalid warning threshold"), optarg);
 505                         for (ptr = optarg; ptr && ii < MAX_OIDS; ii++) {
 506                                 if (llu_getll (&lower_warn_lim[ii], ptr) == 1)
 507                                         eval_method[ii] |= WARN_LT;
 508                                 if (llu_getul (&upper_warn_lim[ii], ptr) == 1)
 509                                         eval_method[ii] |= WARN_GT;
 510                                 (ptr = index (ptr, ',')) ? ptr++ : ptr;
 511                         }
 512                         break;
 513                 case 'e': /* PRELIMINARY - may change */
 514                 case 'E': /* PRELIMINARY - may change */
 515                         if (!is_integer (optarg))
 516                                 usage2 (_("Retries interval must be a positive integer"), optarg);
 517                         else
 518                                 retries = atoi(optarg);
 519                         break;
 520                 case 'o':                                                                       /* object identifier */
 521                         if ( strspn( optarg, "0123456789.," ) != strlen( optarg ) ) {
 522                                         /*
 523                                          * we have something other than digits, periods and comas,
 524                                          * so we have a mib variable, rather than just an SNMP OID,
 525                                          * so we have to actually read the mib files
 526                                          */
 527                                         needmibs = TRUE;
 528                         }
 529                         oids = calloc(MAX_OIDS, sizeof (char *));
 530                         for (ptr = strtok(optarg, ", "); ptr != NULL && j < MAX_OIDS; ptr = strtok(NULL, ", "), j++) {
 531                                 oids[j] = strdup(ptr);
 532                         }
 533                         numoids = j;
 534                         if (c == 'E' || c == 'e') {
 535                                 jj++;
 536                                 ii++;
 537                         }
 538                         if (c == 'E')
 539                                 eval_method[j+1] |= WARN_PRESENT;
 540                         else if (c == 'e')
 541                                 eval_method[j+1] |= CRIT_PRESENT;
 542                         break;
 543                 case 's':                                                                       /* string or substring */
 544                         strncpy (string_value, optarg, sizeof (string_value) - 1);
 545                         string_value[sizeof (string_value) - 1] = 0;
 546                         eval_method[jj++] = CRIT_STRING;
 547                         ii++;
 548                         break;
 549                 case 'R':                                                                       /* regex */
 550                         cflags = REG_ICASE;
 551                 case 'r':                                                                       /* regex */
 552                         cflags |= REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
 553                         strncpy (regex_expect, optarg, sizeof (regex_expect) - 1);
 554                         regex_expect[sizeof (regex_expect) - 1] = 0;
 555                         errcode = regcomp (&preg, regex_expect, cflags);
 556                         if (errcode != 0) {
 557                                 regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
 558                                 printf (_("Could Not Compile Regular Expression"));
 559                                 return ERROR;
 560                         }
 561                         eval_method[jj++] = CRIT_REGEX;
 562                         ii++;
 563                         break;
 564
 565         /* Format */
 566                 case 'd':                                                                       /* delimiter */
 567                         delimiter = strscpy (delimiter, optarg);
 568                         break;
 569                 case 'D':                                                                       /* output-delimiter */
 570                         output_delim = strscpy (output_delim, optarg);
 571                         break;
 572                 case 'l':                                                                       /* label */
 573                         label = optarg;
 574                         nlabels++;
 575                         if (nlabels >= labels_size) {
 576                                 labels_size += 8;
 577                                 labels = realloc (labels, labels_size);
 578                                 if (labels == NULL)
 579                                         die (STATE_UNKNOWN, _("Could not reallocate labels[%d]"), (int)nlabels);
 580                         }
 581                         labels[nlabels - 1] = optarg;
 582                         ptr = thisarg (optarg);
 583                         labels[nlabels - 1] = ptr;
 584                         if (strstr (ptr, "'") == ptr)
 585                                 labels[nlabels - 1] = ptr + 1;
 586                         while (ptr && (ptr = nextarg (ptr))) {
 587                                 if (nlabels >= labels_size) {
 588                                         labels_size += 8;
 589                                         labels = realloc (labels, labels_size);
 590                                         if (labels == NULL)
 591                                                 die (STATE_UNKNOWN, _("Could not reallocate labels\n"));
 592                                 }
 593                                 labels++;
 594                                 ptr = thisarg (ptr);
 595                                 if (strstr (ptr, "'") == ptr)
 596                                         labels[nlabels - 1] = ptr + 1;
 597                                 else
 598                                         labels[nlabels - 1] = ptr;
 599                         }
 600                         break;
 601                 case 'u':                                                                       /* units */
 602                         units = optarg;
 603                         nunits++;
 604                         if (nunits >= unitv_size) {
 605                                 unitv_size += 8;
 606                                 unitv = realloc (unitv, unitv_size);
 607                                 if (unitv == NULL)
 608                                         die (STATE_UNKNOWN, _("Could not reallocate units [%d]\n"), (int)nunits);
 609                         }
 610                         unitv[nunits - 1] = optarg;
 611                         ptr = thisarg (optarg);
 612                         unitv[nunits - 1] = ptr;
 613                         if (strstr (ptr, "'") == ptr)
 614                                 unitv[nunits - 1] = ptr + 1;
 615                         while (ptr && (ptr = nextarg (ptr))) {
 616                                 if (nunits >= unitv_size) {
 617                                         unitv_size += 8;
 618                                         unitv = realloc (unitv, unitv_size);
 619                                         if (units == NULL)
 620                                                 die (STATE_UNKNOWN, _("Could not realloc() units\n"));
 621                                 }
 622                                 nunits++;
 623                                 ptr = thisarg (ptr);
 624                                 if (strstr (ptr, "'") == ptr)
 625                                         unitv[nunits - 1] = ptr + 1;
 626                                 else
 627                                         unitv[nunits - 1] = ptr;
 628                         }
 629                         break;
 630
 631                 }
 632         }
 633
 634         if (server_address == NULL)
 635                 server_address = argv[optind];
 636
 637         if (community == NULL)
 638                 community = strdup (DEFAULT_COMMUNITY);
 639
 640         return validate_arguments ();
 641 }
 642
 643
 644 /******************************************************************************
 645
 646 @@-
 647 <sect3>
 648 <title>validate_arguments</title>
 649
 650 <para>&PROTO_validate_arguments;</para>
 651
 652 <para>Checks to see if the default miblist needs to be loaded. Also verifies
 653 the authentication and authorization combinations based on protocol version
 654 selected.</para>
 655
 656 <para></para>
 657
 658 </sect3>
 659 -@@
 660 ******************************************************************************/
 661
 662
 663
 664 int
 665 validate_arguments ()
 666 {
 667         /* check whether to load locally installed MIBS (CPU/disk intensive) */
 668         if (miblist == NULL) {
 669                 if ( needmibs == TRUE ) {
 670                         miblist = strdup (DEFAULT_MIBLIST);
 671                 }else{
 672                         miblist = "''";                 /* don't read any mib files for numeric oids */
 673                 }
 674         }
 675
 676         /* Check server_address is given */
 677         if (server_address == NULL)
 678                 die(STATE_UNKNOWN, _("No host specified\n"));
 679
 680         /* Check oid is given */
 681         if (numoids == 0)
 682                 die(STATE_UNKNOWN, _("No OIDs specified\n"));
 683
 684         if (proto == NULL)
 685                 asprintf(&proto, DEFAULT_PROTOCOL);
 686
 687         if ((strcmp(proto,"1") == 0) || (strcmp(proto, "2c")==0)) {     /* snmpv1 or snmpv2c */
 688                 numauthpriv = 2;
 689                 authpriv = calloc (numauthpriv, sizeof (char *));
 690                 authpriv[0] = strdup ("-c");
 691                 authpriv[1] = strdup (community);
 692         }
 693         else if ( strcmp (proto, "3") == 0 ) {          /* snmpv3 args */
 694                 if (seclevel == NULL)
 695                         asprintf(&seclevel, "noAuthNoPriv");
 696
 697                 if (strcmp(seclevel, "noAuthNoPriv") == 0) {
 698                         numauthpriv = 2;
 699                         authpriv = calloc (numauthpriv, sizeof (char *));
 700                         authpriv[0] = strdup ("-l");
 701                         authpriv[1] = strdup ("noAuthNoPriv");
 702                 } else {
 703                         if (! ( (strcmp(seclevel, "authNoPriv")==0) || (strcmp(seclevel, "authPriv")==0) ) ) {
 704                                 usage2 (_("Invalid seclevel"), seclevel);
 705                         }
 706
 707                         if (authproto == NULL )
 708                                 asprintf(&authproto, DEFAULT_AUTH_PROTOCOL);
 709
 710                         if (secname == NULL)
 711                                 die(STATE_UNKNOWN, _("Required parameter: %s\n"), "secname");
 712
 713                         if (authpasswd == NULL)
 714                                 die(STATE_UNKNOWN, _("Required parameter: %s\n"), "authpasswd");
 715
 716                         if ( strcmp(seclevel, "authNoPriv") == 0 ) {
 717                                 numauthpriv = 8;
 718                                 authpriv = calloc (numauthpriv, sizeof (char *));
 719                                 authpriv[0] = strdup ("-l");
 720                                 authpriv[1] = strdup ("authNoPriv");
 721                                 authpriv[2] = strdup ("-a");
 722                                 authpriv[3] = strdup (authproto);
 723                                 authpriv[4] = strdup ("-u");
 724                                 authpriv[5] = strdup (secname);
 725                                 authpriv[6] = strdup ("-A");
 726                                 authpriv[7] = strdup (authpasswd);
 727                         } else if ( strcmp(seclevel, "authPriv") == 0 ) {
 728                                 if (privproto == NULL )
 729                                         asprintf(&privproto, DEFAULT_PRIV_PROTOCOL);
 730
 731                                 if (privpasswd == NULL)
 732                                         die(STATE_UNKNOWN, _("Required parameter: %s\n"), "privpasswd");
 733
 734                                 numauthpriv = 12;
 735                                 authpriv = calloc (numauthpriv, sizeof (char *));
 736                                 authpriv[0] = strdup ("-l");
 737                                 authpriv[1] = strdup ("authPriv");
 738                                 authpriv[2] = strdup ("-a");
 739                                 authpriv[3] = strdup (authproto);
 740                                 authpriv[4] = strdup ("-u");
 741                                 authpriv[5] = strdup (secname);
 742                                 authpriv[6] = strdup ("-A");
 743                                 authpriv[7] = strdup (authpasswd);
 744                                 authpriv[8] = strdup ("-x");
 745                                 authpriv[9] = strdup (privproto);
 746                                 authpriv[10] = strdup ("-X");
 747                                 authpriv[11] = strdup (privpasswd);
 748                         }
 749                 }
 750
 751         }
 752         else {
 753                 usage2 (_("Invalid SNMP version"), proto);
 754         }
 755
 756         return OK;
 757 }
 758
 759
 760
 761 char *
 762 clarify_message (char *msg)
 763 {
 764         int i = 0;
 765         int foo;
 766         char tmpmsg_c[MAX_INPUT_BUFFER];
 767         char *tmpmsg = (char *) &tmpmsg_c;
 768         tmpmsg = strcpy (tmpmsg, msg);
 769         if (!strncmp (tmpmsg, " Hex:", 5)) {
 770                 tmpmsg = strtok (tmpmsg, ":");
 771                 while ((tmpmsg = strtok (NULL, " "))) {
 772                         foo = strtol (tmpmsg, NULL, 16);
 773                         /* Translate chars that are not the same value in the printers
 774                          * character set.
 775                          */
 776                         switch (foo) {
 777                         case 208:
 778                                 {
 779                                         foo = 197;
 780                                         break;
 781                                 }
 782                         case 216:
 783                                 {
 784                                         foo = 196;
 785                                         break;
 786                                 }
 787                         }
 788                         msg[i] = foo;
 789                         i++;
 790                 }
 791                 msg[i] = 0;
 792         }
 793         return (msg);
 794 }
 795
 796
 797
 798 int
 799 check_num (int i)
 800 {
 801         int result;
 802         result = STATE_OK;
 803         if (eval_method[i] & WARN_GT && eval_method[i] & WARN_LT &&
 804                         lower_warn_lim[i] > upper_warn_lim[i]) {
 805                 if (response_value[i] <= lower_warn_lim[i] &&
 806                                 response_value[i] >= upper_warn_lim[i]) {
 807                         result = STATE_WARNING;
 808                 }
 809         }
 810         else if
 811                 ((eval_method[i] & WARN_GT && response_value[i] > upper_warn_lim[i]) ||
 812                  (eval_method[i] & WARN_GE && response_value[i] >= upper_warn_lim[i]) ||
 813                  (eval_method[i] & WARN_LT && response_value[i] < lower_warn_lim[i]) ||
 814                  (eval_method[i] & WARN_LE && response_value[i] <= lower_warn_lim[i]) ||
 815                  (eval_method[i] & WARN_EQ && response_value[i] == upper_warn_lim[i]) ||
 816                  (eval_method[i] & WARN_NE && response_value[i] != upper_warn_lim[i])) {
 817                 result = STATE_WARNING;
 818         }
 819
 820         if (eval_method[i] & CRIT_GT && eval_method[i] & CRIT_LT &&
 821                         lower_crit_lim[i] > upper_crit_lim[i]) {
 822                 if (response_value[i] <= lower_crit_lim[i] &&
 823                                 response_value[i] >= upper_crit_lim[i]) {
 824                         result = STATE_CRITICAL;
 825                 }
 826         }
 827         else if
 828                 ((eval_method[i] & CRIT_GT && response_value[i] > upper_crit_lim[i]) ||
 829                  (eval_method[i] & CRIT_GE && response_value[i] >= upper_crit_lim[i]) ||
 830                  (eval_method[i] & CRIT_LT && response_value[i] < lower_crit_lim[i]) ||
 831                  (eval_method[i] & CRIT_LE && response_value[i] <= lower_crit_lim[i]) ||
 832                  (eval_method[i] & CRIT_EQ && response_value[i] == upper_crit_lim[i]) ||
 833                  (eval_method[i] & CRIT_NE && response_value[i] != upper_crit_lim[i])) {
 834                 result = STATE_CRITICAL;
 835         }
 836
 837         return result;
 838 }
 839
 840
 841
 842 int
 843 llu_getll (unsigned long long *ll, char *str)
 844 {
 845         char tmp[100];
 846         if (strchr (str, ':') == NULL)
 847                 return 0;
 848         if (strchr (str, ',') != NULL && (strchr (str, ',') < strchr (str, ':')))
 849                 return 0;
 850         if (sscanf (str, "%llu%[:]", ll, tmp) == 2)
 851                 return 1;
 852         return 0;
 853 }
 854
 855
 856
 857 int
 858 llu_getul (unsigned long long *ul, char *str)
 859 {
 860         char tmp[100];
 861         if (sscanf (str, "%llu%[^,]", ul, tmp) == 1)
 862                 return 1;
 863         if (sscanf (str, ":%llu%[^,]", ul, tmp) == 1)
 864                 return 1;
 865         if (sscanf (str, "%*u:%llu%[^,]", ul, tmp) == 1)
 866                 return 1;
 867         return 0;
 868 }
 869
 870
 871
 872 /* trim leading whitespace
 873          if there is a leading quote, make sure it balances */
 874
 875 char *
 876 thisarg (char *str)
 877 {
 878         str += strspn (str, " \t\r\n"); /* trim any leading whitespace */
 879         if (strstr (str, "'") == str) { /* handle SIMPLE quoted strings */
 880                 if (strlen (str) == 1 || !strstr (str + 1, "'"))
 881                         die (STATE_UNKNOWN, _("Unbalanced quotes\n"));
 882         }
 883         return str;
 884 }
 885
 886
 887
 888 /* if there's a leading quote, advance to the trailing quote
 889          set the trailing quote to '\x0'
 890          if the string continues, advance beyond the comma */
 891
 892 char *
 893 nextarg (char *str)
 894 {
 895         if (strstr (str, "'") == str) {
 896                 str[0] = 0;
 897                 if (strlen (str) > 1) {
 898                         str = strstr (str + 1, "'");
 899                         return (++str);
 900                 }
 901                 else {
 902                         return NULL;
 903                 }
 904         }
 905         if (strstr (str, ",") == str) {
 906                 str[0] = 0;
 907                 if (strlen (str) > 1) {
 908                         return (++str);
 909                 }
 910                 else {
 911                         return NULL;
 912                 }
 913         }
 914         if ((str = strstr (str, ",")) && strlen (str) > 1) {
 915                 str[0] = 0;
 916                 return (++str);
 917         }
 918         return NULL;
 919 }
 920
 921
 922
 923 void
 924 print_help (void)
 925 {
 926         print_revision (progname, NP_VERSION);
 927
 928         printf (COPYRIGHT, copyright, email);
 929
 930         printf ("%s\n", _("Check status of remote machines and obtain system information via SNMP"));
 931
 932         printf ("\n\n");
 933
 934         print_usage ();
 935
 936         printf (_(UT_HELP_VRSN));
 937         printf (_(UT_EXTRA_OPTS));
 938
 939         printf (_(UT_HOST_PORT), 'p', DEFAULT_PORT);
 940
 941         /* SNMP and Authentication Protocol */
 942         printf (" %s\n", "-n, --next");
 943         printf ("    %s\n", _("Use SNMP GETNEXT instead of SNMP GET"));
 944         printf (" %s\n", "-P, --protocol=[1|2c|3]");
 945         printf ("    %s\n", _("SNMP protocol version"));
 946         printf (" %s\n", "-L, --seclevel=[noAuthNoPriv|authNoPriv|authPriv]");
 947         printf ("    %s\n", _("SNMPv3 securityLevel"));
 948         printf (" %s\n", "-a, --authproto=[MD5|SHA]");
 949         printf ("    %s\n", _("SNMPv3 auth proto"));
 950         printf (" %s\n", "-x, --privproto=[DES|AES]");
 951         printf ("    %s\n", _("SNMPv3 priv proto (default DES)"));
 952
 953         /* Authentication Tokens*/
 954         printf (" %s\n", "-C, --community=STRING");
 955         printf ("    %s ", _("Optional community string for SNMP communication"));
 956         printf ("(%s \"%s\")\n", _("default is") ,DEFAULT_COMMUNITY);
 957         printf (" %s\n", "-U, --secname=USERNAME");
 958         printf ("    %s\n", _("SNMPv3 username"));
 959         printf (" %s\n", "-A, --authpassword=PASSWORD");
 960         printf ("    %s\n", _("SNMPv3 authentication password"));
 961         printf (" %s\n", "-X, --privpasswd=PASSWORD");
 962         printf ("    %s\n", _("SNMPv3 privacy password"));
 963
 964         /* OID Stuff */
 965         printf (" %s\n", "-o, --oid=OID(s)");
 966         printf ("    %s\n", _("Object identifier(s) or SNMP variables whose value you wish to query"));
 967         printf (" %s\n", "-m, --miblist=STRING");
 968         printf ("    %s\n", _("List of MIBS to be loaded (default = none if using numeric OIDs or 'ALL'"));
 969         printf ("    %s\n", _("for symbolic OIDs.)"));
 970         printf (" %s\n", "-d, --delimiter=STRING");
 971         printf ("    %s \"%s\"\n", _("Delimiter to use when parsing returned data. Default is"), DEFAULT_DELIMITER);
 972         printf ("    %s\n", _("Any data on the right hand side of the delimiter is considered"));
 973         printf ("    %s\n", _("to be the data that should be used in the evaluation."));
 974
 975         /* Tests Against Integers */
 976         printf (" %s\n", "-w, --warning=INTEGER_RANGE(s)");
 977         printf ("    %s\n", _("Range(s) which will not result in a WARNING status"));
 978         printf (" %s\n", "-c, --critical=INTEGER_RANGE(s)");
 979         printf ("    %s\n", _("Range(s) which will not result in a CRITICAL status"));
 980
 981         /* Tests Against Strings */
 982         printf (" %s\n", "-s, --string=STRING");
 983         printf ("    %s\n", _("Return OK state (for that OID) if STRING is an exact match"));
 984         printf (" %s\n", "-r, --ereg=REGEX");
 985         printf ("    %s\n", _("Return OK state (for that OID) if extended regular expression REGEX matches"));
 986         printf (" %s\n", "-R, --eregi=REGEX");
 987         printf ("    %s\n", _("Return OK state (for that OID) if case-insensitive extended REGEX matches"));
 988         printf (" %s\n", "-l, --label=STRING");
 989         printf ("    %s\n", _("Prefix label for output from plugin (default -s 'SNMP')"));
 990
 991         /* Output Formatting */
 992         printf (" %s\n", "-u, --units=STRING");
 993         printf ("    %s\n", _("Units label(s) for output data (e.g., 'sec.')."));
 994         printf (" %s\n", "-D, --output-delimiter=STRING");
 995         printf ("    %s\n", _("Separates output on multiple OID requests"));
 996
 997         printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
 998         printf (" %s\n", "-e, --retries=INTEGER");
 999         printf ("    %s\n", _("Number of retries to be used in the requests"));
1000
1001         printf (_(UT_VERBOSE));
1002
1003         printf ("\n");
1004         printf ("%s\n", _("This plugin uses the 'snmpget' command included with the NET-SNMP package."));
1005         printf ("%s\n", _("if you don't have the package installed, you will need to download it from"));
1006         printf ("%s\n", _("http://net-snmp.sourceforge.net before you can use this plugin."));
1007
1008         printf ("\n");
1009         printf ("%s\n", _("Notes:"));
1010         printf (" %s\n", _("- Multiple OIDs may be indicated by a comma- or space-delimited list (lists with"));
1011         printf ("   %s\n", _("internal spaces must be quoted) [max 8 OIDs]"));
1012
1013         printf (" %s\n", _("- Ranges are inclusive and are indicated with colons. When specified as"));
1014         printf ("   %s\n", _("'min:max' a STATE_OK will be returned if the result is within the indicated"));
1015         printf ("   %s\n", _("range or is equal to the upper or lower bound. A non-OK state will be"));
1016         printf ("   %s\n", _("returned if the result is outside the specified range."));
1017
1018         printf (" %s\n", _("- If specified in the order 'max:min' a non-OK state will be returned if the"));
1019         printf ("   %s\n", _("result is within the (inclusive) range."));
1020
1021         printf (" %s\n", _("- Upper or lower bounds may be omitted to skip checking the respective limit."));
1022         printf (" %s\n", _("- Bare integers are interpreted as upper limits."));
1023         printf (" %s\n", _("- When checking multiple OIDs, separate ranges by commas like '-w 1:10,1:,:20'"));
1024         printf (" %s\n", _("- Note that only one string and one regex may be checked at present"));
1025         printf (" %s\n", _("- All evaluation methods other than PR, STR, and SUBSTR expect that the value"));
1026         printf ("   %s\n", _("returned from the SNMP query is an unsigned integer."));
1027 #ifdef NP_EXTRA_OPTS
1028         printf (" -%s", _(UT_EXTRA_OPTS_NOTES));
1029 #endif
1030
1031         printf (_(UT_SUPPORT));
1032 }
1033
1034
1035
1036 void
1037 print_usage (void)
1038 {
1039         printf (_("Usage:"));
1040         printf ("%s -H <ip_address> -o <OID> [-w warn_range] [-c crit_range]\n",progname);
1041         printf ("[-C community] [-s string] [-r regex] [-R regexi] [-t timeout] [-e retries]\n");
1042         printf ("[-l label] [-u units] [-p port-number] [-d delimiter] [-D output-delimiter]\n");
1043         printf ("[-m miblist] [-P snmp version] [-L seclevel] [-U secname] [-a authproto]\n");
1044         printf ("[-A authpasswd] [-x privproto] [-X privpasswd]\n");
1045 }