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