upstream/monitoring-plugins
1
0
Fork 0
mirror of https://github.com/monitoring-plugins/monitoring-plugins.git synced 2026-04-21 22:29:49 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #2144 from RincewindsHat/refactor/check_snmp

Browse source 
Refactor check snmp:
 - Switch from executing `snmpget`/`snmpgetnext` to linking directly agains net-snmp
 - Refactor to use test abstraction -> allows for JSON output
This commit is contained in:
Lorenz Kästle 2025-09-09 01:57:25 +02:00 committed by GitHub
commit 615fec347c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
21 changed files with 2440 additions and 1767 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.github/monitoring-plugins.spec vendored
View file

@ -88,6 +88,9 @@ BuildRequires: postgresql-devel
# check_radius
BuildRequires: radcli-devel
# check_snmp
BuildRequires: net-snmp-devel
%description
Common files for Monitoring Plugins

3
.github/prepare_debian.sh vendored
View file

@ -24,6 +24,7 @@ apt-get -y install perl \
libpq-dev \
libradcli-dev \
libnet-snmp-perl \
libsnmp-dev \
procps \
libdbi0-dev \
libdbd-sqlite3 \
@ -111,6 +112,8 @@ mkdir -p /var/lib/snmp/mib_indexes
sed -e 's/^agentaddress.*/agentaddress 127.0.0.1/' -i /etc/snmp/snmpd.conf
service snmpd start
sed 's/^mibs ://' -i /etc/snmp/snmp.conf
# start cron, will be used by check_nagios
cron

17
.github/workflows/codeql-analysis.yml vendored
View file

@ -57,9 +57,20 @@ jobs:
run: |
sudo apt update
sudo apt-get install -y --no-install-recommends m4 gettext automake autoconf make build-essential
sudo apt-get install -y --no-install-recommends perl autotools-dev libdbi-dev libldap2-dev libpq-dev \
libmysqlclient-dev libradcli-dev libkrb5-dev libdbi0-dev \
libdbd-sqlite3 libssl-dev libcurl4-openssl-dev liburiparser-dev
sudo apt-get install -y --no-install-recommends perl \
autotools-dev \
libdbi-dev \
libldap2-dev \
libpq-dev \
libmysqlclient-dev \
libradcli-dev \
libkrb5-dev \
libdbi0-dev \
libdbd-sqlite3 \
libssl-dev \
libcurl4-openssl-dev \
liburiparser-dev \
libsnmp-dev
- name: Configure build
run: |

21
configure.ac
View file

