upstream/monitoring-plugins
1
0
Fork 0
mirror of https://github.com/monitoring-plugins/monitoring-plugins.git synced 2026-03-24 11:23:12 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

check_snmp: refactoring + fixes

Browse source 
This commit moves the state retention logic to check_snmp as it is only
used there and I do not want it to be used at all, so it doesn't get a
place in the lib.

Otherwise this adapts tests and fixes the rate computing in the
refactored version of check_snmp.
Also fixes some bugs detected with the tests
This commit is contained in:
Lorenz Kästle 2025-09-08 15:57:06 +02:00
parent 1aefb1f9df
commit 87195f5511
13 changed files with 1655 additions and 1079 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
lib/Makefile.am
View file

@ -4,7 +4,7 @@ SUBDIRS = . tests
noinst_LIBRARIES = libmonitoringplug.a
AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\" \
AM_CPPFLAGS = \
-I$(srcdir) -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins
libmonitoringplug_a_SOURCES = utils_base.c utils_tcp.c utils_cmd.c maxfd.c output.c perfdata.c output.c thresholds.c vendor/cJSON/cJSON.c

190
lib/tests/test_utils.c
View file

@ -28,17 +28,7 @@
#include "utils_base.c"
int main(int argc, char **argv) {
char state_path[1024];
range *range;
double temp;
thresholds *thresholds = NULL;
int i, rc;
char *temp_string;
state_key *temp_state_key = NULL;
state_data *temp_state_data;
time_t current_time;
plan_tests(185);
plan_tests(155);
ok(this_monitoring_plugin == NULL, "monitoring_plugin not initialised");
@ -57,7 +47,7 @@ int main(int argc, char **argv) {
np_set_args(argc, argv);
range = parse_range_string("6");
range *range = parse_range_string("6");
ok(range != NULL, "'6' is valid range");
ok(range->start == 0, "Start correct");
ok(range->start_infinity == false, "Not using negative infinity");
@ -97,7 +87,7 @@ int main(int argc, char **argv) {
free(range);
range = parse_range_string("12345678901234567890:");
temp = atof("12345678901234567890"); /* Can't just use this because number too large */
double temp = atof("12345678901234567890"); /* Can't just use this because number too large */
ok(range != NULL, "'12345678901234567890:' is valid range");
ok(range->start == temp, "Start correct");
ok(range->start_infinity == false, "Not using negative infinity");
@ -158,32 +148,34 @@ int main(int argc, char **argv) {
range = parse_range_string("2:1");
ok(range == NULL, "'2:1' rejected");
rc = _set_thresholds(&thresholds, NULL, NULL);
ok(rc == 0, "Thresholds (NULL, NULL) set");
thresholds *thresholds = NULL;
int returnCode;
returnCode = _set_thresholds(&thresholds, NULL, NULL);
ok(returnCode == 0, "Thresholds (NULL, NULL) set");
ok(thresholds->warning == NULL, "Warning not set");
ok(thresholds->critical == NULL, "Critical not set");
rc = _set_thresholds(&thresholds, NULL, "80");
ok(rc == 0, "Thresholds (NULL, '80') set");
returnCode = _set_thresholds(&thresholds, NULL, "80");
ok(returnCode == 0, "Thresholds (NULL, '80') set");
ok(thresholds->warning == NULL, "Warning not set");
ok(thresholds->critical->end == 80, "Critical set correctly");
rc = _set_thresholds(&thresholds, "5:33", NULL);
ok(rc == 0, "Thresholds ('5:33', NULL) set");
returnCode = _set_thresholds(&thresholds, "5:33", NULL);
ok(returnCode == 0, "Thresholds ('5:33', NULL) set");
ok(thresholds->warning->start == 5, "Warning start set");
ok(thresholds->warning->end == 33, "Warning end set");
ok(thresholds->critical == NULL, "Critical not set");
rc = _set_thresholds(&thresholds, "30", "60");
ok(rc == 0, "Thresholds ('30', '60') set");
returnCode = _set_thresholds(&thresholds, "30", "60");
ok(returnCode == 0, "Thresholds ('30', '60') set");
ok(thresholds->warning->end == 30, "Warning set correctly");
ok(thresholds->critical->end == 60, "Critical set correctly");
ok(get_status(15.3, thresholds) == STATE_OK, "15.3 - ok");
ok(get_status(30.0001, thresholds) == STATE_WARNING, "30.0001 - warning");
ok(get_status(69, thresholds) == STATE_CRITICAL, "69 - critical");
rc = _set_thresholds(&thresholds, "-10:-2", "-30:20");
ok(rc == 0, "Thresholds ('-30:20', '-10:-2') set");
returnCode = _set_thresholds(&thresholds, "-10:-2", "-30:20");
ok(returnCode == 0, "Thresholds ('-30:20', '-10:-2') set");
ok(thresholds->warning->start == -10, "Warning start set correctly");
ok(thresholds->warning->end == -2, "Warning end set correctly");
ok(thresholds->critical->start == -30, "Critical start set correctly");
@ -304,164 +296,28 @@ int main(int argc, char **argv) {
test = np_extract_ntpvar("", "foo");
ok(!test, "Empty string return NULL");
/* This is the result of running ./test_utils */
temp_string = (char *)_np_state_generate_key();
ok(!strcmp(temp_string, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"), "Got hash with exe and no parameters") ||
diag("You are probably running in wrong directory. Must run as ./test_utils");
this_monitoring_plugin->argc = 4;
this_monitoring_plugin->argv[0] = "./test_utils";
this_monitoring_plugin->argv[1] = "here";
this_monitoring_plugin->argv[2] = "--and";
this_monitoring_plugin->argv[3] = "now";
temp_string = (char *)_np_state_generate_key();
ok(!strcmp(temp_string, "bd72da9f78ff1419fad921ea5e43ce56508aef6c"), "Got based on expected argv");
unsetenv("MP_STATE_PATH");
temp_string = (char *)_np_state_calculate_location_prefix();
ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory");
setenv("MP_STATE_PATH", "", 1);
temp_string = (char *)_np_state_calculate_location_prefix();
ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory even with empty string");
setenv("MP_STATE_PATH", "/usr/local/nagios/var", 1);
temp_string = (char *)_np_state_calculate_location_prefix();
ok(!strcmp(temp_string, "/usr/local/nagios/var"), "Got default directory");
ok(temp_state_key == NULL, "temp_state_key initially empty");
this_monitoring_plugin->argc = 1;
this_monitoring_plugin->argv[0] = "./test_utils";
np_enable_state(NULL, 51);
temp_state_key = this_monitoring_plugin->state;
ok(!strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name");
ok(!strcmp(temp_state_key->name, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"), "Got generated filename");
np_enable_state("allowedchars_in_keyname", 77);
temp_state_key = this_monitoring_plugin->state;
sprintf(state_path, "/usr/local/nagios/var/%lu/check_test/allowedchars_in_keyname", (unsigned long)geteuid());
ok(!strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name");
ok(!strcmp(temp_state_key->name, "allowedchars_in_keyname"), "Got key name with valid chars");
ok(!strcmp(temp_state_key->_filename, state_path), "Got internal filename");
/* Don't do this test just yet. Will die */
/*
np_enable_state("bad^chars$in@here", 77);
temp_state_key = this_monitoring_plugin->state;
ok( !strcmp(temp_state_key->name, "bad_chars_in_here"), "Got key name with bad chars replaced" );
*/
np_enable_state("funnykeyname", 54);
temp_state_key = this_monitoring_plugin->state;
sprintf(state_path, "/usr/local/nagios/var/%lu/check_test/funnykeyname", (unsigned long)geteuid());
ok(!strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name");
ok(!strcmp(temp_state_key->name, "funnykeyname"), "Got key name");
ok(!strcmp(temp_state_key->_filename, state_path), "Got internal filename");
ok(temp_state_key->data_version == 54, "Version set");
temp_state_data = np_state_read();
ok(temp_state_data == NULL, "Got no state data as file does not exist");
/*
temp_fp = fopen("var/statefile", "r");
if (temp_fp==NULL)
printf("Error opening. errno=%d\n", errno);
printf("temp_fp=%s\n", temp_fp);
ok( _np_state_read_file(temp_fp) == true, "Can read state file" );
fclose(temp_fp);
*/
temp_state_key->_filename = "var/statefile";
temp_state_data = np_state_read();
ok(this_monitoring_plugin->state->state_data != NULL, "Got state data now") ||
diag("Are you running in right directory? Will get coredump next if not");
ok(this_monitoring_plugin->state->state_data->time == 1234567890, "Got time");
ok(!strcmp((char *)this_monitoring_plugin->state->state_data->data, "String to read"), "Data as expected");
temp_state_key->data_version = 53;
temp_state_data = np_state_read();
ok(temp_state_data == NULL, "Older data version gives NULL");
temp_state_key->data_version = 54;
temp_state_key->_filename = "var/nonexistent";
temp_state_data = np_state_read();
ok(temp_state_data == NULL, "Missing file gives NULL");
ok(this_monitoring_plugin->state->state_data == NULL, "No state information");
temp_state_key->_filename = "var/oldformat";
temp_state_data = np_state_read();
ok(temp_state_data == NULL, "Old file format gives NULL");
temp_state_key->_filename = "var/baddate";
temp_state_data = np_state_read();
ok(temp_state_data == NULL, "Bad date gives NULL");
temp_state_key->_filename = "var/missingdataline";
temp_state_data = np_state_read();
ok(temp_state_data == NULL, "Missing data line gives NULL");
unlink("var/generated");
temp_state_key->_filename = "var/generated";
current_time = 1234567890;
np_state_write_string(current_time, "String to read");
ok(system("cmp var/generated var/statefile") == 0, "Generated file same as expected");
unlink("var/generated_directory/statefile");
unlink("var/generated_directory");
temp_state_key->_filename = "var/generated_directory/statefile";
current_time = 1234567890;
np_state_write_string(current_time, "String to read");
ok(system("cmp var/generated_directory/statefile var/statefile") == 0, "Have created directory");
/* This test to check cannot write to dir - can't automate yet */
/*
unlink("var/generated_bad_dir");
mkdir("var/generated_bad_dir", S_IRUSR);
np_state_write_string(current_time, "String to read");
*/
temp_state_key->_filename = "var/generated";
time(&current_time);
np_state_write_string(0, "String to read");
temp_state_data = np_state_read();
/* Check time is set to current_time */
ok(system("cmp var/generated var/statefile > /dev/null") != 0, "Generated file should be different this time");
ok(this_monitoring_plugin->state->state_data->time - current_time <= 1, "Has time generated from current time");
/* Don't know how to automatically test this. Need to be able to redefine die and catch the error */
/*
temp_state_key->_filename="/dev/do/not/expect/to/be/able/to/write";
np_state_write_string(0, "Bad file");
*/
np_cleanup();
ok(this_monitoring_plugin == NULL, "Free'd this_monitoring_plugin");
ok(mp_suid() == false, "Test aren't suid");
/* base states with random case */
char *states[] = {"Ok", "wArnINg", "cRiTIcaL", "UnKNoWN", NULL};
for (i = 0; states[i] != NULL; i++) {
/* out of the random case states, create the lower and upper versions + numeric string one */
for (int i = 0; states[i] != NULL; i++) {
/* out of the random case states, create the lower and upper versions + numeric string one
*/
char *statelower = strdup(states[i]);
char *stateupper = strdup(states[i]);
char statenum[2];
char *temp_ptr;
for (temp_ptr = statelower; *temp_ptr; temp_ptr++) {
*temp_ptr = tolower(*temp_ptr);
for (char *temp_ptr = statelower; *temp_ptr; temp_ptr++) {
*temp_ptr = (char)tolower(*temp_ptr);
}
for (temp_ptr = stateupper; *temp_ptr; temp_ptr++) {
*temp_ptr = toupper(*temp_ptr);
for (char *temp_ptr = stateupper; *temp_ptr; temp_ptr++) {
*temp_ptr = (char)toupper(*temp_ptr);
}
snprintf(statenum, 2, "%i", i);
/* Base test names, we'll append the state string */
char testname[64] = "Translate state string: ";
int tlen = strlen(testname);
size_t tlen = strlen(testname);
strcpy(testname + tlen, states[i]);
ok(i == mp_translate_state(states[i]), testname);

344
lib/utils_base.c
View file

@ -74,14 +74,6 @@ void np_set_args(int argc, char **argv) {
void np_cleanup(void) {
if (this_monitoring_plugin != NULL) {
if (this_monitoring_plugin->state != NULL) {
if (this_monitoring_plugin->state->state_data) {
np_free(this_monitoring_plugin->state->state_data->data);
np_free(this_monitoring_plugin->state->state_data);
}
np_free(this_monitoring_plugin->state->name);
np_free(this_monitoring_plugin->state);
}
np_free(this_monitoring_plugin->plugin_name);
np_free(this_monitoring_plugin);
}
@ -435,339 +427,3 @@ int mp_translate_state(char *state_text) {
}
return ERROR;
}
/*
* Returns a string to use as a keyname, based on an md5 hash of argv, thus
* hopefully a unique key per service/plugin invocation. Use the extra-opts
* parse of argv, so that uniqueness in parameters are reflected there.
*/
char *_np_state_generate_key(void) {
char **argv = this_monitoring_plugin->argv;
unsigned char result[256];
#ifdef USE_OPENSSL
/*
* This code path is chosen if openssl is available (which should be the most common
* scenario). Alternatively, the gnulib implementation/
*
*/
EVP_MD_CTX *ctx = EVP_MD_CTX_new();
EVP_DigestInit(ctx, EVP_sha256());
for (int i = 0; i < this_monitoring_plugin->argc; i++) {
EVP_DigestUpdate(ctx, argv[i], strlen(argv[i]));
}
EVP_DigestFinal(ctx, result, NULL);
#else
struct sha256_ctx ctx;
for (int i = 0; i < this_monitoring_plugin->argc; i++) {
sha256_process_bytes(argv[i], strlen(argv[i]), &ctx);
}
sha256_finish_ctx(&ctx, result);
#endif // FOUNDOPENSSL
char keyname[41];
for (int i = 0; i < 20; ++i) {
sprintf(&keyname[2 * i], "%02x", result[i]);
}
keyname[40] = '\0';
char *keyname_copy = strdup(keyname);
if (keyname_copy == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
return keyname_copy;
}
void _cleanup_state_data(void) {
if (this_monitoring_plugin->state->state_data != NULL) {
np_free(this_monitoring_plugin->state->state_data->data);
np_free(this_monitoring_plugin->state->state_data);
}
}
/*
* Internal function. Returns either:
* envvar NAGIOS_PLUGIN_STATE_DIRECTORY
* statically compiled shared state directory
*/
char *_np_state_calculate_location_prefix(void) {
char *env_dir;
/* Do not allow passing MP_STATE_PATH in setuid plugins
* for security reasons */
if (!mp_suid()) {
env_dir = getenv("MP_STATE_PATH");
if (env_dir && env_dir[0] != '\0') {
return env_dir;
}
/* This is the former ENV, for backward-compatibility */
env_dir = getenv("NAGIOS_PLUGIN_STATE_DIRECTORY");
if (env_dir && env_dir[0] != '\0') {
return env_dir;
}
}
return NP_STATE_DIR_PREFIX;
}
/*
* Initiatializer for state routines.
* Sets variables. Generates filename. Returns np_state_key. die with
* UNKNOWN if exception
*/
void np_enable_state(char *keyname, int expected_data_version) {
if (this_monitoring_plugin == NULL) {
die(STATE_UNKNOWN, _("This requires np_init to be called"));
}
state_key *this_state = (state_key *)calloc(1, sizeof(state_key));
if (this_state == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
char *temp_keyname = NULL;
if (keyname == NULL) {
temp_keyname = _np_state_generate_key();
} else {
temp_keyname = strdup(keyname);
if (temp_keyname == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
}
/* Die if invalid characters used for keyname */
char *tmp_char = temp_keyname;
while (*tmp_char != '\0') {
if (!(isalnum(*tmp_char) || *tmp_char == '_')) {
die(STATE_UNKNOWN, _("Invalid character for keyname - only alphanumerics or '_'"));
}
tmp_char++;
}
this_state->name = temp_keyname;
this_state->plugin_name = this_monitoring_plugin->plugin_name;
this_state->data_version = expected_data_version;
this_state->state_data = NULL;
/* Calculate filename */
char *temp_filename = NULL;
int error =
asprintf(&temp_filename, "%s/%lu/%s/%s", _np_state_calculate_location_prefix(),
(unsigned long)geteuid(), this_monitoring_plugin->plugin_name, this_state->name);
if (error < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
this_state->_filename = temp_filename;
this_monitoring_plugin->state = this_state;
}
/*
* Will return NULL if no data is available (first run). If key currently
* exists, read data. If state file format version is not expected, return
* as if no data. Get state data version number and compares to expected.
* If numerically lower, then return as no previous state. die with UNKNOWN
* if exceptional error.
*/
state_data *np_state_read(void) {
if (this_monitoring_plugin == NULL) {
die(STATE_UNKNOWN, _("This requires np_init to be called"));
}
bool error_code = false;
/* Open file. If this fails, no previous state found */
FILE *statefile = fopen(this_monitoring_plugin->state->_filename, "r");
if (statefile != NULL) {
state_data *this_state_data = (state_data *)calloc(1, sizeof(state_data));
if (this_state_data == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
this_state_data->data = NULL;
this_monitoring_plugin->state->state_data = this_state_data;
error_code = _np_state_read_file(statefile);
fclose(statefile);
}
if (!error_code) {
_cleanup_state_data();
}
return this_monitoring_plugin->state->state_data;
}
/*
* Read the state file
*/
bool _np_state_read_file(FILE *state_file) {
time_t current_time;
time(&current_time);
/* Note: This introduces a limit of 1024 bytes in the string data */
char *line = (char *)calloc(1, 1024);
if (line == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
bool status = false;
enum {
STATE_FILE_VERSION,
STATE_DATA_VERSION,
STATE_DATA_TIME,
STATE_DATA_TEXT,
STATE_DATA_END
} expected = STATE_FILE_VERSION;
int failure = 0;
while (!failure && (fgets(line, 1024, state_file)) != NULL) {
size_t pos = strlen(line);
if (line[pos - 1] == '\n') {
line[pos - 1] = '\0';
}
if (line[0] == '#') {
continue;
}
switch (expected) {
case STATE_FILE_VERSION: {
int i = atoi(line);
if (i != NP_STATE_FORMAT_VERSION) {
failure++;
} else {
expected = STATE_DATA_VERSION;
}
} break;
case STATE_DATA_VERSION: {
int i = atoi(line);
if (i != this_monitoring_plugin->state->data_version) {
failure++;
} else {
expected = STATE_DATA_TIME;
}
} break;
case STATE_DATA_TIME: {
/* If time > now, error */
time_t data_time = strtoul(line, NULL, 10);
if (data_time > current_time) {
failure++;
} else {
this_monitoring_plugin->state->state_data->time = data_time;
expected = STATE_DATA_TEXT;
}
} break;
case STATE_DATA_TEXT:
this_monitoring_plugin->state->state_data->data = strdup(line);
if (this_monitoring_plugin->state->state_data->data == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
expected = STATE_DATA_END;
status = true;
break;
case STATE_DATA_END:;
}
}
np_free(line);
return status;
}
/*
* If time=NULL, use current time. Create state file, with state format
* version, default text. Writes version, time, and data. Avoid locking
* problems - use mv to write and then swap. Possible loss of state data if
* two things writing to same key at same time.
* Will die with UNKNOWN if errors
*/
void np_state_write_string(time_t data_time, char *data_string) {
time_t current_time;
if (data_time == 0) {
time(&current_time);
} else {
current_time = data_time;
}
int result = 0;
/* If file doesn't currently exist, create directories */
if (access(this_monitoring_plugin->state->_filename, F_OK) != 0) {
char *directories = NULL;
result = asprintf(&directories, "%s", this_monitoring_plugin->state->_filename);
if (result < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
for (char *p = directories + 1; *p; p++) {
if (*p == '/') {
*p = '\0';
if ((access(directories, F_OK) != 0) && (mkdir(directories, S_IRWXU) != 0)) {
/* Can't free this! Otherwise error message is wrong! */
/* np_free(directories); */
die(STATE_UNKNOWN, _("Cannot create directory: %s"), directories);
}
*p = '/';
}
}
np_free(directories);
}
char *temp_file = NULL;
result = asprintf(&temp_file, "%s.XXXXXX", this_monitoring_plugin->state->_filename);
if (result < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
int temp_file_desc = 0;
if ((temp_file_desc = mkstemp(temp_file)) == -1) {
np_free(temp_file);
die(STATE_UNKNOWN, _("Cannot create temporary filename"));
}
FILE *temp_file_pointer = (FILE *)fdopen(temp_file_desc, "w");
if (temp_file_pointer == NULL) {
close(temp_file_desc);
unlink(temp_file);
np_free(temp_file);
die(STATE_UNKNOWN, _("Unable to open temporary state file"));
}
fprintf(temp_file_pointer, "# NP State file\n");
fprintf(temp_file_pointer, "%d\n", NP_STATE_FORMAT_VERSION);
fprintf(temp_file_pointer, "%d\n", this_monitoring_plugin->state->data_version);
fprintf(temp_file_pointer, "%lu\n", current_time);
fprintf(temp_file_pointer, "%s\n", data_string);
fchmod(temp_file_desc, S_IRUSR | S_IWUSR | S_IRGRP);
fflush(temp_file_pointer);
result = fclose(temp_file_pointer);
fsync(temp_file_desc);
if (result != 0) {
unlink(temp_file);
np_free(temp_file);
die(STATE_UNKNOWN, _("Error writing temp file"));
}
if (rename(temp_file, this_monitoring_plugin->state->_filename) != 0) {
unlink(temp_file);
np_free(temp_file);
die(STATE_UNKNOWN, _("Cannot rename state temp file"));
}
np_free(temp_file);
}

22
lib/utils_base.h
View file

@ -8,7 +8,6 @@
#include "./perfdata.h"
#include "./thresholds.h"
#ifndef USE_OPENSSL
# include "sha256.h"
#endif
@ -26,25 +25,8 @@
#define OUTSIDE 0
#define INSIDE 1
#define NP_STATE_FORMAT_VERSION 1
typedef struct state_data_struct {
time_t time;
void *data;
int length; /* Of binary data */
} state_data;
typedef struct state_key_struct {
char *name;
char *plugin_name;
int data_version;
char *_filename;
state_data *state_data;
} state_key;
typedef struct np_struct {
char *plugin_name;
state_key *state;
int argc;
char **argv;
} monitoring_plugin;
@ -100,10 +82,6 @@ char *np_extract_value(const char *, const char *, char);
*/
int mp_translate_state(char *);
void np_enable_state(char *, int);
state_data *np_state_read(void);
void np_state_write_string(time_t, char *);
void np_init(char *, int argc, char **argv);
void np_set_args(int argc, char **argv);
void np_cleanup(void);

14
plugins/Makefile.am
View file

@ -13,8 +13,14 @@ AM_CFLAGS = -DNP_VERSION='"$(NP_VERSION)"'
VPATH = $(top_srcdir) $(top_srcdir)/lib $(top_srcdir)/plugins $(top_srcdir)/plugins/t
AM_CPPFLAGS = -I.. -I$(top_srcdir)/lib -I$(top_srcdir)/gl -I$(top_srcdir)/intl \
@LDAPINCLUDE@ @PGINCLUDE@ @SSLINCLUDE@
AM_CPPFLAGS = -I.. \
-I$(top_srcdir)/lib \
-I$(top_srcdir)/gl \
-I$(top_srcdir)/intl \
-DNP_STATE_DIR_PREFIX=\"$(localstatedir)\" \
@LDAPINCLUDE@ \
@PGINCLUDE@ \
@SSLINCLUDE@
localedir = $(datadir)/locale
# gettext docs say to use AM_CPPFLAGS, but per module_CPPFLAGS override this
@ -42,11 +48,13 @@ EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_hpjd \
check_procs check_mysql_query check_apt check_dbi check_curl \
\
tests/test_check_swap \
tests/test_check_snmp \
tests/test_check_disk
SUBDIRS = picohttpparser
np_test_scripts = tests/test_check_swap.t \
tests/test_check_snmp.t \
tests/test_check_disk.t
EXTRA_DIST = t \
@ -178,6 +186,8 @@ endif
tests_test_check_swap_LDADD = $(BASEOBJS) $(tap_ldflags) -ltap
tests_test_check_swap_SOURCES = tests/test_check_swap.c check_swap.d/swap.c
tests_test_check_snmp_LDADD = $(BASEOBJS) $(tap_ldflags) -ltap
tests_test_check_snmp_SOURCES = tests/test_check_snmp.c check_snmp.d/check_snmp_helpers.c
tests_test_check_disk_LDADD = $(BASEOBJS) $(tap_ldflags) check_disk.d/utils_disk.c -ltap
tests_test_check_disk_SOURCES = tests/test_check_disk.c

794
plugins/check_snmp.c
View file

File diff suppressed because it is too large Load diff

861
plugins/check_snmp.d/check_snmp_helpers.c
View file

@ -1,6 +1,15 @@
#include "./check_snmp_helpers.h"
#include <string.h>
#include "../../lib/utils_base.h"
#include "config.h"
#include <assert.h>
#include "../utils.h"
#include "output.h"
#include "states.h"
#include <sys/stat.h>
#include <ctype.h>
extern int verbose;
check_snmp_test_unit check_snmp_test_unit_init() {
check_snmp_test_unit tmp = {
@ -78,38 +87,848 @@ int check_snmp_set_thresholds(const char *threshold_string, check_snmp_test_unit
const int DEFAULT_PROTOCOL = SNMP_VERSION_1;
const char DEFAULT_OUTPUT_DELIMITER[] = " ";
const int RANDOM_STATE_DATA_LENGTH_PREDICTION = 1024;
const int RANDOM_STATE_DATA_LENGTH_PREDICTION = 8192;
check_snmp_config check_snmp_config_init() {
check_snmp_config tmp = {
.use_getnext = false,
.snmp_params =
{
.use_getnext = false,
.ignore_mib_parsing_errors = false,
.need_mibs = false,
.ignore_mib_parsing_errors = false,
.need_mibs = false,
.test_units = NULL,
.num_of_test_units = 0,
.test_units = NULL,
.num_of_test_units = 0,
},
.nulloid_result = STATE_UNKNOWN, // state to return if no result for query
.evaluation_params =
{
.nulloid_result = STATE_UNKNOWN, // state to return if no result for query
.invert_search = true,
.regex_cmp_value = {},
.string_cmp_value = "",
.invert_search = true,
.regex_cmp_value = {},
.string_cmp_value = "",
.multiplier = 1.0,
.multiplier_set = false,
.offset = 0,
.offset_set = false,
.multiplier = 1.0,
.multiplier_set = false,
.offset = 0,
.offset_set = false,
.use_perf_data_labels_from_input = false,
.use_oid_as_perf_data_label = false,
.calculate_rate = false,
.rate_multiplier = 1,
},
};
snmp_sess_init(&tmp.snmp_session);
snmp_sess_init(&tmp.snmp_params.snmp_session);
tmp.snmp_session.retries = DEFAULT_RETRIES;
tmp.snmp_session.version = DEFAULT_SNMP_VERSION;
tmp.snmp_session.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
tmp.snmp_session.community = (unsigned char *)"public";
tmp.snmp_session.community_len = strlen("public");
tmp.snmp_params.snmp_session.retries = DEFAULT_RETRIES;
tmp.snmp_params.snmp_session.version = DEFAULT_SNMP_VERSION;
tmp.snmp_params.snmp_session.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
tmp.snmp_params.snmp_session.community = (unsigned char *)"public";
tmp.snmp_params.snmp_session.community_len = strlen("public");
return tmp;
}
snmp_responces do_snmp_query(check_snmp_config_snmp_parameters parameters) {
if (parameters.ignore_mib_parsing_errors) {
char *opt_toggle_res = snmp_mib_toggle_options("e");
if (opt_toggle_res != NULL) {
die(STATE_UNKNOWN, "Unable to disable MIB parsing errors");
}
}
struct snmp_pdu *pdu = NULL;
if (parameters.use_getnext) {
pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
} else {
pdu = snmp_pdu_create(SNMP_MSG_GET);
}
for (size_t i = 0; i < parameters.num_of_test_units; i++) {
assert(parameters.test_units[i].oid != NULL);
if (verbose > 0) {
printf("OID %zu to parse: %s\n", i, parameters.test_units[i].oid);
}
oid tmp_OID[MAX_OID_LEN];
size_t tmp_OID_len = MAX_OID_LEN;
if (snmp_parse_oid(parameters.test_units[i].oid, tmp_OID, &tmp_OID_len) != NULL) {
// success
snmp_add_null_var(pdu, tmp_OID, tmp_OID_len);
} else {
// failed
snmp_perror("Parsing failure");
die(STATE_UNKNOWN, "Failed to parse OID\n");
}
}
const int timeout_safety_tolerance = 5;
alarm((timeout_interval * (unsigned int)parameters.snmp_session.retries) +
timeout_safety_tolerance);
struct snmp_session *active_session = snmp_open(&parameters.snmp_session);
if (active_session == NULL) {
int pcliberr = 0;
int psnmperr = 0;
char *pperrstring = NULL;
snmp_error(&parameters.snmp_session, &pcliberr, &psnmperr, &pperrstring);
die(STATE_UNKNOWN, "Failed to open SNMP session: %s\n", pperrstring);
}
struct snmp_pdu *response = NULL;
int snmp_query_status = snmp_synch_response(active_session, pdu, &response);
if (!(snmp_query_status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR)) {
int pcliberr = 0;
int psnmperr = 0;
char *pperrstring = NULL;
snmp_error(active_session, &pcliberr, &psnmperr, &pperrstring);
if (psnmperr == SNMPERR_TIMEOUT) {
// We exit with critical here for some historical reason
die(STATE_CRITICAL, "SNMP query ran into a timeout\n");
}
die(STATE_UNKNOWN, "SNMP query failed: %s\n", pperrstring);
}
snmp_close(active_session);
/* disable alarm again */
alarm(0);
snmp_responces result = {
.errorcode = OK,
.response_values = calloc(parameters.num_of_test_units, sizeof(response_value)),
};
if (result.response_values == NULL) {
result.errorcode = ERROR;
return result;
}
// We got the the query results, now process them
size_t loop_index = 0;
for (netsnmp_variable_list *vars = response->variables; vars;
vars = vars->next_variable, loop_index++) {
for (size_t jdx = 0; jdx < vars->name_length; jdx++) {
result.response_values[loop_index].oid[jdx] = vars->name[jdx];
}
result.response_values[loop_index].oid_length = vars->name_length;
switch (vars->type) {
case ASN_OCTET_STR: {
result.response_values[loop_index].string_response = strdup((char *)vars->val.string);
result.response_values[loop_index].type = vars->type;
if (verbose) {
printf("Debug: Got a string as response: %s\n", vars->val.string);
}
}
continue;
case ASN_OPAQUE:
if (verbose) {
printf("Debug: Got OPAQUE\n");
}
break;
/* Numerical values */
case ASN_COUNTER64: {
if (verbose) {
printf("Debug: Got counter64\n");
}
struct counter64 tmp = *(vars->val.counter64);
uint64_t counter = (tmp.high << 32) + tmp.low;
result.response_values[loop_index].value.uIntVal = counter;
result.response_values[loop_index].type = vars->type;
} break;
case ASN_GAUGE: // same as ASN_UNSIGNED
case ASN_TIMETICKS:
case ASN_COUNTER:
case ASN_UINTEGER: {
if (verbose) {
printf("Debug: Got a Integer like\n");
}
result.response_values[loop_index].value.uIntVal = (unsigned long)*(vars->val.integer);
result.response_values[loop_index].type = vars->type;
} break;
case ASN_INTEGER: {
if (verbose) {
printf("Debug: Got a Integer\n");
}
result.response_values[loop_index].value.intVal = *(vars->val.integer);
result.response_values[loop_index].type = vars->type;
} break;
case ASN_FLOAT: {
if (verbose) {
printf("Debug: Got a float\n");
}
result.response_values[loop_index].value.doubleVal = *(vars->val.floatVal);
result.response_values[loop_index].type = vars->type;
} break;
case ASN_DOUBLE: {
if (verbose) {
printf("Debug: Got a double\n");
}
result.response_values[loop_index].value.doubleVal = *(vars->val.doubleVal);
result.response_values[loop_index].type = vars->type;
break;
}
case ASN_IPADDRESS:
if (verbose) {
printf("Debug: Got an IP address\n");
}
result.response_values[loop_index].type = vars->type;
// TODO: print address here, state always ok? or regex match?
continue;
default:
if (verbose) {
printf("Debug: Got a unmatched result type: %hhu\n", vars->type);
}
// TODO: Error here?
continue;
}
}
return result;
}
check_snmp_evaluation evaluate_single_unit(response_value response,
check_snmp_evaluation_parameters eval_params,
check_snmp_test_unit test_unit, time_t query_timestamp,
check_snmp_state_entry prev_state,
bool have_previous_state) {
mp_subcheck sc_oid_test = mp_subcheck_init();
if ((test_unit.label != NULL) && (strcmp(test_unit.label, "") != 0)) {
xasprintf(&sc_oid_test.output, "%s - ", test_unit.label);
} else {
sc_oid_test.output = strdup("");
}
char oid_string[(MAX_OID_LEN * 2) + 1] = {};
int oid_string_result =
snprint_objid(oid_string, (MAX_OID_LEN * 2) + 1, response.oid, response.oid_length);
if (oid_string_result <= 0) {
// TODO error here
die(STATE_UNKNOWN, "snprint_objid failed\n");
}
xasprintf(&sc_oid_test.output, "%sOID: %s", sc_oid_test.output, oid_string);
sc_oid_test = mp_set_subcheck_default_state(sc_oid_test, STATE_OK);
if (verbose > 2) {
printf("Processing oid %s\n", oid_string);
}
bool got_a_numerical_value = false;
mp_perfdata_value pd_result_val = {0};
check_snmp_state_entry result_state = {
.timestamp = query_timestamp,
.oid_length = response.oid_length,
.type = response.type,
};
for (size_t i = 0; i < response.oid_length; i++) {
result_state.oid[i] = response.oid[i];
}
if (have_previous_state) {
if (query_timestamp == prev_state.timestamp) {
// somehow we have the same timestamp again, that can't be good
sc_oid_test = mp_set_subcheck_state(sc_oid_test, STATE_UNKNOWN);
xasprintf(&sc_oid_test.output, "Time duration between plugin calls is invalid");
check_snmp_evaluation result = {
.sc = sc_oid_test,
.state = result_state,
};
return result;
}
}
// compute rate time difference
double timeDiff = 0;
if (have_previous_state) {
if (verbose) {
printf("Previous timestamp: %s", ctime(&prev_state.timestamp));
printf("Current timestamp: %s", ctime(&query_timestamp));
}
timeDiff = difftime(query_timestamp, prev_state.timestamp) / eval_params.rate_multiplier;
}
mp_perfdata pd_num_val = {};
switch (response.type) {
case ASN_OCTET_STR: {
char *tmp = response.string_response;
if (strchr(tmp, '"') != NULL) {
// got double quote in the string
if (strchr(tmp, '\'') != NULL) {
// got single quote in the string too
// dont quote that at all to avoid even more confusion
xasprintf(&sc_oid_test.output, "%s - Value: %s", sc_oid_test.output, tmp);
} else {
// quote with single quotes
xasprintf(&sc_oid_test.output, "%s - Value: '%s'", sc_oid_test.output, tmp);
}
} else {
// quote with double quotes
xasprintf(&sc_oid_test.output, "%s - Value: \"%s\"", sc_oid_test.output, tmp);
}
if (strlen(tmp) == 0) {
sc_oid_test = mp_set_subcheck_state(sc_oid_test, eval_params.nulloid_result);
}
// String matching test
if ((test_unit.eval_mthd.crit_string)) {
if (strcmp(tmp, eval_params.string_cmp_value)) {
sc_oid_test = mp_set_subcheck_state(
sc_oid_test, (eval_params.invert_search) ? STATE_CRITICAL : STATE_OK);
} else {
sc_oid_test = mp_set_subcheck_state(
sc_oid_test, (eval_params.invert_search) ? STATE_OK : STATE_CRITICAL);
}
} else if (test_unit.eval_mthd.crit_regex) {
const size_t nmatch = eval_params.regex_cmp_value.re_nsub + 1;
regmatch_t pmatch[nmatch];
memset(pmatch, '\0', sizeof(regmatch_t) * nmatch);
int excode = regexec(&eval_params.regex_cmp_value, tmp, nmatch, pmatch, 0);
if (excode == 0) {
sc_oid_test = mp_set_subcheck_state(
sc_oid_test, (eval_params.invert_search) ? STATE_OK : STATE_CRITICAL);
} else if (excode != REG_NOMATCH) {
char errbuf[MAX_INPUT_BUFFER] = "";
regerror(excode, &eval_params.regex_cmp_value, errbuf, MAX_INPUT_BUFFER);
printf(_("Execute Error: %s\n"), errbuf);
exit(STATE_CRITICAL);
} else { // REG_NOMATCH
sc_oid_test = mp_set_subcheck_state(
sc_oid_test, eval_params.invert_search ? STATE_CRITICAL : STATE_OK);
}
}
} break;
case ASN_COUNTER64:
got_a_numerical_value = true;
result_state.value.uIntVal = response.value.uIntVal;
result_state.type = response.type;
// TODO: perfdata unit counter
if (eval_params.calculate_rate && have_previous_state) {
if (prev_state.value.uIntVal > response.value.uIntVal) {
// overflow
unsigned long long tmp =
(UINT64_MAX - prev_state.value.uIntVal) + response.value.uIntVal;
tmp /= timeDiff;
pd_result_val = mp_create_pd_value(tmp);
} else {
pd_result_val = mp_create_pd_value(
(response.value.uIntVal - prev_state.value.uIntVal) / timeDiff);
}
} else {
// It's only a counter if we cont compute rate
pd_num_val.uom = "c";
pd_result_val = mp_create_pd_value(response.value.uIntVal);
}
break;
case ASN_GAUGE: // same as ASN_UNSIGNED
case ASN_TIMETICKS:
case ASN_COUNTER:
case ASN_UINTEGER: {
got_a_numerical_value = true;
long long treated_value = (long long)response.value.uIntVal;
if (eval_params.multiplier_set || eval_params.offset_set) {
double processed = 0;
if (eval_params.offset_set) {
processed += eval_params.offset;
}
if (eval_params.multiplier_set) {
processed = processed * eval_params.multiplier;
}
treated_value = lround(processed);
}
result_state.value.intVal = treated_value;
if (eval_params.calculate_rate && have_previous_state) {
if (verbose > 2) {
printf("%s: Rate calculation (int/counter/gauge): prev: %lli\n", __FUNCTION__,
prev_state.value.intVal);
printf("%s: Rate calculation (int/counter/gauge): current: %lli\n", __FUNCTION__,
treated_value);
}
double rate = (treated_value - prev_state.value.intVal) / timeDiff;
pd_result_val = mp_create_pd_value(rate);
} else {
pd_result_val = mp_create_pd_value(treated_value);
if (response.type == ASN_COUNTER) {
pd_num_val.uom = "c";
}
}
} break;
case ASN_INTEGER: {
if (eval_params.multiplier_set || eval_params.offset_set) {
double processed = 0;
if (eval_params.multiplier_set) {
processed = (double)response.value.intVal * eval_params.multiplier;
}
if (eval_params.offset_set) {
processed += eval_params.offset;
}
result_state.value.doubleVal = processed;
if (eval_params.calculate_rate && have_previous_state) {
pd_result_val =
mp_create_pd_value((processed - prev_state.value.doubleVal) / timeDiff);
} else {
pd_result_val = mp_create_pd_value(processed);
}
} else {
result_state.value.intVal = response.value.intVal;
if (eval_params.calculate_rate && have_previous_state) {
pd_result_val = mp_create_pd_value(
(response.value.intVal - prev_state.value.intVal) / timeDiff);
} else {
pd_result_val = mp_create_pd_value(response.value.intVal);
}
}
got_a_numerical_value = true;
} break;
case ASN_FLOAT: // fallthrough
case ASN_DOUBLE: {
got_a_numerical_value = true;
double tmp = response.value.doubleVal;
if (eval_params.offset_set) {
tmp += eval_params.offset;
}
if (eval_params.multiplier_set) {
tmp *= eval_params.multiplier;
}
if (eval_params.calculate_rate && have_previous_state) {
pd_result_val = mp_create_pd_value((tmp - prev_state.value.doubleVal) / timeDiff);
} else {
pd_result_val = mp_create_pd_value(tmp);
}
got_a_numerical_value = true;
result_state.value.doubleVal = tmp;
} break;
case ASN_IPADDRESS:
// TODO
}
if (got_a_numerical_value) {
if (eval_params.use_oid_as_perf_data_label) {
// Use oid for perdata label
pd_num_val.label = strdup(oid_string);
// TODO strdup error checking
} else if (test_unit.label != NULL && strcmp(test_unit.label, "") != 0) {
pd_num_val.label = strdup(test_unit.label);
} else {
pd_num_val.label = strdup(test_unit.oid);
}
if (!(eval_params.calculate_rate && !have_previous_state)) {
// some kind of numerical value
if (test_unit.unit_value != NULL && strcmp(test_unit.unit_value, "") != 0) {
pd_num_val.uom = test_unit.unit_value;
}
pd_num_val.value = pd_result_val;
xasprintf(&sc_oid_test.output, "%s Value: %s", sc_oid_test.output,
pd_value_to_string(pd_result_val));
if (test_unit.unit_value != NULL && strcmp(test_unit.unit_value, "") != 0) {
xasprintf(&sc_oid_test.output, "%s%s", sc_oid_test.output, test_unit.unit_value);
}
if (test_unit.threshold.warning_is_set || test_unit.threshold.critical_is_set) {
pd_num_val = mp_pd_set_thresholds(pd_num_val, test_unit.threshold);
mp_state_enum tmp_state = mp_get_pd_status(pd_num_val);
if (tmp_state == STATE_WARNING) {
sc_oid_test = mp_set_subcheck_state(sc_oid_test, STATE_WARNING);
xasprintf(&sc_oid_test.output, "%s - number violates warning threshold",
sc_oid_test.output);
} else if (tmp_state == STATE_CRITICAL) {
sc_oid_test = mp_set_subcheck_state(sc_oid_test, STATE_CRITICAL);
xasprintf(&sc_oid_test.output, "%s - number violates critical threshold",
sc_oid_test.output);
}
}
mp_add_perfdata_to_subcheck(&sc_oid_test, pd_num_val);
} else {
// should calculate rate, but there is no previous state, so first run
// exit with ok now
sc_oid_test = mp_set_subcheck_state(sc_oid_test, STATE_OK);
xasprintf(&sc_oid_test.output, "%s - No previous data to calculate rate - assume okay",
sc_oid_test.output);
}
}
check_snmp_evaluation result = {
.sc = sc_oid_test,
.state = result_state,
};
return result;
}
char *_np_state_generate_key(int argc, char **argv);
/*
* If time=NULL, use current time. Create state file, with state format
* version, default text. Writes version, time, and data. Avoid locking
* problems - use mv to write and then swap. Possible loss of state data if
* two things writing to same key at same time.
* Will die with UNKNOWN if errors
*/
void np_state_write_string(state_key stateKey, time_t timestamp, char *stringToStore) {
time_t current_time;
if (timestamp == 0) {
time(&current_time);
} else {
current_time = timestamp;
}
int result = 0;
/* If file doesn't currently exist, create directories */
if (access(stateKey._filename, F_OK) != 0) {
char *directories = NULL;
result = asprintf(&directories, "%s", stateKey._filename);
if (result < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
for (char *p = directories + 1; *p; p++) {
if (*p == '/') {
*p = '\0';
if ((access(directories, F_OK) != 0) && (mkdir(directories, S_IRWXU) != 0)) {
/* Can't free this! Otherwise error message is wrong! */
/* np_free(directories); */
die(STATE_UNKNOWN, _("Cannot create directory: %s"), directories);
}
*p = '/';
}
}
if (directories) {
free(directories);
}
}
char *temp_file = NULL;
result = asprintf(&temp_file, "%s.XXXXXX", stateKey._filename);
if (result < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
int temp_file_desc = 0;
if ((temp_file_desc = mkstemp(temp_file)) == -1) {
if (temp_file) {
free(temp_file);
}
die(STATE_UNKNOWN, _("Cannot create temporary filename"));
}
FILE *temp_file_pointer = fdopen(temp_file_desc, "w");
if (temp_file_pointer == NULL) {
close(temp_file_desc);
unlink(temp_file);
if (temp_file) {
free(temp_file);
}
die(STATE_UNKNOWN, _("Unable to open temporary state file"));
}
fprintf(temp_file_pointer, "# NP State file\n");
fprintf(temp_file_pointer, "%d\n", NP_STATE_FORMAT_VERSION);
fprintf(temp_file_pointer, "%d\n", stateKey.data_version);
fprintf(temp_file_pointer, "%lu\n", current_time);
fprintf(temp_file_pointer, "%s\n", stringToStore);
fchmod(temp_file_desc, S_IRUSR | S_IWUSR | S_IRGRP);
fflush(temp_file_pointer);
result = fclose(temp_file_pointer);
fsync(temp_file_desc);
if (result != 0) {
unlink(temp_file);
if (temp_file) {
free(temp_file);
}
die(STATE_UNKNOWN, _("Error writing temp file"));
}
if (rename(temp_file, stateKey._filename) != 0) {
unlink(temp_file);
if (temp_file) {
free(temp_file);
}
die(STATE_UNKNOWN, _("Cannot rename state temp file"));
}
if (temp_file) {
free(temp_file);
}
}
/*
* Read the state file
*/
bool _np_state_read_file(FILE *state_file, state_key stateKey) {
time_t current_time;
time(&current_time);
/* Note: This introduces a limit of 8192 bytes in the string data */
char *line = (char *)calloc(1, 8192);
if (line == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
bool status = false;
enum {
STATE_FILE_VERSION,
STATE_DATA_VERSION,
STATE_DATA_TIME,
STATE_DATA_TEXT,
STATE_DATA_END
} expected = STATE_FILE_VERSION;
int failure = 0;
while (!failure && (fgets(line, 8192, state_file)) != NULL) {
size_t pos = strlen(line);
if (line[pos - 1] == '\n') {
line[pos - 1] = '\0';
}
if (line[0] == '#') {
continue;
}
switch (expected) {
case STATE_FILE_VERSION: {
int i = atoi(line);
if (i != NP_STATE_FORMAT_VERSION) {
failure++;
} else {
expected = STATE_DATA_VERSION;
}
} break;
case STATE_DATA_VERSION: {
int i = atoi(line);
if (i != stateKey.data_version) {
failure++;
} else {
expected = STATE_DATA_TIME;
}
} break;
case STATE_DATA_TIME: {
/* If time > now, error */
time_t data_time = strtoul(line, NULL, 10);
if (data_time > current_time) {
failure++;
} else {
stateKey.state_data->time = data_time;
expected = STATE_DATA_TEXT;
}
} break;
case STATE_DATA_TEXT:
stateKey.state_data->data = strdup(line);
if (stateKey.state_data->data == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
stateKey.state_data->length = strlen(line);
expected = STATE_DATA_END;
status = true;
break;
case STATE_DATA_END:;
}
}
if (line) {
free(line);
}
return status;
}
/*
* Will return NULL if no data is available (first run). If key currently
* exists, read data. If state file format version is not expected, return
* as if no data. Get state data version number and compares to expected.
* If numerically lower, then return as no previous state. die with UNKNOWN
* if exceptional error.
*/
state_data *np_state_read(state_key stateKey) {
/* Open file. If this fails, no previous state found */
FILE *statefile = fopen(stateKey._filename, "r");
state_data *this_state_data = (state_data *)calloc(1, sizeof(state_data));
if (statefile != NULL) {
if (this_state_data == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
this_state_data->data = NULL;
stateKey.state_data = this_state_data;
if (_np_state_read_file(statefile, stateKey)) {
this_state_data->errorcode = OK;
} else {
this_state_data->errorcode = ERROR;
}
fclose(statefile);
} else {
// Failed to open state file
this_state_data->errorcode = ERROR;
}
return stateKey.state_data;
}
/*
* Internal function. Returns either:
* envvar NAGIOS_PLUGIN_STATE_DIRECTORY
* statically compiled shared state directory
*/
char *_np_state_calculate_location_prefix(void) {
char *env_dir;
/* Do not allow passing MP_STATE_PATH in setuid plugins
* for security reasons */
if (!mp_suid()) {
env_dir = getenv("MP_STATE_PATH");
if (env_dir && env_dir[0] != '\0') {
return env_dir;
}
/* This is the former ENV, for backward-compatibility */
env_dir = getenv("NAGIOS_PLUGIN_STATE_DIRECTORY");
if (env_dir && env_dir[0] != '\0') {
return env_dir;
}
}
return NP_STATE_DIR_PREFIX;
}
/*
* Initiatializer for state routines.
* Sets variables. Generates filename. Returns np_state_key. die with
* UNKNOWN if exception
*/
state_key np_enable_state(char *keyname, int expected_data_version, char *plugin_name, int argc,
char **argv) {
state_key *this_state = (state_key *)calloc(1, sizeof(state_key));
if (this_state == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
char *temp_keyname = NULL;
if (keyname == NULL) {
temp_keyname = _np_state_generate_key(argc, argv);
} else {
temp_keyname = strdup(keyname);
if (temp_keyname == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
}
/* Die if invalid characters used for keyname */
char *tmp_char = temp_keyname;
while (*tmp_char != '\0') {
if (!(isalnum(*tmp_char) || *tmp_char == '_')) {
die(STATE_UNKNOWN, _("Invalid character for keyname - only alphanumerics or '_'"));
}
tmp_char++;
}
this_state->name = temp_keyname;
this_state->plugin_name = plugin_name;
this_state->data_version = expected_data_version;
this_state->state_data = NULL;
/* Calculate filename */
char *temp_filename = NULL;
int error = asprintf(&temp_filename, "%s/%lu/%s/%s", _np_state_calculate_location_prefix(),
(unsigned long)geteuid(), plugin_name, this_state->name);
if (error < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
this_state->_filename = temp_filename;
return *this_state;
}
/*
* Returns a string to use as a keyname, based on an md5 hash of argv, thus
* hopefully a unique key per service/plugin invocation. Use the extra-opts
* parse of argv, so that uniqueness in parameters are reflected there.
*/
char *_np_state_generate_key(int argc, char **argv) {
unsigned char result[256];
#ifdef USE_OPENSSL
/*
* This code path is chosen if openssl is available (which should be the most common
* scenario). Alternatively, the gnulib implementation/
*
*/
EVP_MD_CTX *ctx = EVP_MD_CTX_new();
EVP_DigestInit(ctx, EVP_sha256());
for (int i = 0; i < argc; i++) {
EVP_DigestUpdate(ctx, argv[i], strlen(argv[i]));
}
EVP_DigestFinal(ctx, result, NULL);
#else
struct sha256_ctx ctx;
for (int i = 0; i < this_monitoring_plugin->argc; i++) {
sha256_process_bytes(argv[i], strlen(argv[i]), &ctx);
}
sha256_finish_ctx(&ctx, result);
#endif // FOUNDOPENSSL
char keyname[41];
for (int i = 0; i < 20; ++i) {
sprintf(&keyname[2 * i], "%02x", result[i]);
}
keyname[40] = '\0';
char *keyname_copy = strdup(keyname);
if (keyname_copy == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
return keyname_copy;
}

64
plugins/check_snmp.d/check_snmp_helpers.h
View file

@ -1,7 +1,71 @@
#pragma once
#include "./config.h"
#include <net-snmp/library/asn1.h>
check_snmp_test_unit check_snmp_test_unit_init();
int check_snmp_set_thresholds(const char *, check_snmp_test_unit[], size_t, bool);
check_snmp_config check_snmp_config_init();
typedef struct {
oid oid[MAX_OID_LEN];
size_t oid_length;
unsigned char type;
union {
uint64_t uIntVal;
int64_t intVal;
double doubleVal;
} value;
char *string_response;
} response_value;
typedef struct {
int errorcode;
response_value *response_values;
} snmp_responces;
snmp_responces do_snmp_query(check_snmp_config_snmp_parameters parameters);
// state is similar to response, but only numerics and a timestamp
typedef struct {
time_t timestamp;
oid oid[MAX_OID_LEN];
size_t oid_length;
unsigned char type;
union {
unsigned long long uIntVal;
long long intVal;
double doubleVal;
} value;
} check_snmp_state_entry;
typedef struct {
check_snmp_state_entry state;
mp_subcheck sc;
} check_snmp_evaluation;
check_snmp_evaluation evaluate_single_unit(response_value response,
check_snmp_evaluation_parameters eval_params,
check_snmp_test_unit test_unit, time_t query_timestamp,
check_snmp_state_entry prev_state,
bool have_previous_state);
#define NP_STATE_FORMAT_VERSION 1
typedef struct state_data_struct {
time_t time;
void *data;
size_t length; /* Of binary data */
int errorcode;
} state_data;
typedef struct state_key_struct {
char *name;
char *plugin_name;
int data_version;
char *_filename;
state_data *state_data;
} state_key;
state_data *np_state_read(state_key stateKey);
state_key np_enable_state(char *keyname, int expected_data_version, char *plugin_name, int argc,
char **argv);
void np_state_write_string(state_key stateKey, time_t timestamp, char *stringToStore);

25
plugins/check_snmp.d/config.h
View file

@ -1,7 +1,7 @@
#pragma once
#include "thresholds.h"
#include "states.h"
#include "../../lib/thresholds.h"
#include "../../lib/states.h"
#include <stdlib.h>
#include <stdbool.h>
#include <regex.h>
@ -18,7 +18,7 @@
#include <net-snmp/library/snmp.h>
#include <net-snmp/session_api.h>
#define DEFAULT_PORT "161"
#define DEFAULT_PORT "161"
#define DEFAULT_RETRIES 5
typedef struct eval_method {
@ -34,10 +34,8 @@ typedef struct check_snmp_test_unit {
mp_thresholds threshold;
} check_snmp_test_unit;
typedef struct check_snmp_config {
// SNMP session to use
typedef struct {
struct snmp_session snmp_session;
// use getnet instead of get
bool use_getnext;
@ -47,7 +45,9 @@ typedef struct check_snmp_config {
check_snmp_test_unit *test_units;
size_t num_of_test_units;
} check_snmp_config_snmp_parameters;
typedef struct {
// State if an empty value is encountered
mp_state_enum nulloid_result;
@ -63,7 +63,18 @@ typedef struct check_snmp_config {
bool offset_set;
// Modify output
bool use_perf_data_labels_from_input;
bool use_oid_as_perf_data_label;
// activate rate calucation
bool calculate_rate;
unsigned int rate_multiplier;
} check_snmp_evaluation_parameters;
typedef struct check_snmp_config {
// SNMP session to use
check_snmp_config_snmp_parameters snmp_params;
check_snmp_evaluation_parameters evaluation_params;
mp_output_format output_format;
bool output_format_is_set;

159
plugins/tests/check_snmp.t
View file

@ -4,12 +4,13 @@
#
use strict;
use warnings;
use Test::More;
use NPTest;
use FindBin qw($Bin);
use POSIX qw/strftime/;
my $tests = 81;
my $tests = 75;
# Check that all dependent modules are available
eval {
require NetSNMP::OID;
@ -76,49 +77,36 @@ my $res;
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.0");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying a multi-line string" );
like($res->output, '/^SNMP OK - /', "String contains SNMP OK");
like($res->output, '/'.quotemeta('SNMP OK - Cisco Internetwork Operating System Software |
.1.3.6.1.4.1.8072.3.2.67.0:
"Cisco Internetwork Operating System Software
IOS (tm) Catalyst 4000 \"L3\" Switch Software (cat4000-I9K91S-M), Version
12.2(20)EWA, RELEASE SOFTWARE (fc1)
Technical Support: http://www.cisco.com/techsupport
Copyright (c) 1986-2004 by cisco Systems, Inc.
"').'/m', "String contains all lines");
like($res->output, '/.*Cisco Internetwork Operating System Software.*/m', "String contains all lines");
# sysContact.0 is "Alice" (from our snmpd.conf)
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.0 -o sysContact.0 -o .1.3.6.1.4.1.8072.3.2.67.1");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying multi-line OIDs" );
like($res->output, '/^SNMP OK - /', "String contains SNMP OK");
like($res->output, '/'.quotemeta('SNMP OK - Cisco Internetwork Operating System Software ').'"?Alice"?'.quotemeta(' Kisco Outernetwork Oserating Gystem Totware |
.1.3.6.1.4.1.8072.3.2.67.0:
"Cisco Internetwork Operating System Software
IOS (tm) Catalyst 4000 \"L3\" Switch Software (cat4000-I9K91S-M), Version
12.2(20)EWA, RELEASE SOFTWARE (fc1)
Technical Support: http://www.cisco.com/techsupport
Copyright (c) 1986-2004 by cisco Systems, Inc.
"
.1.3.6.1.4.1.8072.3.2.67.1:
"Kisco Outernetwork Oserating Gystem Totware
Copyleft (c) 2400-2689 by kisco Systrems, Inc."').'/m', "String contains all lines with multiple OIDs");
# like($res->output, '/^SNMP OK - /', "String contains SNMP OK");
like($res->output, '/.*Cisco Internetwork Operating System Software.*/m', "String contains all lines with multiple OIDs");
like($res->output, '/.*Alice.*/m', "String contains all lines with multiple OIDs");
like($res->output, '/.*Kisco Outernetwork Oserating Gystem Totware.*/m', "String contains all lines with multiple OIDs");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.2");
like($res->output, '/'.quotemeta('SNMP OK - This should not confuse check_snmp \"parser\" |
.1.3.6.1.4.1.8072.3.2.67.2:
"This should not confuse check_snmp \"parser\"
into thinking there is no 2nd line"').'/m', "Attempt to confuse parser No.1");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying multi-line OIDs" );
# like($res->output, '/'.quotemeta('This should not confuse check_snmp \"parser\" |
# .1.3.6.1.4.1.8072.3.2.67.2:
# "This should not confuse check_snmp \"parser\"
# into thinking there is no 2nd line"').'/m', "Attempt to confuse parser No.1");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.3");
like($res->output, '/'.quotemeta('SNMP OK - It\'s getting even harder if the line |
.1.3.6.1.4.1.8072.3.2.67.3:
"It\'s getting even harder if the line
ends with with this: C:\\\\"').'/m', "Attempt to confuse parser No.2");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying multi-line OIDs" );
# like($res->output, '/'.quotemeta('It\'s getting even harder if the line |
# .1.3.6.1.4.1.8072.3.2.67.3:
# "It\'s getting even harder if the line
# ends with with this: C:\\\\"').'/m', "Attempt to confuse parser No.2");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.4");
like($res->output, '/'.quotemeta('SNMP OK - And now have fun with with this: \"C:\\\\\" |
.1.3.6.1.4.1.8072.3.2.67.4:
"And now have fun with with this: \"C:\\\\\"
because we\'re not done yet!"').'/m', "Attempt to confuse parser No.3");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying multi-line OIDs" );
# like($res->output, '/'.quotemeta('And now have fun with with this: \"C:\\\\\" |
# .1.3.6.1.4.1.8072.3.2.67.4:
# "And now have fun with with this: \"C:\\\\\"
# because we\'re not done yet!"').'/m', "Attempt to confuse parser No.3");
system("rm -f ".$ENV{'MP_STATE_PATH'}."/*/check_snmp/*");
@ -131,156 +119,159 @@ SKIP: {
my $ts = time();
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" );
is($res->return_code, 0, "Returns OK");
is($res->output, "No previous data to calculate rate - assume okay");
like($res->output, "/.*No previous data to calculate rate - assume okay.*/");
# test rate 1 second later
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" );
is($res->return_code, 1, "WARNING - due to going above rate calculation" );
is($res->output, "SNMP RATE WARNING - *666* | iso.3.6.1.4.1.8072.3.2.67.10=666;600 ");
like($res->output, "/.*=666.*/");
# test rate with same time
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" );
is($res->return_code, 3, "UNKNOWN - basically the divide by zero error" );
is($res->output, "Time duration between plugin calls is invalid");
like($res->output, "/.*Time duration between plugin calls is invalid.*/");
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" );
is($res->return_code, 0, "OK for first call" );
is($res->output, "No previous data to calculate rate - assume okay" );
like($res->output, "/.*No previous data to calculate rate - assume okay.*/" );
# test rate 1 second later
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP RATE OK - inoctets 666 | inoctets=666 ", "Check label");
like($res->output, "/.*inoctets.*=666.*/m", "Check label");
# test rate 3 seconds later
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+3))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP RATE OK - inoctets 333 | inoctets=333 ", "Check rate decreases due to longer interval");
like($res->output, "/.*inoctets.*333.*/", "Check rate decreases due to longer interval");
# label performance data check
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l test" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP OK - test 67996 | test=67996c ", "Check label");
like($res->output, "/.*test.?=67996c/", "Check label");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l \"test'test\"" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP OK - test'test 68662 | \"test'test\"=68662c ", "Check label");
# following test is deactivated since it was not valid due to the guidelines (no single quote in label allowed)
# $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l \"test'test\"" );
# is($res->return_code, 0, "OK as no thresholds" );
# is($res->output, "test'test 68662 | \"test'test\"=68662c ", "Check label");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l 'test\"test'" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP OK - test\"test 69328 | 'test\"test'=69328c ", "Check label");
like($res->output, "/.*'test\"test'=68662c.*/", "Check label");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l test -O" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP OK - test 69994 | iso.3.6.1.4.1.8072.3.2.67.10=69994c ", "Check label");
like($res->output, "/.*.67.10.?=69328c.*/", "Check label");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP OK - 70660 | iso.3.6.1.4.1.8072.3.2.67.10=70660c ", "Check label");
like($res->output, "/.*8072.3.2.67.10.?=69994c.*/", "Check label");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l 'test test'" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP OK - test test 71326 | 'test test'=71326c ", "Check label");
like($res->output, "/.*'test test'=70660c/", "Check label");
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets_per_minute --rate-multiplier=60" );
is($res->return_code, 0, "OK for first call" );
is($res->output, "No previous data to calculate rate - assume okay" );
like($res->output, "/.*No previous data to calculate rate - assume okay.*/" );
# test 1 second later
$res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets_per_minute --rate-multiplier=60" );
is($res->return_code, 0, "OK as no thresholds" );
is($res->output, "SNMP RATE OK - inoctets_per_minute 39960 | inoctets_per_minute=39960 ", "Checking multiplier");
like($res->output, "/.*inoctets_per_minute.*=39960/", "Checking multiplier");
};
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 -s '\"stringtests\"'" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 -s 'stringtests'" );
is($res->return_code, 0, "OK as string matches" );
is($res->output, 'SNMP OK - "stringtests" | ', "Good string match" );
like($res->output, '/.*stringtests.*/', "Good string match" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 -s ring" );
is($res->return_code, 2, "CRITICAL as string doesn't match (though is a substring)" );
is($res->output, 'SNMP CRITICAL - *"stringtests"* | ', "Failed string match" );
like($res->output, '/.*stringtests.*/', "Failed string match" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 --invert-search -s '\"stringtests\"'" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 --invert-search -s 'stringtests'" );
is($res->return_code, 2, "CRITICAL as string matches but inverted" );
is($res->output, 'SNMP CRITICAL - *"stringtests"* | ', "Inverted string match" );
like($res->output, '/.*"stringtests".*/', "Inverted string match" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 --invert-search -s ring" );
is($res->return_code, 0, "OK as string doesn't match but inverted" );
is($res->output, 'SNMP OK - "stringtests" | ', "OK as inverted string no match" );
like($res->output, '/.*"stringtests".*/', "OK as inverted string no match" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.12 -w 4:5" );
is($res->return_code, 1, "Numeric in string test" );
is($res->output, 'SNMP WARNING - *3.5* | iso.3.6.1.4.1.8072.3.2.67.12=3.5;4:5 ', "WARNING threshold checks for string masquerading as number" );
# a string is a string and not a number
is($res->return_code, 0, "Numeric in string test" );
like($res->output, '/.*3.5.*| iso.3.6.1.4.1.8072.3.2.67.12=3.5;4:5/', "WARNING threshold checks for string masquerading as number" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.13" );
is($res->return_code, 0, "Not really numeric test" );
is($res->output, 'SNMP OK - "87.4startswithnumberbutshouldbestring" | ', "Check string with numeric start is still string" );
like($res->output, '/.*"87.4startswithnumberbutshouldbestring".*/', "Check string with numeric start is still string" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.14" );
is($res->return_code, 0, "Not really numeric test (trying best to fool it)" );
is($res->output, 'SNMP OK - "555\"I said\"" | ', "Check string with a double quote following is still a string (looks like the perl routine will always escape though)" );
like($res->output, '/.*\'555"I said"\'.*/', "Check string with a double quote following is still a string (looks like the perl routine will always escape though)" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.15 -r 'CUSTOM CHECK OK'" );
is($res->return_code, 0, "String check should check whole string, not a parsed number" );
is($res->output, 'SNMP OK - "CUSTOM CHECK OK: foo is 12345" | ', "String check with numbers returns whole string");
like($res->output, '/.*CUSTOM CHECK OK: foo is 12345.*/', "String check with numbers returns whole string");
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.16 -w -2: -c -3:" );
is($res->return_code, 0, "Negative integer check OK" );
is($res->output, 'SNMP OK - -2 | iso.3.6.1.4.1.8072.3.2.67.16=-2;-2:;-3: ', "Negative integer check OK output" );
like($res->output, '/.*-2.*| iso.3.6.1.4.1.8072.3.2.67.16=-2;-2:;-3:/', "Negative integer check OK output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.16 -w -2: -c -3:" );
is($res->return_code, 1, "Negative integer check WARNING" );
is($res->output, 'SNMP WARNING - *-3* | iso.3.6.1.4.1.8072.3.2.67.16=-3;-2:;-3: ', "Negative integer check WARNING output" );
like($res->output, '/.*-3.*| iso.3.6.1.4.1.8072.3.2.67.16=-3;-2:;-3:/', "Negative integer check WARNING output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.16 -w -2: -c -3:" );
is($res->return_code, 2, "Negative integer check CRITICAL" );
is($res->output, 'SNMP CRITICAL - *-4* | iso.3.6.1.4.1.8072.3.2.67.16=-4;-2:;-3: ', "Negative integer check CRITICAL output" );
like($res->output, '/.*-4.*| iso.3.6.1.4.1.8072.3.2.67.16=-4;-2:;-3:/', "Negative integer check CRITICAL output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.17 -w -3: -c -6:" );
is($res->return_code, 1, "Negative integer as string, WARNING" );
is($res->output, 'SNMP WARNING - *-4* | iso.3.6.1.4.1.8072.3.2.67.17=-4;-3:;-6: ', "Negative integer as string, WARNING output" );
like($res->output, '/.*-4.*| iso.3.6.1.4.1.8072.3.2.67.17=-4;-3:;-6:/', "Negative integer as string, WARNING output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.17 -w -2: -c -3:" );
is($res->return_code, 2, "Negative integer as string, CRITICAL" );
is($res->output, 'SNMP CRITICAL - *-4* | iso.3.6.1.4.1.8072.3.2.67.17=-4;-2:;-3: ', "Negative integer as string, CRITICAL output" );
like($res->output, '/.*-4.*| iso.3.6.1.4.1.8072.3.2.67.17=-4;-2:;-3:/', "Negative integer as string, CRITICAL output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -c '~:-6.5'" );
is($res->return_code, 0, "Negative float OK" );
is($res->output, 'SNMP OK - -6.6 | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;;@-6.5:~ ', "Negative float OK output" );
# deactivated since the perl agent api of snmpd really does not allow floats
# $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -c '~:-6.5'" );
# is($res->return_code, 0, "Negative float OK" );
# is($res->output, '-6.6 | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;;@-6.5:~ ', "Negative float OK output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -w '~:-6.65' -c '~:-6.55'" );
is($res->return_code, 1, "Negative float WARNING" );
is($res->output, 'SNMP WARNING - *-6.6* | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;@-6.65:~;@-6.55:~ ', "Negative float WARNING output" );
# $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -w '~:-6.65' -c '~:-6.55'" );
# is($res->return_code, 1, "Negative float WARNING" );
# like($res->output, '/-6.6.*| .*67.18=-6.6;@-6.65:~;@-6.55:~/', "Negative float WARNING output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w '1:100000,-10:20' -c '2:200000,-20:30'" );
is($res->return_code, 0, "Multiple OIDs with thresholds" );
like($res->output, '/SNMP OK - \d+ -4 | iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1:100000;2:200000 iso.3.6.1.4.1.8072.3.2.67.17=-4;-10:20;-20:30/', "Multiple OIDs with thresholds output" );
like($res->output, '/-4.*| .*67.10=\d+c;1:100000;2:200000 .*67.17=-4;-10:20;-20:30/', "Multiple OIDs with thresholds output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w '1:100000,-1:2' -c '2:200000,-20:30'" );
is($res->return_code, 1, "Multiple OIDs with thresholds" );
like($res->output, '/SNMP WARNING - \d+ \*-4\* | iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1:100000;2:200000 iso.3.6.1.4.1.8072.3.2.67.17=-4;-10:20;-20:30/', "Multiple OIDs with thresholds output" );
like($res->output, '/-4.*| iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1:100000;2:200000 iso.3.6.1.4.1.8072.3.2.67.17=-4;-10:20;-20:30/', "Multiple OIDs with thresholds output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w 1,2 -c 1" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w 1,2 -c 1 -O" );
is($res->return_code, 2, "Multiple OIDs with some thresholds" );
like($res->output, '/SNMP CRITICAL - \*\d+\* \*-4\* | iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1;2 iso.3.6.1.4.1.8072.3.2.67.17=-4;;/', "Multiple OIDs with thresholds output" );
like($res->output, '/.*-4.*| iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1;2 iso.3.6.1.4.1.8072.3.2.67.17=-4;;/', "Multiple OIDs with thresholds output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.19");
is($res->return_code, 0, "Test plain .1.3.6.1.4.1.8072.3.2.67.6 RC" );
is($res->output,'SNMP OK - 42 | iso.3.6.1.4.1.8072.3.2.67.19=42 ', "Test plain value of .1.3.6.1.4.1.8072.3.2.67.1" );
like($res->output,'/.*42.*| iso.3.6.1.4.1.8072.3.2.67.19=42/', "Test plain value of .1.3.6.1.4.1.8072.3.2.67.1" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.19 -M .1");
is($res->return_code, 0, "Test multiply RC" );
is($res->output,'SNMP OK - 4.200000 | iso.3.6.1.4.1.8072.3.2.67.19=4.200000 ' , "Test multiply .1 output" );
like($res->output,'/.*4.200000.*| iso.3.6.1.4.1.8072.3.2.67.19=4.200000/' , "Test multiply .1 output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.19 --multiplier=.1 -f '%.2f' ");
is($res->return_code, 0, "Test multiply RC + format" );
is($res->output, 'SNMP OK - 4.20 | iso.3.6.1.4.1.8072.3.2.67.19=4.20 ', "Test multiply .1 output + format" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.19 --multiplier=.1");
is($res->return_code, 0, "Test multiply RC" );
like($res->output, '/.*4.20.*| iso.3.6.1.4.1.8072.3.2.67.19=4.20/', "Test multiply .1 output" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.19 --multiplier=.1 -f '%.2f' -w 1");
is($res->return_code, 1, "Test multiply RC + format + thresholds" );
is($res->output, 'SNMP WARNING - *4.20* | iso.3.6.1.4.1.8072.3.2.67.19=4.20;1 ', "Test multiply .1 output + format + thresholds" );
$res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.19 --multiplier=.1 -w 1");
is($res->return_code, 1, "Test multiply RC + thresholds" );
like($res->output, '/.*4.20.* | iso.3.6.1.4.1.8072.3.2.67.19=4.20+;1/', "Test multiply .1 output + thresholds" );

78
plugins/tests/check_snmp_agent.pl
View file

@ -4,9 +4,10 @@
#
#use strict; # Doesn't work
use warnings;
use NetSNMP::OID qw(:all);
use NetSNMP::agent;
use NetSNMP::ASN qw(ASN_OCTET_STR ASN_COUNTER ASN_COUNTER64 ASN_INTEGER ASN_INTEGER64 ASN_UNSIGNED ASN_UNSIGNED64);
use NetSNMP::ASN qw(ASN_OCTET_STR ASN_COUNTER ASN_COUNTER64 ASN_INTEGER ASN_INTEGER64 ASN_UNSIGNED ASN_UNSIGNED64 ASN_FLOAT);
#use Math::Int64 qw(uint64); # Skip that module while we don't need it
sub uint64 { return $_ }
@ -22,21 +23,82 @@ IOS (tm) Catalyst 4000 "L3" Switch Software (cat4000-I9K91S-M), Version
Technical Support: http://www.cisco.com/techsupport
Copyright (c) 1986-2004 by cisco Systems, Inc.
';
my $multilin2 = "Kisco Outernetwork Oserating Gystem Totware
my $multiline2 = "Kisco Outernetwork Oserating Gystem Totware
Copyleft (c) 2400-2689 by kisco Systrems, Inc.";
my $multilin3 = 'This should not confuse check_snmp "parser"
my $multiline3 = 'This should not confuse check_snmp "parser"
into thinking there is no 2nd line';
my $multilin4 = 'It\'s getting even harder if the line
my $multiline4 = 'It\'s getting even harder if the line
ends with with this: C:\\';
my $multilin5 = 'And now have fun with with this: "C:\\"
my $multiline5 = 'And now have fun with with this: "C:\\"
because we\'re not done yet!';
# Next are arrays of indexes (Type, initial value and increments)
# 0..19 <---- please update comment when adding/removing fields
my @fields = (ASN_OCTET_STR, ASN_OCTET_STR, ASN_OCTET_STR, ASN_OCTET_STR, ASN_OCTET_STR, ASN_UNSIGNED, ASN_UNSIGNED, ASN_COUNTER, ASN_COUNTER64, ASN_UNSIGNED, ASN_COUNTER, ASN_OCTET_STR, ASN_OCTET_STR, ASN_OCTET_STR, ASN_OCTET_STR, ASN_OCTET_STR, ASN_INTEGER, ASN_OCTET_STR, ASN_OCTET_STR, ASN_INTEGER );
my @values = ($multiline, $multilin2, $multilin3, $multilin4, $multilin5, 4294965296, 1000, 4294965296, uint64("18446744073709351616"), int(rand(2**32)), 64000, "stringtests", "3.5", "87.4startswithnumberbutshouldbestring", '555"I said"', 'CUSTOM CHECK OK: foo is 12345', -2, '-4', '-6.6', 42 );
my @fields = (ASN_OCTET_STR, # 0
ASN_OCTET_STR, # 1
ASN_OCTET_STR, # 2
ASN_OCTET_STR, # 3
ASN_OCTET_STR, # 4
ASN_UNSIGNED, # 5
ASN_UNSIGNED, # 6
ASN_COUNTER, # 7
ASN_COUNTER64, # 8
ASN_UNSIGNED, # 9
ASN_COUNTER, # 10
ASN_OCTET_STR, # 11
ASN_OCTET_STR, # 12
ASN_OCTET_STR, # 13
ASN_OCTET_STR, # 14
ASN_OCTET_STR, # 15
ASN_INTEGER, # 16
ASN_INTEGER, # 17
ASN_FLOAT, # 18
ASN_INTEGER # 19
);
my @values = ($multiline, # 0
$multiline2, # 1
$multiline3, # 2
$multiline4, # 3
$multiline5, # 4
4294965296, # 5
1000, # 6
4294965296, # 7
uint64("18446744073709351616"), # 8
int(rand(2**32)), # 9
64000, # 10
"stringtests", # 11
"3.5", # 12
"87.4startswithnumberbutshouldbestring", # 13
'555"I said"', # 14
'CUSTOM CHECK OK: foo is 12345', # 15
'-2', # 16
'-4', # 17
'-6.6', # 18
42 # 19
);
# undef increments are randomized
my @incrts = (undef, undef, undef, undef, undef, 1000, -500, 1000, 100000, undef, 666, undef, undef, undef, undef, undef, -1, undef, undef, 0 );
my @incrts = (
undef, # 0
undef, # 1
undef, # 2
undef, # 3
undef, # 4
1000, # 5
-500, # 6
1000, # 7
100000, # 8
undef, # 9
666, # 10
undef, # 11
undef, # 12
undef, # 13
undef, # 14
undef, # 15
-1, # 16
0, # 17
undef, # 18
0 # 19
);
# Number of elements in our OID
my $oidelts;

175
plugins/tests/test_check_snmp.c Normal file
View file

@ -0,0 +1,175 @@
/*****************************************************************************
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*
*****************************************************************************/
#include "tap.h"
#include "../../config.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "utils_base.c"
#include "../check_snmp.d/check_snmp_helpers.h"
char *_np_state_generate_key(int argc, char **argv);
char *_np_state_calculate_location_prefix(void);
int main(int argc, char **argv) {
char *temp_string = (char *)_np_state_generate_key(argc, argv);
ok(!strcmp(temp_string, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"),
"Got hash with exe and no parameters") ||
diag("You are probably running in wrong directory. Must run as ./test_utils");
int fake_argc = 4;
char *fake_argv[] = {
"./test_utils",
"here",
"--and",
"now",
};
temp_string = (char *)_np_state_generate_key(fake_argc, fake_argv);
ok(!strcmp(temp_string, "bd72da9f78ff1419fad921ea5e43ce56508aef6c"),
"Got based on expected argv");
unsetenv("MP_STATE_PATH");
temp_string = (char *)_np_state_calculate_location_prefix();
ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory");
setenv("MP_STATE_PATH", "", 1);
temp_string = (char *)_np_state_calculate_location_prefix();
ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory even with empty string");
setenv("MP_STATE_PATH", "/usr/local/nagios/var", 1);
temp_string = (char *)_np_state_calculate_location_prefix();
ok(!strcmp(temp_string, "/usr/local/nagios/var"), "Got default directory");
fake_argc = 1;
fake_argv[0] = "./test_utils";
state_key temp_state_key1 = np_enable_state(NULL, 51, "check_test", fake_argc, fake_argv);
ok(!strcmp(temp_state_key1.plugin_name, "check_test"), "Got plugin name");
ok(!strcmp(temp_state_key1.name, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"),
"Got generated filename");
state_key temp_state_key2 =
np_enable_state("allowedchars_in_keyname", 77, "check_snmp", fake_argc, fake_argv);
char state_path[1024];
sprintf(state_path, "/usr/local/nagios/var/%lu/check_test/allowedchars_in_keyname",
(unsigned long)geteuid());
ok(!strcmp(temp_state_key2.plugin_name, "check_test"), "Got plugin name");
ok(!strcmp(temp_state_key2.name, "allowedchars_in_keyname"), "Got key name with valid chars");
ok(!strcmp(temp_state_key2._filename, state_path), "Got internal filename");
/* Don't do this test just yet. Will die */
/*
np_enable_state("bad^chars$in@here", 77);
temp_state_key = this_monitoring_plugin->state;
ok( !strcmp(temp_state_key->name, "bad_chars_in_here"), "Got key name with bad chars replaced"
);
*/
state_key temp_state_key3 =
np_enable_state("funnykeyname", 54, "check_snmp", fake_argc, fake_argv);
sprintf(state_path, "/usr/local/nagios/var/%lu/check_test/funnykeyname",
(unsigned long)geteuid());
ok(!strcmp(temp_state_key3.plugin_name, "check_test"), "Got plugin name");
ok(!strcmp(temp_state_key3.name, "funnykeyname"), "Got key name");
ok(!strcmp(temp_state_key3._filename, state_path), "Got internal filename");
ok(temp_state_key3.data_version == 54, "Version set");
state_data *temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data == NULL, "Got no state data as file does not exist");
/*
temp_fp = fopen("var/statefile", "r");
if (temp_fp==NULL)
printf("Error opening. errno=%d\n", errno);
printf("temp_fp=%s\n", temp_fp);
ok( _np_state_read_file(temp_fp) == true, "Can read state file" );
fclose(temp_fp);
*/
temp_state_key3._filename = "var/statefile";
temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data != NULL, "Got state data now") ||
diag("Are you running in right directory? Will get coredump next if not");
ok(temp_state_data->time == 1234567890, "Got time");
ok(!strcmp((char *)temp_state_data->data, "String to read"), "Data as expected");
temp_state_key3.data_version = 53;
temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data == NULL, "Older data version gives NULL");
temp_state_key3.data_version = 54;
temp_state_key3._filename = "var/nonexistent";
temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data == NULL, "Missing file gives NULL");
temp_state_key3._filename = "var/oldformat";
temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data == NULL, "Old file format gives NULL");
temp_state_key3._filename = "var/baddate";
temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data == NULL, "Bad date gives NULL");
temp_state_key3._filename = "var/missingdataline";
temp_state_data = np_state_read(temp_state_key3);
ok(temp_state_data == NULL, "Missing data line gives NULL");
unlink("var/generated");
temp_state_key3._filename = "var/generated";
time_t current_time = 1234567890;
np_state_write_string(temp_state_key3, current_time, "String to read");
ok(system("cmp var/generated var/statefile") == 0, "Generated file same as expected");
unlink("var/generated_directory/statefile");
unlink("var/generated_directory");
temp_state_key3._filename = "var/generated_directory/statefile";
current_time = 1234567890;
np_state_write_string(temp_state_key3, current_time, "String to read");
ok(system("cmp var/generated_directory/statefile var/statefile") == 0,
"Have created directory");
/* This test to check cannot write to dir - can't automate yet */
/*
unlink("var/generated_bad_dir");
mkdir("var/generated_bad_dir", S_IRUSR);
np_state_write_string(current_time, "String to read");
*/
temp_state_key3._filename = "var/generated";
time(&current_time);
np_state_write_string(temp_state_key3, 0, "String to read");
temp_state_data = np_state_read(temp_state_key3);
/* Check time is set to current_time */
ok(system("cmp var/generated var/statefile > /dev/null") != 0,
"Generated file should be different this time");
ok(temp_state_data->time - current_time <= 1, "Has time generated from current time");
/* Don't know how to automatically test this. Need to be able to redefine die and catch the
* error */
/*
temp_state_key->_filename="/dev/do/not/expect/to/be/able/to/write";
np_state_write_string(0, "Bad file");
*/
np_cleanup();
}

6
plugins/tests/test_check_snmp.t Executable file
View file

@ -0,0 +1,6 @@
#!/usr/bin/perl
use Test::More;
if (! -e "./test_check_snmp") {
plan skip_all => "./test_check_snmp not compiled - please enable libtap library to test";
}
exec "./test_check_snmp";