@ -1470,17 +1470,6 @@ AC_ARG_WITH(snmpgetnext_command,
AS_IF([test -n "$PATH_TO_SNMPGET"], [
AC_DEFINE_UNQUOTED(PATH_TO_SNMPGET,"$PATH_TO_SNMPGET",[path to snmpget binary])
EXTRAS="$EXTRAS check_hpjd"
dnl PATH_TO_SNMPGETNEXT is used unconditionally in check_snmp:
dnl
dnl https://github.com/nagios-plugins/nagios-plugins/issues/788
dnl
AS_IF([test -n "$PATH_TO_SNMPGETNEXT"], [
AC_DEFINE_UNQUOTED(PATH_TO_SNMPGETNEXT,"$PATH_TO_SNMPGETNEXT",[path to snmpgetnext binary])
EXTRAS="$EXTRAS check_snmp\$(EXEEXT)"
], [
AC_MSG_WARN([Get snmpgetnext from https://net-snmp.sourceforge.io/ to build the check_snmp plugin])
])
], [
AC_MSG_WARN([Get snmpget from https://net-snmp.sourceforge.io/ to build the check_hpjd and check_snmp plugins])
])
@ -1493,6 +1482,16 @@ else
AC_MSG_WARN([Tried $PERL - install Net::SNMP perl module if you want to use the perl snmp plugins])
fi
dnl Check whether DES encryption is available (might not on RHEL)
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>]], [[oid *foo = usmDESPrivProtocol;]]
)],
[AC_DEFINE(HAVE_USM_DES_PRIV_PROTOCOL,1,Define whether we have DES Privacy Protocol)],
[]
)
AC_PATH_PROG(PATH_TO_QUAKESTAT,quakestat)
AC_PATH_PROG(PATH_TO_QSTAT,qstat)
AC_ARG_WITH(qstat_command,

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

72
lib/perfdata.c
View file

@ -33,7 +33,18 @@ char *pd_value_to_string(const mp_perfdata_value pd) {
char *pd_to_string(mp_perfdata pd) {
assert(pd.label != NULL);
char *result = NULL;
asprintf(&result, "'%s'=", pd.label);
if (strchr(pd.label, '\'') == NULL) {
asprintf(&result, "'%s'=", pd.label);
} else {
// we have a illegal single quote in the string
// replace it silently instead of complaining
for (char *ptr = pd.label; *ptr == '\0'; ptr++) {
if (*ptr == '\'') {
*ptr = '_';
}
}
}
asprintf(&result, "%s%s", result, pd_value_to_string(pd.value));
@ -249,7 +260,9 @@ char *mp_range_to_string(const mp_range input) {
return result;
}
mp_perfdata mp_set_pd_value_float(mp_perfdata pd, float value) { return mp_set_pd_value_double(pd, value); }
mp_perfdata mp_set_pd_value_float(mp_perfdata pd, float value) {
return mp_set_pd_value_double(pd, value);
}
mp_perfdata mp_set_pd_value_double(mp_perfdata pd, double value) {
pd.value.pd_double = value;
@ -257,15 +270,25 @@ mp_perfdata mp_set_pd_value_double(mp_perfdata pd, double value) {
return pd;
}
mp_perfdata mp_set_pd_value_char(mp_perfdata pd, char value) { return mp_set_pd_value_long_long(pd, (long long)value); }
mp_perfdata mp_set_pd_value_char(mp_perfdata pd, char value) {
return mp_set_pd_value_long_long(pd, (long long)value);
}
mp_perfdata mp_set_pd_value_u_char(mp_perfdata pd, unsigned char value) { return mp_set_pd_value_u_long_long(pd, (unsigned long long)value); }
mp_perfdata mp_set_pd_value_u_char(mp_perfdata pd, unsigned char value) {
return mp_set_pd_value_u_long_long(pd, (unsigned long long)value);
}
mp_perfdata mp_set_pd_value_int(mp_perfdata pd, int value) { return mp_set_pd_value_long_long(pd, (long long)value); }
mp_perfdata mp_set_pd_value_int(mp_perfdata pd, int value) {
return mp_set_pd_value_long_long(pd, (long long)value);
}
mp_perfdata mp_set_pd_value_u_int(mp_perfdata pd, unsigned int value) { return mp_set_pd_value_u_long_long(pd, (unsigned long long)value); }
mp_perfdata mp_set_pd_value_u_int(mp_perfdata pd, unsigned int value) {
return mp_set_pd_value_u_long_long(pd, (unsigned long long)value);
}
mp_perfdata mp_set_pd_value_long(mp_perfdata pd, long value) { return mp_set_pd_value_long_long(pd, (long long)value); }
mp_perfdata mp_set_pd_value_long(mp_perfdata pd, long value) {
return mp_set_pd_value_long_long(pd, (long long)value);
}
mp_perfdata mp_set_pd_value_u_long(mp_perfdata pd, unsigned long value) {
return mp_set_pd_value_u_long_long(pd, (unsigned long long)value);
@ -290,19 +313,33 @@ mp_perfdata_value mp_create_pd_value_double(double value) {
return res;
}
mp_perfdata_value mp_create_pd_value_float(float value) { return mp_create_pd_value_double((double)value); }
mp_perfdata_value mp_create_pd_value_float(float value) {
return mp_create_pd_value_double((double)value);
}
mp_perfdata_value mp_create_pd_value_char(char value) { return mp_create_pd_value_long_long((long long)value); }
mp_perfdata_value mp_create_pd_value_char(char value) {
return mp_create_pd_value_long_long((long long)value);
}
mp_perfdata_value mp_create_pd_value_u_char(unsigned char value) { return mp_create_pd_value_u_long_long((unsigned long long)value); }
mp_perfdata_value mp_create_pd_value_u_char(unsigned char value) {
return mp_create_pd_value_u_long_long((unsigned long long)value);
}
mp_perfdata_value mp_create_pd_value_int(int value) { return mp_create_pd_value_long_long((long long)value); }
mp_perfdata_value mp_create_pd_value_int(int value) {
return mp_create_pd_value_long_long((long long)value);
}
mp_perfdata_value mp_create_pd_value_u_int(unsigned int value) { return mp_create_pd_value_u_long_long((unsigned long long)value); }
mp_perfdata_value mp_create_pd_value_u_int(unsigned int value) {
return mp_create_pd_value_u_long_long((unsigned long long)value);
}
mp_perfdata_value mp_create_pd_value_long(long value) { return mp_create_pd_value_long_long((long long)value); }
mp_perfdata_value mp_create_pd_value_long(long value) {
return mp_create_pd_value_long_long((long long)value);
}
mp_perfdata_value mp_create_pd_value_u_long(unsigned long value) { return mp_create_pd_value_u_long_long((unsigned long long)value); }
mp_perfdata_value mp_create_pd_value_u_long(unsigned long value) {
return mp_create_pd_value_u_long_long((unsigned long long)value);
}
mp_perfdata_value mp_create_pd_value_long_long(long long value) {
mp_perfdata_value res = {0};
@ -368,6 +405,13 @@ mp_range_parsed mp_parse_range_string(const char *input) {
}
char *working_copy = strdup(input);
if (working_copy == NULL) {
// strdup error, probably
mp_range_parsed result = {
.error = MP_RANGE_PARSING_FAILURE,
};
return result;
}
input = working_copy;
char *separator = index(working_copy, ':');

2
lib/perfdata.h
View file

@ -45,7 +45,7 @@ typedef struct range_struct {
double start;
bool start_infinity;
double end;
int end_infinity;
bool end_infinity;
int alert_on; /* OUTSIDE (default) or INSIDE */
char *text; /* original unparsed text input */
} range;

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);

438
lib/utils_base.c
View file

@ -33,12 +33,12 @@
#include <unistd.h>
#include <sys/types.h>
#define np_free(ptr) \
{ \
if (ptr) { \
free(ptr); \
ptr = NULL; \
} \
#define np_free(ptr) \
{ \
if (ptr) { \
free(ptr); \
ptr = NULL; \
} \
}
monitoring_plugin *this_monitoring_plugin = NULL;
@ -46,7 +46,7 @@ monitoring_plugin *this_monitoring_plugin = NULL;
int timeout_state = STATE_CRITICAL;
unsigned int timeout_interval = DEFAULT_SOCKET_TIMEOUT;
bool _np_state_read_file(FILE *);
bool _np_state_read_file(FILE *state_file);
void np_init(char *plugin_name, int argc, char **argv) {
if (this_monitoring_plugin == NULL) {
@ -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);
}
@ -153,7 +145,8 @@ range *parse_range_string(char *str) {
set_range_end(temp_range, end);
}
if (temp_range->start_infinity == true || temp_range->end_infinity == true || temp_range->start <= temp_range->end) {
if (temp_range->start_infinity || temp_range->end_infinity ||
temp_range->start <= temp_range->end) {
return temp_range;
}
free(temp_range);
@ -205,12 +198,14 @@ void print_thresholds(const char *threshold_name, thresholds *my_threshold) {
printf("Threshold not set");
} else {
if (my_threshold->warning) {
printf("Warning: start=%g end=%g; ", my_threshold->warning->start, my_threshold->warning->end);
printf("Warning: start=%g end=%g; ", my_threshold->warning->start,
my_threshold->warning->end);
} else {
printf("Warning not set; ");
}
if (my_threshold->critical) {
printf("Critical: start=%g end=%g", my_threshold->critical->start, my_threshold->critical->end);
printf("Critical: start=%g end=%g", my_threshold->critical->start,
my_threshold->critical->end);
} else {
printf("Critical not set");
}
@ -222,15 +217,16 @@ void print_thresholds(const char *threshold_name, thresholds *my_threshold) {
bool mp_check_range(const mp_perfdata_value value, const mp_range my_range) {
bool is_inside = false;
if (my_range.end_infinity == false && my_range.start_infinity == false) {
if (!my_range.end_infinity && !my_range.start_infinity) {
// range: .........|---inside---|...........
// value
is_inside = ((cmp_perfdata_value(my_range.start, value) < 1) && (cmp_perfdata_value(value, my_range.end) <= 0));
} else if (my_range.start_infinity == false && my_range.end_infinity == true) {
is_inside = ((cmp_perfdata_value(value, my_range.start) >= 0) &&
(cmp_perfdata_value(value, my_range.end) <= 0));
} else if (!my_range.start_infinity && my_range.end_infinity) {
// range: .........|---inside---------
// value
is_inside = (cmp_perfdata_value(my_range.start, value) < 0);
} else if (my_range.start_infinity == true && my_range.end_infinity == false) {
is_inside = (cmp_perfdata_value(value, my_range.start) >= 0);
} else if (my_range.start_infinity && !my_range.end_infinity) {
// range: -inside--------|....................
// value
is_inside = (cmp_perfdata_value(value, my_range.end) == -1);
@ -239,7 +235,8 @@ bool mp_check_range(const mp_perfdata_value value, const mp_range my_range) {
is_inside = true;
}
if ((is_inside && my_range.alert_on_inside_range == INSIDE) || (!is_inside && my_range.alert_on_inside_range == OUTSIDE)) {
if ((is_inside && my_range.alert_on_inside_range == INSIDE) ||
(!is_inside && my_range.alert_on_inside_range == OUTSIDE)) {
return true;
}
@ -256,21 +253,21 @@ bool check_range(double value, range *my_range) {
yes = false;
}
if (my_range->end_infinity == false && my_range->start_infinity == false) {
if (!my_range->end_infinity && !my_range->start_infinity) {
if ((my_range->start <= value) && (value <= my_range->end)) {
return no;
}
return yes;
}
if (my_range->start_infinity == false && my_range->end_infinity == true) {
if (!my_range->start_infinity && my_range->end_infinity) {
if (my_range->start <= value) {
return no;
}
return yes;
}
if (my_range->start_infinity == true && my_range->end_infinity == false) {
if (my_range->start_infinity && !my_range->end_infinity) {
if (value <= my_range->end) {
return no;
}
@ -282,12 +279,12 @@ bool check_range(double value, range *my_range) {
/* Returns status */
int get_status(double value, thresholds *my_thresholds) {
if (my_thresholds->critical != NULL) {
if (check_range(value, my_thresholds->critical) == true) {
if (check_range(value, my_thresholds->critical)) {
return STATE_CRITICAL;
}
}
if (my_thresholds->warning != NULL) {
if (check_range(value, my_thresholds->warning) == true) {
if (check_range(value, my_thresholds->warning)) {
return STATE_WARNING;
}
}
@ -296,32 +293,31 @@ int get_status(double value, thresholds *my_thresholds) {
char *np_escaped_string(const char *string) {
char *data;
int i;
int j = 0;
int write_index = 0;
data = strdup(string);
for (i = 0; data[i]; i++) {
for (int i = 0; data[i]; i++) {
if (data[i] == '\\') {
switch (data[++i]) {
case 'n':
data[j++] = '\n';
data[write_index++] = '\n';
break;
case 'r':
data[j++] = '\r';
data[write_index++] = '\r';
break;
case 't':
data[j++] = '\t';
data[write_index++] = '\t';
break;
case '\\':
data[j++] = '\\';
data[write_index++] = '\\';
break;
default:
data[j++] = data[i];
data[write_index++] = data[i];
}
} else {
data[j++] = data[i];
data[write_index++] = data[i];
}
}
data[j] = '\0';
data[write_index] = '\0';
return data;
}
@ -336,33 +332,35 @@ int np_check_if_root(void) { return (geteuid() == 0); }
char *np_extract_value(const char *varlist, const char *name, char sep) {
char *tmp = NULL;
char *value = NULL;
int i;
while (1) {
while (true) {
/* Strip any leading space */
for (; isspace(varlist[0]); varlist++)
for (; isspace(varlist[0]); varlist++) {
;
}
if (strncmp(name, varlist, strlen(name)) == 0) {
varlist += strlen(name);
/* strip trailing spaces */
for (; isspace(varlist[0]); varlist++)
for (; isspace(varlist[0]); varlist++) {
;
}
if (varlist[0] == '=') {
/* We matched the key, go past the = sign */
varlist++;
/* strip leading spaces */
for (; isspace(varlist[0]); varlist++)
for (; isspace(varlist[0]); varlist++) {
;
}
if ((tmp = index(varlist, sep))) {
/* Value is delimited by a comma */
if (tmp - varlist == 0) {
continue;
}
value = (char *)calloc(1, tmp - varlist + 1);
strncpy(value, varlist, tmp - varlist);
value = (char *)calloc(1, (unsigned long)(tmp - varlist + 1));
strncpy(value, varlist, (unsigned long)(tmp - varlist));
value[tmp - varlist] = '\0';
} else {
/* Value is delimited by a \0 */
@ -387,7 +385,7 @@ char *np_extract_value(const char *varlist, const char *name, char sep) {
/* Clean-up trailing spaces/newlines */
if (value) {
for (i = strlen(value) - 1; isspace(value[i]); i--) {
for (unsigned long i = strlen(value) - 1; isspace(value[i]); i--) {
value[i] = '\0';
}
}
@ -429,349 +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) {
int i;
char **argv = this_monitoring_plugin->argv;
char keyname[41];
char *p = NULL;
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 (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 (i = 0; i < this_monitoring_plugin->argc; i++) {
sha256_process_bytes(argv[i], strlen(argv[i]), &ctx);
}
sha256_finish_ctx(&ctx, result);
#endif // FOUNDOPENSSL
for (i = 0; i < 20; ++i) {
sprintf(&keyname[2 * i], "%02x", result[i]);
}
keyname[40] = '\0';
p = strdup(keyname);
if (p == NULL) {
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
}
return p;
}
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) {
state_key *this_state = NULL;
char *temp_filename = NULL;
char *temp_keyname = NULL;
char *p = NULL;
int ret;
if (this_monitoring_plugin == NULL) {
die(STATE_UNKNOWN, _("This requires np_init to be called"));
}
this_state = (state_key *)calloc(1, sizeof(state_key));
if (this_state == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
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 */
p = temp_keyname;
while (*p != '\0') {
if (!(isalnum(*p) || *p == '_')) {
die(STATE_UNKNOWN, _("Invalid character for keyname - only alphanumerics or '_'"));
}
p++;
}
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 */
ret = asprintf(&temp_filename, "%s/%lu/%s/%s", _np_state_calculate_location_prefix(), (unsigned long)geteuid(),
this_monitoring_plugin->plugin_name, this_state->name);
if (ret < 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) {
state_data *this_state_data = NULL;
FILE *statefile;
bool rc = false;
if (this_monitoring_plugin == NULL) {
die(STATE_UNKNOWN, _("This requires np_init to be called"));
}
/* Open file. If this fails, no previous state found */
statefile = fopen(this_monitoring_plugin->state->_filename, "r");
if (statefile != NULL) {
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;
rc = _np_state_read_file(statefile);
fclose(statefile);
}
if (!rc) {
_cleanup_state_data();
}
return this_monitoring_plugin->state->state_data;
}
/*
* Read the state file
*/
bool _np_state_read_file(FILE *f) {
bool status = false;
size_t pos;
char *line;
int i;
int failure = 0;
time_t current_time, data_time;
enum {
STATE_FILE_VERSION,
STATE_DATA_VERSION,
STATE_DATA_TIME,
STATE_DATA_TEXT,
STATE_DATA_END
} expected = STATE_FILE_VERSION;
time(&current_time);
/* Note: This introduces a limit of 1024 bytes in the string data */
line = (char *)calloc(1, 1024);
if (line == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
while (!failure && (fgets(line, 1024, f)) != NULL) {
pos = strlen(line);
if (line[pos - 1] == '\n') {
line[pos - 1] = '\0';
}
if (line[0] == '#') {
continue;
}
switch (expected) {
case STATE_FILE_VERSION:
i = atoi(line);
if (i != NP_STATE_FORMAT_VERSION) {
failure++;
} else {
expected = STATE_DATA_VERSION;
}
break;
case STATE_DATA_VERSION:
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 */
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) {
FILE *fp;
char *temp_file = NULL;
int fd = 0, result = 0;
time_t current_time;
char *directories = NULL;
char *p = NULL;
if (data_time == 0) {
time(&current_time);
} else {
current_time = data_time;
}
/* If file doesn't currently exist, create directories */
if (access(this_monitoring_plugin->state->_filename, F_OK) != 0) {
result = asprintf(&directories, "%s", this_monitoring_plugin->state->_filename);
if (result < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
for (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);
}
result = asprintf(&temp_file, "%s.XXXXXX", this_monitoring_plugin->state->_filename);
if (result < 0) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"), strerror(errno));
}
if ((fd = mkstemp(temp_file)) == -1) {
np_free(temp_file);
die(STATE_UNKNOWN, _("Cannot create temporary filename"));
}
fp = (FILE *)fdopen(fd, "w");
if (fp == NULL) {
close(fd);
unlink(temp_file);
np_free(temp_file);
die(STATE_UNKNOWN, _("Unable to open temporary state file"));
}
fprintf(fp, "# NP State file\n");
fprintf(fp, "%d\n", NP_STATE_FORMAT_VERSION);
fprintf(fp, "%d\n", this_monitoring_plugin->state->data_version);
fprintf(fp, "%lu\n", current_time);
fprintf(fp, "%s\n", data_string);
fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP);
fflush(fp);
result = fclose(fp);
fsync(fd);
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);

23
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
@ -30,22 +36,25 @@ libexec_PROGRAMS = check_apt check_cluster check_disk check_dummy check_http che
check_mrtg check_mrtgtraf check_ntp check_ntp_peer check_ping \
check_real check_smtp check_ssh check_tcp check_time check_ntp_time \
check_ups check_users negate \
urlize @EXTRAS@
urlize @EXTRAS@ \
check_snmp
check_tcp_programs = check_ftp check_imap check_nntp check_pop \
check_udp check_clamd @check_tcp_ssl@
EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \
EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_hpjd \
check_swap check_fping check_ldap check_game check_dig \
check_nagios check_by_ssh check_dns check_nt check_ide_smart \
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 \
@ -78,6 +87,7 @@ EXTRA_DIST = t \
check_ping.d \
check_by_ssh.d \
check_smtp.d \
check_snmp.d \
check_mysql.d \
check_ntp_time.d \
check_dig.d \
@ -151,7 +161,10 @@ check_ping_LDADD = $(NETLIBS)
check_procs_LDADD = $(BASEOBJS)
check_radius_LDADD = $(NETLIBS) $(RADIUSLIBS)
check_real_LDADD = $(NETLIBS)
check_snmp_SOURCES = check_snmp.c check_snmp.d/check_snmp_helpers.c
check_snmp_LDADD = $(BASEOBJS)
check_snmp_LDFLAGS = $(AM_LDFLAGS) `net-snmp-config --libs`
check_snmp_CFLAGS = $(AM_CFLAGS) `net-snmp-config --cflags`
check_smtp_LDADD = $(SSLOBJS)
check_ssh_LDADD = $(NETLIBS)
check_swap_SOURCES = check_swap.c check_swap.d/swap.c
@ -173,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

1805
plugins/check_snmp.c
View file

File diff suppressed because it is too large Load diff

934
plugins/check_snmp.d/check_snmp_helpers.c Normal file
View file

@ -0,0 +1,934 @@
#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 = {
.threshold = mp_thresholds_init(),
};
return tmp;
}
int check_snmp_set_thresholds(const char *threshold_string, check_snmp_test_unit test_units[],
size_t max_test_units, bool is_critical) {
if (threshold_string == NULL || strlen(threshold_string) == 0) {
// No input, do nothing
return 0;
}
if (strchr(threshold_string, ',') != NULL) {
// Got a comma in the string, should be multiple values
size_t tu_index = 0;
while (threshold_string[0] == ',') {
// got commas at the beginning, so skip some values
tu_index++;
threshold_string++;
}
for (char *ptr = strtok(threshold_string, ", "); ptr != NULL;
ptr = strtok(NULL, ", "), tu_index++) {
if (tu_index > max_test_units) {
// More thresholds then values, just ignore them
return 0;
}
// edge case: maybe we got `,,` to skip a value
if (strlen(ptr) == 0) {
// no threshold given, do not set it then
continue;
}
mp_range_parsed tmp = mp_parse_range_string(ptr);
if (tmp.error != MP_PARSING_SUCCES) {
die(STATE_UNKNOWN, "Unable to parse critical threshold range: %s", ptr);
}
if (is_critical) {
test_units[tu_index].threshold.critical = tmp.range;
test_units[tu_index].threshold.critical_is_set = true;
} else {
test_units[tu_index].threshold.warning = tmp.range;
test_units[tu_index].threshold.warning_is_set = true;
}
}
} else {
// Single value
// only valid for the first test unit
mp_range_parsed tmp = mp_parse_range_string(threshold_string);
if (tmp.error != MP_PARSING_SUCCES) {
die(STATE_UNKNOWN, "Unable to parse critical threshold range: %s", threshold_string);
}
if (is_critical) {
test_units[0].threshold.critical = tmp.range;
test_units[0].threshold.critical_is_set = true;
} else {
test_units[0].threshold.warning = tmp.range;
test_units[0].threshold.warning_is_set = true;
}
}
return 0;
}
const int DEFAULT_PROTOCOL = SNMP_VERSION_1;
const char DEFAULT_OUTPUT_DELIMITER[] = " ";
const int RANDOM_STATE_DATA_LENGTH_PREDICTION = 8192;
check_snmp_config check_snmp_config_init() {
check_snmp_config tmp = {
.snmp_params =
{
.use_getnext = false,
.ignore_mib_parsing_errors = false,
.need_mibs = false,
.test_units = NULL,
.num_of_test_units = 0,
},
.evaluation_params =
{
.nulloid_result = STATE_UNKNOWN, // state to return if no result for query
.invert_search = true,
.regex_cmp_value = {},
.string_cmp_value = "",
.multiplier = 1.0,
.multiplier_set = false,
.offset = 0,
.offset_set = false,
.use_oid_as_perf_data_label = false,
.calculate_rate = false,
.rate_multiplier = 1,
},
};
snmp_sess_init(&tmp.snmp_params.snmp_session);
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?
break;
default:
if (verbose) {
printf("Debug: Got a unmatched result type: %hhu\n", vars->type);
}
// TODO: Error here?
break;
}
}
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
break;
}
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;
}

71
plugins/check_snmp.d/check_snmp_helpers.h Normal file
View file

@ -0,0 +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);

81
plugins/check_snmp.d/config.h Normal file
View file

@ -0,0 +1,81 @@
#pragma once
#include "../../lib/thresholds.h"
#include "../../lib/states.h"
#include <stdlib.h>
#include <stdbool.h>
#include <regex.h>
#include "../common.h"
// defines for snmp libs
#define u_char unsigned char
#define u_long unsigned long
#define u_short unsigned short
#define u_int unsigned int
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/library/snmp.h>
#include <net-snmp/session_api.h>
#define DEFAULT_PORT "161"
#define DEFAULT_RETRIES 5
typedef struct eval_method {
bool crit_string;
bool crit_regex;
} eval_method;
typedef struct check_snmp_test_unit {
char *oid;
char *label;
char *unit_value;
eval_method eval_mthd;
mp_thresholds threshold;
} check_snmp_test_unit;
typedef struct {
struct snmp_session snmp_session;
// use getnet instead of get
bool use_getnext;
// TODO actually make these useful
bool ignore_mib_parsing_errors;
bool need_mibs;
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;
// String evaluation stuff
bool invert_search;
regex_t regex_cmp_value; // regex to match query results against
char string_cmp_value[MAX_INPUT_BUFFER];
// Modify data
double multiplier;
bool multiplier_set;
double offset;
bool offset_set;
// Modify output
bool use_oid_as_perf_data_label;
// activate rate calculation
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;
} check_snmp_config;

103
plugins/t/check_snmp.t
View file

@ -10,7 +10,7 @@ use NPTest;
BEGIN {
plan skip_all => 'check_snmp is not compiled' unless -x "./check_snmp";
plan tests => 63;
plan tests => 62;
}
my $res;
@ -24,7 +24,7 @@ my $user_snmp = getTestParameter("NP_SNMP_USER", "An SNMP user", "auth_
$res = NPTest->testCmd( "./check_snmp -t 1" );
is( $res->return_code, 3, "No host name" );
is( $res->output, "No host specified" );
is( $res->output, "No OIDs specified" );
$res = NPTest->testCmd( "./check_snmp -H fakehostname --ignore-mib-parsing-errors" );
is( $res->return_code, 3, "No OIDs specified" );
@ -32,145 +32,124 @@ is( $res->output, "No OIDs specified" );
$res = NPTest->testCmd( "./check_snmp -H fakehost --ignore-mib-parsing-errors -o oids -P 3 -U not_a_user --seclevel=rubbish" );
is( $res->return_code, 3, "Invalid seclevel" );
like( $res->output, "/check_snmp: Invalid seclevel - rubbish/" );
like( $res->output, "/invalid security level: rubbish/" );
$res = NPTest->testCmd( "./check_snmp -H fakehost --ignore-mib-parsing-errors -o oids -P 3c" );
is( $res->return_code, 3, "Invalid protocol" );
like( $res->output, "/check_snmp: Invalid SNMP version - 3c/" );
like( $res->output, "/invalid SNMP version/protocol: 3c/" );
SKIP: {
skip "no snmp host defined", 50 if ( ! $host_snmp );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -w 1: -c 1:");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -P 2c -C $snmp_community -o system.sysUpTime.0 -w 1: -c 1:");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying uptime" );
like($res->output, '/^SNMP OK - (\d+)/', "String contains SNMP OK");
$res->output =~ /^SNMP OK - (\d+)/;
$res->output =~ /\|.*=(\d+);/;
my $value = $1;
cmp_ok( $value, ">", 0, "Got a time value" );
like($res->perf_output, "/sysUpTime.*$1/", "Got perfdata with value '$1' in it");
# some more threshold tests
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1 -P 2c");
cmp_ok( $res->return_code, '==', 2, "Threshold test -c 1" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1:");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1: -P 2c");
cmp_ok( $res->return_code, '==', 0, "Threshold test -c 1:" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c ~:1");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c ~:1 -P 2c");
cmp_ok( $res->return_code, '==', 2, "Threshold test -c ~:1" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1:10");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1:10 -P 2c");
cmp_ok( $res->return_code, '==', 2, "Threshold test -c 1:10" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c \@1:10");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c \@1:10 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Threshold test -c \@1:10" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 10:1");
cmp_ok( $res->return_code, '==', 0, "Threshold test -c 10:1" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o .1.3.6.1.2.1.1.3.0 -w 1: -c 1:");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o .1.3.6.1.2.1.1.3.0 -w 1: -c 1: -P 2c");
cmp_ok( $res->return_code, '==', 0, "Test with numeric OID (no mibs loaded)" );
like($res->output, '/^SNMP OK - \d+/', "String contains SNMP OK");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysDescr.0");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysDescr.0 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying sysDescr" );
unlike($res->perf_output, '/sysDescr/', "Perfdata doesn't contain string values");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysDescr.0,system.sysDescr.0");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysDescr.0,system.sysDescr.0 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying two string OIDs, comma-separated" );
like($res->output, '/^SNMP OK - /', "String contains SNMP OK");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysDescr.0 -o system.sysDescr.0");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysDescr.0 -o system.sysDescr.0 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying two string OIDs, repeated option" );
like($res->output, '/^SNMP OK - /', "String contains SNMP OK");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w 1:1 -c 1:1");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w 1:1 -c 1:1 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying hrSWRunIndex.1" );
like($res->output, '/^SNMP OK - 1\s.*$/', "String fits SNMP OK and output format");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w 0 -c 1:");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w 0 -c 1: -P 2c");
cmp_ok( $res->return_code, '==', 1, "Exit WARNING when querying hrSWRunIndex.1 and warn-th doesn't apply " );
like($res->output, '/^SNMP WARNING - \*1\*\s.*$/', "String matches SNMP WARNING and output format");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w :0 -c 0");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w :0 -c 0 -P 2c");
cmp_ok( $res->return_code, '==', 2, "Exit CRITICAL when querying hrSWRunIndex.1 and crit-th doesn't apply" );
like($res->output, '/^SNMP CRITICAL - \*1\*\s.*$/', "String matches SNMP CRITICAL and output format");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o ifIndex.2,ifIndex.1 -w 1:2 -c 1:2");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o ifIndex.2,ifIndex.1 -w 1:2 -c 1:2 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Checking two OIDs at once" );
like($res->output, "/^SNMP OK - 2 1/", "Got two values back" );
like( $res->perf_output, "/ifIndex.2=2/", "Got 1st perf data" );
like( $res->perf_output, "/ifIndex.1=1/", "Got 2nd perf data" );
like( $res->perf_output, "/ifIndex.2'?=2/", "Got 1st perf data" );
like( $res->perf_output, "/ifIndex.1'?=1/", "Got 2nd perf data" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o ifIndex.2,ifIndex.1 -w 1:2,1:2 -c 2:2,2:2");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o ifIndex.2,ifIndex.1 -w 1:2,1:2 -c 2:2,2:2 -P 2c");
cmp_ok( $res->return_code, '==', 2, "Checking critical threshold is passed if any one value crosses" );
like($res->output, "/^SNMP CRITICAL - 2 *1*/", "Got two values back" );
like( $res->perf_output, "/ifIndex.2=2/", "Got 1st perf data" );
like( $res->perf_output, "/ifIndex.1=1/", "Got 2nd perf data" );
like( $res->perf_output, "/ifIndex.2'?=2/", "Got 1st perf data" );
like( $res->perf_output, "/ifIndex.1'?=1/", "Got 2nd perf data" );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrStorage.hrMemorySize.0,host.hrSystem.hrSystemProcesses.0 -w 1:,1: -c 1:,1:");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrStorage.hrMemorySize.0,host.hrSystem.hrSystemProcesses.0 -w 1:,1: -c 1:,1: -P 2c");
cmp_ok( $res->return_code, '==', 0, "Exit OK when querying hrMemorySize and hrSystemProcesses");
like($res->output, '/^SNMP OK - \d+ \d+/', "String contains hrMemorySize and hrSystemProcesses");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w \@:0 -c \@0");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w \@:0 -c \@0 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Exit OK with inside-range thresholds");
like($res->output, '/^SNMP OK - 1\s.*$/', "String matches SNMP OK and output format");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o enterprises.ucdavis.laTable.laEntry.laLoad.3");
$res->output =~ m/^SNMP OK - (\d+\.\d{2})\s.*$/;
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o enterprises.ucdavis.laTable.laEntry.laLoadInt.3 -P 2c");
$res->output =~ m/^.*Value: (\d+).*$/;
my $lower = $1 - 0.05;
my $higher = $1 + 0.05;
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o enterprises.ucdavis.laTable.laEntry.laLoad.3 -w $lower -c $higher");
cmp_ok( $res->return_code, '==', 1, "Exit WARNING with fractionnal arguments");
# $res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o enterprises.ucdavis.laTable.laEntry.laLoadInt.3 -w $lower -c $higher -P 2c");
# cmp_ok( $res->return_code, '==', 1, "Exit WARNING with fractional arguments");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0,host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w ,:0 -c ,:2");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0,host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w ,:0 -c ,:2 -P 2c");
cmp_ok( $res->return_code, '==', 1, "Exit WARNING on 2nd threshold");
like($res->output, '/^SNMP WARNING - Timeticks:\s\(\d+\)\s+(?:\d+ days?,\s+)?\d+:\d+:\d+\.\d+\s+\*1\*\s.*$/', "First OID returned as string, 2nd checked for thresholds");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w '' -c ''");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w '' -c '' -P 2c");
cmp_ok( $res->return_code, '==', 0, "Empty thresholds doesn't crash");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrStorage.hrMemorySize.0,host.hrSystem.hrSystemProcesses.0 -w ,,1 -c ,,2");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrStorage.hrMemorySize.0,host.hrSystem.hrSystemProcesses.0 -w ,,1 -c ,,2 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Skipping first two thresholds on 2 OID check");
like($res->output, '/^SNMP OK - \d+ \w+ \d+\s.*$/', "Skipping first two thresholds, result printed rather than parsed");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrStorage.hrMemorySize.0,host.hrSystem.hrSystemProcesses.0 -w ,, -c ,,");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o host.hrStorage.hrMemorySize.0,host.hrSystem.hrSystemProcesses.0 -w ,, -c ,, -P 2c");
cmp_ok( $res->return_code, '==', 0, "Skipping all thresholds");
like($res->output, '/^SNMP OK - \d+ \w+ \d+\s.*$/', "Skipping all thresholds, result printed rather than parsed");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1000000000000: -u '1/100 sec'");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -c 1000000000000: -u '1/100 sec' -P 2c");
cmp_ok( $res->return_code, '==', 2, "Timetick used as a threshold");
like($res->output, '/^SNMP CRITICAL - \*\d+\* 1\/100 sec.*$/', "Timetick used as a threshold, parsed as numeric");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o system.sysUpTime.0 -P 2c");
cmp_ok( $res->return_code, '==', 0, "Timetick used as a string");
like($res->output, '/^SNMP OK - Timeticks:\s\(\d+\)\s+(?:\d+ days?,\s+)?\d+:\d+:\d+\.\d+\s.*$/', "Timetick used as a string, result printed rather than parsed");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o HOST-RESOURCES-MIB::hrSWRunName.1");
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -C $snmp_community -o HOST-RESOURCES-MIB::hrSWRunName.1 -P 2c");
cmp_ok( $res->return_code, '==', 0, "snmp response without datatype");
like( $res->output, '/^SNMP OK - "(systemd|init)" \| $/', "snmp response without datatype" );
}
SKIP: {
skip "no SNMP user defined", 1 if ( ! $user_snmp );
$res = NPTest->testCmd( "./check_snmp -H $host_snmp --ignore-mib-parsing-errors -o HOST-RESOURCES-MIB::hrSystemUptime.0 -P 3 -U $user_snmp -L noAuthNoPriv");
like( $res->output, '/^SNMP OK - Timeticks:\s\(\d+\)\s+(?:\d+ days?,\s+)?\d+:\d+:\d+\.\d+\s.*$/', "noAuthNoPriv security level works properly" );
}
# These checks need a complete command line. An invalid community is used so
# the tests can run on hosts w/o snmp host/community in NPTest.cache. Execution will fail anyway
SKIP: {
skip "no non responsive host defined", 2 if ( ! $host_nonresponsive );
$res = NPTest->testCmd( "./check_snmp -H $host_nonresponsive --ignore-mib-parsing-errors -C np_foobar -o system.sysUpTime.0 -w 1: -c 1:");
$res = NPTest->testCmd( "./check_snmp -H $host_nonresponsive --ignore-mib-parsing-errors -C np_foobar -o system.sysUpTime.0 -w 1: -c 1: -P 2c");
cmp_ok( $res->return_code, '==', 2, "Exit CRITICAL with non responsive host" );
like($res->output, '/Plugin timed out while executing system call/', "String matches timeout problem");
# like($res->output, '/Plugin timed out while executing system call/', "String matches timeout problem");
}
SKIP: {
skip "no non invalid host defined", 2 if ( ! $hostname_invalid );
$res = NPTest->testCmd( "./check_snmp -H $hostname_invalid --ignore-mib-parsing-errors -C np_foobar -o system.sysUpTime.0 -w 1: -c 1:");
$res = NPTest->testCmd( "./check_snmp -H $hostname_invalid --ignore-mib-parsing-errors -C np_foobar -o system.sysUpTime.0 -w 1: -c 1: -P 2c");
cmp_ok( $res->return_code, '==', 3, "Exit UNKNOWN with non responsive host" );
like($res->output, '/External command error: .*(nosuchhost|Name or service not known|Unknown host).*/s', "String matches invalid host");
like($res->output, '/.*Unknown host.*/s', "String matches invalid host");
}

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;

2
plugins/tests/conf/snmpd.conf
View file

@ -19,5 +19,5 @@ syscontact Alice
# Embedded Subagents
###############################################################################
perl do "tests/check_snmp_agent.pl";
perl do "./tests/check_snmp_agent.pl";

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";