debian/pkg-monitoring-plugins
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

New upstream version 2.3.4

Browse source
This commit is contained in:
Jan Wagner 2023-10-18 07:29:37 +00:00
parent 7c86d65dc2
commit 30f882762f
556 changed files with 90432 additions and 53391 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lib/Makefile.am
View file

@ -7,7 +7,7 @@ noinst_LIBRARIES = libmonitoringplug.a
AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\" \
-I$(srcdir) -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins
libmonitoringplug_a_SOURCES = utils_base.c utils_disk.c utils_tcp.c utils_cmd.c
libmonitoringplug_a_SOURCES = utils_base.c utils_disk.c utils_tcp.c utils_cmd.c maxfd.c
EXTRA_DIST = utils_base.h utils_disk.h utils_tcp.h utils_cmd.h parse_ini.h extra_opts.h
if USE_PARSE_INI

1122
lib/Makefile.in
View file

File diff suppressed because it is too large Load diff

25
lib/extra_opts.c
View file

@ -1,23 +1,23 @@
/*****************************************************************************
*
*
* Monitoring Plugins extra_opts library
*
*
* License: GPL
* Copyright (c) 2007 Monitoring Plugins Development Team
*
*
* 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 "common.h"
@ -26,15 +26,14 @@
#include "extra_opts.h"
/* FIXME: copied from utils.h; we should move a bunch of libs! */
int
is_option2 (char *str)
bool is_option2 (char *str)
{
if (!str)
return FALSE;
return false;
else if (strspn (str, "-") == 1 || strspn (str, "-") == 2)
return TRUE;
return true;
else
return FALSE;
return false;
}
/* this is the externally visible function used by plugins */
@ -93,14 +92,14 @@ char **np_extra_opts(int *argc, char **argv, const char *plugin_name){
/* append the list to extra_args */
if(extra_args==NULL){
extra_args=ea1;
while(ea1=ea1->next) ea_num++;
while((ea1 = ea1->next)) ea_num++;
}else{
ea_tmp=extra_args;
while(ea_tmp->next) {
ea_tmp=ea_tmp->next;
}
ea_tmp->next=ea1;
while(ea1=ea1->next) ea_num++;
while((ea1 = ea1->next)) ea_num++;
}
ea1=ea_tmp=NULL;
}

26
lib/maxfd.c Normal file
View file

@ -0,0 +1,26 @@
#include "./maxfd.h"
#include <errno.h>
long mp_open_max (void) {
long maxfd = 0L;
/* Try sysconf(_SC_OPEN_MAX) first, as it can be higher than OPEN_MAX.
* If that fails and the macro isn't defined, we fall back to an educated
* guess. There's no guarantee that our guess is adequate and the program
* will die with SIGSEGV if it isn't and the upper boundary is breached. */
#ifdef _SC_OPEN_MAX
errno = 0;
if ((maxfd = sysconf (_SC_OPEN_MAX)) < 0) {
if (errno == 0)
maxfd = DEFAULT_MAXFD; /* it's indeterminate */
else
die (STATE_UNKNOWN, _("sysconf error for _SC_OPEN_MAX\n"));
}
#elif defined(OPEN_MAX)
return OPEN_MAX
#else /* sysconf macro unavailable, so guess (may be wildly inaccurate) */
return DEFAULT_MAXFD;
#endif
return(maxfd);
}

25
lib/parse_ini.c
View file

@ -1,24 +1,24 @@
/*****************************************************************************
*
*
* Monitoring Plugins parse_ini library
*
*
* License: GPL
* Copyright (c) 2007 Monitoring Plugins Development Team
*
*
* 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 "common.h"
@ -78,7 +78,7 @@ static char *default_file_in_path(void);
/*
* Parse_locator decomposes a string of the form
* [stanza][@filename]
* into its seperate parts.
* into its separate parts.
*/
static void
parse_locator(const char *locator, const char *def_stanza, np_ini_info *i)
@ -131,7 +131,7 @@ np_get_defaults(const char *locator, const char *default_section)
if (inifile == NULL)
die(STATE_UNKNOWN, _("Can't read config file: %s\n"),
strerror(errno));
if (read_defaults(inifile, i.stanza, &defaults) == FALSE)
if (!read_defaults(inifile, i.stanza, &defaults))
die(STATE_UNKNOWN,
_("Invalid section '%s' in config file '%s'\n"), i.stanza,
i.file);
@ -157,7 +157,8 @@ np_get_defaults(const char *locator, const char *default_section)
static int
read_defaults(FILE *f, const char *stanza, np_arg_list **opts)
{
int c, status = FALSE;
int c = 0;
bool status = false;
size_t i, stanza_len;
enum { NOSTANZA, WRONGSTANZA, RIGHTSTANZA } stanzastate = NOSTANZA;
@ -169,7 +170,7 @@ read_defaults(FILE *f, const char *stanza, np_arg_list **opts)
if (isspace(c))
continue;
switch (c) {
/* globble up coment lines */
/* globble up comment lines */
case ';':
case '#':
GOBBLE_TO(f, c, '\n');
@ -219,7 +220,7 @@ read_defaults(FILE *f, const char *stanza, np_arg_list **opts)
die(STATE_UNKNOWN, "%s\n",
_("Config file error"));
}
status = TRUE;
status = true;
break;
}
break;

2
lib/tests/Makefile.am
View file

@ -27,7 +27,7 @@ endif
AM_CFLAGS = -g -I$(top_srcdir)/lib -I$(top_srcdir)/gl $(tap_cflags)
AM_LDFLAGS = $(tap_ldflags) -ltap
LDADD = $(top_srcdir)/lib/libmonitoringplug.a $(top_srcdir)/gl/libgnu.a
LDADD = $(top_srcdir)/lib/libmonitoringplug.a $(top_srcdir)/gl/libgnu.a $(LIB_CRYPTO)
SOURCES = test_utils.c test_disk.c test_tcp.c test_cmd.c test_base64.c test_ini1.c test_ini3.c test_opts1.c test_opts2.c test_opts3.c

1134
lib/tests/Makefile.in
View file

File diff suppressed because it is too large Load diff

10
lib/tests/test_base64.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "common.h"

24
lib/tests/test_cmd.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "common.h"
@ -176,14 +176,14 @@ main (int argc, char **argv)
ok (result == UNSET, "(initialised) Checking exit code is reset");
command = (char *)malloc(COMMAND_LINE);
strcpy(command, "/bin/echo3456 non-existant command");
strcpy(command, "/bin/echo3456 non-existent command");
result = cmd_run (command, &chld_out, &chld_err, 0);
ok (chld_out.lines == 0,
"Non existant command, so no output");
"Non existent command, so no output");
ok (chld_err.lines == 0,
"No stderr either");
ok (result == 3, "Get return code 3 (?) for non-existant command");
ok (result == 3, "Get return code 3 (?) for non-existent command");
/* ensure everything is empty again */
@ -192,14 +192,14 @@ main (int argc, char **argv)
result = UNSET;
command = (char *)malloc(COMMAND_LINE);
strcpy(command, "/bin/sh non-existant-file");
strcpy(command, "/bin/sh non-existent-file");
result = cmd_run (command, &chld_out, &chld_err, 0);
ok (chld_out.lines == 0,
"/bin/sh returns no stdout when file is missing...");
ok (chld_err.lines == 1,
"...but does give an error line");
ok (strstr(chld_err.line[0],"non-existant-file") != NULL, "And missing filename is in error message");
ok (strstr(chld_err.line[0],"non-existent-file") != NULL, "And missing filename is in error message");
ok (result != 0, "Get non-zero return code from /bin/sh");
@ -219,11 +219,11 @@ main (int argc, char **argv)
result = UNSET;
command = (char *)malloc(COMMAND_LINE);
strcpy(command, "/bin/non-existant-command");
strcpy(command, "/bin/non-existent-command");
result = cmd_run (command, &chld_out, &chld_err, 0);
ok (chld_out.lines == 0,
"/bin/non-existant-command returns no stdout...");
"/bin/non-existent-command returns no stdout...");
ok (chld_err.lines == 0,
"...and no stderr output either");
ok (result == 3, "Get return code 3 = UNKNOWN when command does not exist");

42
lib/tests/test_disk.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "common.h"
@ -44,19 +44,19 @@ main (int argc, char **argv)
plan_tests(33);
ok( np_find_name(exclude_filesystem, "/var/log") == FALSE, "/var/log not in list");
ok( np_find_name(exclude_filesystem, "/var/log") == false, "/var/log not in list");
np_add_name(&exclude_filesystem, "/var/log");
ok( np_find_name(exclude_filesystem, "/var/log") == TRUE, "is in list now");
ok( np_find_name(exclude_filesystem, "/home") == FALSE, "/home not in list");
ok( np_find_name(exclude_filesystem, "/var/log") == true, "is in list now");
ok( np_find_name(exclude_filesystem, "/home") == false, "/home not in list");
np_add_name(&exclude_filesystem, "/home");
ok( np_find_name(exclude_filesystem, "/home") == TRUE, "is in list now");
ok( np_find_name(exclude_filesystem, "/var/log") == TRUE, "/var/log still in list");
ok( np_find_name(exclude_filesystem, "/home") == true, "is in list now");
ok( np_find_name(exclude_filesystem, "/var/log") == true, "/var/log still in list");
ok( np_find_name(exclude_fstype, "iso9660") == FALSE, "iso9660 not in list");
ok( np_find_name(exclude_fstype, "iso9660") == false, "iso9660 not in list");
np_add_name(&exclude_fstype, "iso9660");
ok( np_find_name(exclude_fstype, "iso9660") == TRUE, "is in list now");
ok( np_find_name(exclude_fstype, "iso9660") == true, "is in list now");
ok( np_find_name(exclude_filesystem, "iso9660") == FALSE, "Make sure no clashing in variables");
ok( np_find_name(exclude_filesystem, "iso9660") == false, "Make sure no clashing in variables");
/*
for (temp_name = exclude_filesystem; temp_name; temp_name = temp_name->next) {
@ -88,10 +88,10 @@ main (int argc, char **argv)
cflags, 3,strdup("regex on dev names:"));
np_test_mount_entry_regex(dummy_mount_list, strdup("/foo"),
cflags, 0,
strdup("regex on non existant dev/path:"));
strdup("regex on non existent dev/path:"));
np_test_mount_entry_regex(dummy_mount_list, strdup("/Foo"),
cflags | REG_ICASE,0,
strdup("regi on non existant dev/path:"));
strdup("regi on non existent dev/path:"));
np_test_mount_entry_regex(dummy_mount_list, strdup("/c.t0"),
cflags, 3,
strdup("partial devname regex match:"));
@ -120,7 +120,7 @@ main (int argc, char **argv)
np_add_parameter(&paths, "/home/tonvoon");
np_add_parameter(&paths, "/dev/c2t0d0s0");
np_set_best_match(paths, dummy_mount_list, FALSE);
np_set_best_match(paths, dummy_mount_list, false);
for (p = paths; p; p = p->name_next) {
struct mount_entry *temp_me;
temp_me = p->best_match;
@ -144,7 +144,7 @@ main (int argc, char **argv)
np_add_parameter(&paths, "/home/tonvoon");
np_add_parameter(&paths, "/home");
np_set_best_match(paths, dummy_mount_list, TRUE);
np_set_best_match(paths, dummy_mount_list, true);
for (p = paths; p; p = p->name_next) {
if (! strcmp(p->name, "/home/groups")) {
ok( ! p->best_match , "/home/groups correctly not found");
@ -167,7 +167,7 @@ main (int argc, char **argv)
}
ok(found == 0, "first element successfully deleted");
found = 0;
p=paths;
while (p) {
if (! strcmp(p->name, "/tmp"))
@ -203,9 +203,9 @@ main (int argc, char **argv)
}
void
void
np_test_mount_entry_regex (struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc)
{
{
int matches = 0;
regex_t re;
struct mount_entry *me;
@ -214,7 +214,7 @@ np_test_mount_entry_regex (struct mount_entry *dummy_mount_list, char *regstr, i
if(np_regex_match_mount_entry(me,&re))
matches++;
}
ok( matches == expect,
ok( matches == expect,
"%s '%s' matched %i/3 entries. ok: %i/3",
desc, regstr, expect, matches);

10
lib/tests/test_ini1.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "common.h"

10
lib/tests/test_ini3.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "parse_ini.h"

2
lib/tests/test_ini3.t
View file

@ -10,7 +10,7 @@ if (! -e "./test_ini3") {
# array of argument arrays
# - First value is the expected return code
# - 2nd value is the NAGIOS_CONFIG_PATH
# TODO: looks like we look in default path after looking trough this variable - shall we?
# TODO: looks like we look in default path after looking through this variable - shall we?
# - 3rd value is the plugin name
# - 4th is the ini locator
my @TESTS = (

2
lib/tests/test_opts2.c
View file

@ -12,7 +12,7 @@
*
* 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 "common.h"

2
lib/tests/test_opts3.t
View file

@ -10,7 +10,7 @@ if (! -e "./test_opts3") {
# array of argument arrays
# - First value is the expected return code
# - 2nd value is the NAGIOS_CONFIG_PATH
# TODO: looks like we look in default path after looking trough this variable - shall we?
# TODO: looks like we look in default path after looking through this variable - shall we?
# - 3rd value is the plugin name
# - 4th and up are arguments
my @TESTS = (

14
lib/tests/test_tcp.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "common.h"
@ -33,7 +33,7 @@ main(void)
server_expect[0] = strdup("AA");
server_expect[1] = strdup("bb");
server_expect[2] = strdup("CC");
ok(np_expect_match("AA bb CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_SUCCESS,
"Test matching any string at the beginning (first expect string)");
ok(np_expect_match("bb AA CC XX", server_expect, server_expect_count, NP_MATCH_EXACT) == NP_MATCH_SUCCESS,
@ -52,7 +52,7 @@ main(void)
"Test not matching all strings");
ok(np_expect_match("XX XX", server_expect, server_expect_count, NP_MATCH_ALL) == NP_MATCH_RETRY,
"Test not matching any string (testing all)");
return exit_status();
}

105
lib/tests/test_utils.c
View file

@ -1,19 +1,19 @@
/*****************************************************************************
*
*
* 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 "common.h"
@ -62,99 +62,99 @@ main (int argc, char **argv)
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");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 6, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
free(range);
range = parse_range_string("1:12%%");
ok( range != NULL, "'1:12%%' is valid - percentages are ignored");
ok( range->start == 1, "Start correct");
ok( range->start_infinity == FALSE, "Not using negative infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 12, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
free(range);
range = parse_range_string("-7:23");
ok( range != NULL, "'-7:23' is valid range");
ok( range->start == -7, "Start correct");
ok( range->start_infinity == FALSE, "Not using negative infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 23, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
free(range);
range = parse_range_string(":5.75");
ok( range != NULL, "':5.75' is valid range");
ok( range->start == 0, "Start correct");
ok( range->start_infinity == FALSE, "Not using negative infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 5.75, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
free(range);
range = parse_range_string("~:-95.99");
ok( range != NULL, "~:-95.99' is valid range");
ok( range->start_infinity == TRUE, "Using negative infinity");
ok( range->start_infinity == true, "Using negative infinity");
ok( range->end == -95.99, "End correct (with rounding errors)");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
free(range);
range = parse_range_string("12345678901234567890:");
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");
ok( range->end_infinity == TRUE, "Using infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end_infinity == true, "Using infinity");
/* Cannot do a "-1" on temp, as it appears to be same value */
ok( check_range(temp/1.1, range) == TRUE, "12345678901234567890/1.1 - alert");
ok( check_range(temp, range) == FALSE, "12345678901234567890 - no alert");
ok( check_range(temp*2, range) == FALSE, "12345678901234567890*2 - no alert");
ok( check_range(temp/1.1, range) == true, "12345678901234567890/1.1 - alert");
ok( check_range(temp, range) == false, "12345678901234567890 - no alert");
ok( check_range(temp*2, range) == false, "12345678901234567890*2 - no alert");
free(range);
range = parse_range_string("~:0");
ok( range != NULL, "'~:0' is valid range");
ok( range->start_infinity == TRUE, "Using negative infinity");
ok( range->start_infinity == true, "Using negative infinity");
ok( range->end == 0, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
ok( range->alert_on == OUTSIDE, "Will alert on outside of this range");
ok( check_range(0.5, range) == TRUE, "0.5 - alert");
ok( check_range(-10, range) == FALSE, "-10 - no alert");
ok( check_range(0, range) == FALSE, "0 - no alert");
ok( check_range(0.5, range) == true, "0.5 - alert");
ok( check_range(-10, range) == false, "-10 - no alert");
ok( check_range(0, range) == false, "0 - no alert");
free(range);
range = parse_range_string("@0:657.8210567");
ok( range != 0, "@0:657.8210567' is a valid range");
ok( range->start == 0, "Start correct");
ok( range->start_infinity == FALSE, "Not using negative infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 657.8210567, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
ok( range->alert_on == INSIDE, "Will alert on inside of this range" );
ok( check_range(32.88, range) == TRUE, "32.88 - alert");
ok( check_range(-2, range) == FALSE, "-2 - no alert");
ok( check_range(657.8210567, range) == TRUE, "657.8210567 - alert");
ok( check_range(0, range) == TRUE, "0 - alert");
ok( check_range(32.88, range) == true, "32.88 - alert");
ok( check_range(-2, range) == false, "-2 - no alert");
ok( check_range(657.8210567, range) == true, "657.8210567 - alert");
ok( check_range(0, range) == true, "0 - alert");
free(range);
range = parse_range_string("@1:1");
ok( range != NULL, "'@1:1' is a valid range");
ok( range->start == 1, "Start correct");
ok( range->start_infinity == FALSE, "Not using negative infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 1, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( range->end_infinity == false, "Not using infinity");
ok( range->alert_on == INSIDE, "Will alert on inside of this range" );
ok( check_range(0.5, range) == FALSE, "0.5 - no alert");
ok( check_range(1, range) == TRUE, "1 - alert");
ok( check_range(5.2, range) == FALSE, "5.2 - no alert");
ok( check_range(0.5, range) == false, "0.5 - no alert");
ok( check_range(1, range) == true, "1 - alert");
ok( check_range(5.2, range) == false, "5.2 - no alert");
free(range);
range = parse_range_string("1:1");
ok( range != NULL, "'1:1' is a valid range");
ok( range->start == 1, "Start correct");
ok( range->start_infinity == FALSE, "Not using negative infinity");
ok( range->start_infinity == false, "Not using negative infinity");
ok( range->end == 1, "End correct");
ok( range->end_infinity == FALSE, "Not using infinity");
ok( check_range(0.5, range) == TRUE, "0.5 - alert");
ok( check_range(1, range) == FALSE, "1 - no alert");
ok( check_range(5.2, range) == TRUE, "5.2 - alert");
ok( range->end_infinity == false, "Not using infinity");
ok( check_range(0.5, range) == true, "0.5 - alert");
ok( check_range(1, range) == false, "1 - no alert");
ok( check_range(5.2, range) == true, "5.2 - alert");
free(range);
range = parse_range_string("2:1");
@ -309,7 +309,7 @@ main (int argc, char **argv)
/* This is the result of running ./test_utils */
temp_string = (char *) _np_state_generate_key();
ok(!strcmp(temp_string, "83d877b6cdfefb5d6f06101fd6fe76762f21792c"), "Got hash with exe and no parameters" ) ||
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" );
@ -319,7 +319,7 @@ main (int argc, char **argv)
this_monitoring_plugin->argv[2] = "--and";
this_monitoring_plugin->argv[3] = "now";
temp_string = (char *) _np_state_generate_key();
ok(!strcmp(temp_string, "94b5e17bf5abf51cb15aff5f69b96f2f8dac5ecd"), "Got based on expected argv" );
ok(!strcmp(temp_string, "bd72da9f78ff1419fad921ea5e43ce56508aef6c"), "Got based on expected argv" );
unsetenv("MP_STATE_PATH");
temp_string = (char *) _np_state_calculate_location_prefix();
@ -342,7 +342,7 @@ main (int argc, char **argv)
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, "83d877b6cdfefb5d6f06101fd6fe76762f21792c"), "Got generated filename" );
ok( !strcmp(temp_state_key->name, "e2d17f995fd4c020411b85e3e3d0ff7306d4147e"), "Got generated filename" );
np_enable_state("allowedchars_in_keyname", 77);
@ -377,13 +377,13 @@ main (int argc, char **argv)
/*
temp_fp = fopen("var/statefile", "r");
if (temp_fp==NULL)
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" );
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");
@ -395,7 +395,7 @@ main (int argc, char **argv)
ok( temp_state_data==NULL, "Older data version gives NULL" );
temp_state_key->data_version=54;
temp_state_key->_filename="var/nonexistant";
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" );
@ -446,20 +446,20 @@ main (int argc, char **argv)
/* 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");
ok(mp_suid() == false, "Test aren't suid");
/* base states with random case */
char *states[] = {
@ -508,4 +508,3 @@ main (int argc, char **argv)
return exit_status();
}

122
lib/utils_base.c
View file

@ -6,25 +6,25 @@
* Copyright (c) 2006 Monitoring Plugins Development Team
*
* Library of useful functions for plugins
*
*
*
* 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 "common.h"
#include "../plugins/common.h"
#include <stdarg.h>
#include "utils_base.h"
#include <ctype.h>
@ -40,7 +40,7 @@ monitoring_plugin *this_monitoring_plugin=NULL;
unsigned int timeout_state = STATE_CRITICAL;
unsigned int timeout_interval = DEFAULT_SOCKET_TIMEOUT;
int _np_state_read_file(FILE *);
bool _np_state_read_file(FILE *);
void np_init( char *plugin_name, int argc, char **argv ) {
if (this_monitoring_plugin==NULL) {
@ -105,12 +105,12 @@ die (int result, const char *fmt, ...)
void set_range_start (range *this, double value) {
this->start = value;
this->start_infinity = FALSE;
this->start_infinity = false;
}
void set_range_end (range *this, double value) {
this->end = value;
this->end_infinity = FALSE;
this->end_infinity = false;
}
range
@ -124,9 +124,9 @@ range
/* Set defaults */
temp_range->start = 0;
temp_range->start_infinity = FALSE;
temp_range->start_infinity = false;
temp_range->end = 0;
temp_range->end_infinity = TRUE;
temp_range->end_infinity = true;
temp_range->alert_on = OUTSIDE;
temp_range->text = strdup(str);
@ -138,7 +138,7 @@ range
end_str = index(str, ':');
if (end_str != NULL) {
if (str[0] == '~') {
temp_range->start_infinity = TRUE;
temp_range->start_infinity = true;
} else {
start = strtod(str, NULL); /* Will stop at the ':' */
set_range_start(temp_range, start);
@ -152,8 +152,8 @@ range
set_range_end(temp_range, end);
}
if (temp_range->start_infinity == TRUE ||
temp_range->end_infinity == TRUE ||
if (temp_range->start_infinity == true ||
temp_range->end_infinity == true ||
temp_range->start <= temp_range->end) {
return temp_range;
}
@ -223,31 +223,30 @@ void print_thresholds(const char *threshold_name, thresholds *my_threshold) {
printf("\n");
}
/* Returns TRUE if alert should be raised based on the range */
int
check_range(double value, range *my_range)
/* Returns true if alert should be raised based on the range */
bool check_range(double value, range *my_range)
{
int no = FALSE;
int yes = TRUE;
bool no = false;
bool yes = true;
if (my_range->alert_on == INSIDE) {
no = TRUE;
yes = FALSE;
no = true;
yes = false;
}
if (my_range->end_infinity == FALSE && my_range->start_infinity == FALSE) {
if (my_range->end_infinity == false && my_range->start_infinity == false) {
if ((my_range->start <= value) && (value <= my_range->end)) {
return no;
} else {
return yes;
}
} else if (my_range->start_infinity == FALSE && my_range->end_infinity == TRUE) {
} else if (my_range->start_infinity == false && my_range->end_infinity == true) {
if (my_range->start <= value) {
return no;
} else {
return yes;
}
} else if (my_range->start_infinity == TRUE && my_range->end_infinity == FALSE) {
} else if (my_range->start_infinity == true && my_range->end_infinity == false) {
if (value <= my_range->end) {
return no;
} else {
@ -263,12 +262,12 @@ 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) == true) {
return STATE_CRITICAL;
}
}
if (my_thresholds->warning != NULL) {
if (check_range(value, my_thresholds->warning) == TRUE) {
if (check_range(value, my_thresholds->warning) == true) {
return STATE_WARNING;
}
}
@ -319,20 +318,20 @@ char *np_extract_value(const char *varlist, const char *name, char sep) {
while (1) {
/* Strip any leading space */
for (varlist; isspace(varlist[0]); varlist++);
for (; isspace(varlist[0]); varlist++);
if (strncmp(name, varlist, strlen(name)) == 0) {
varlist += strlen(name);
/* strip trailing spaces */
for (varlist; 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 (varlist; isspace(varlist[0]); varlist++);
for (; isspace(varlist[0]); varlist++);
if (tmp = index(varlist, sep)) {
if ((tmp = index(varlist, sep))) {
/* Value is delimited by a comma */
if (tmp-varlist == 0) continue;
value = (char *)calloc(1, tmp-varlist+1);
@ -348,7 +347,7 @@ char *np_extract_value(const char *varlist, const char *name, char sep) {
break;
}
}
if (tmp = index(varlist, sep)) {
if ((tmp = index(varlist, sep))) {
/* More keys, keep going... */
varlist = tmp + 1;
} else {
@ -402,26 +401,45 @@ int mp_translate_state (char *state_text) {
* parse of argv, so that uniqueness in parameters are reflected there.
*/
char *_np_state_generate_key() {
struct sha1_ctx ctx;
int i;
char **argv = this_monitoring_plugin->argv;
unsigned char result[20];
char keyname[41];
char *p=NULL;
sha1_init_ctx(&ctx);
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++) {
sha1_process_bytes(argv[i], strlen(argv[i]), &ctx);
EVP_DigestUpdate(ctx, argv[i], strlen(argv[i]));
}
sha1_finish_ctx(&ctx, &result);
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));
@ -446,7 +464,7 @@ char* _np_state_calculate_location_prefix(){
/* Do not allow passing MP_STATE_PATH in setuid plugins
* for security reasons */
if (mp_suid() == FALSE) {
if (!mp_suid()) {
env_dir = getenv("MP_STATE_PATH");
if(env_dir && env_dir[0] != '\0')
return env_dir;
@ -522,7 +540,7 @@ void np_enable_state(char *keyname, int expected_data_version) {
state_data *np_state_read() {
state_data *this_state_data=NULL;
FILE *statefile;
int rc = FALSE;
bool rc = false;
if(this_monitoring_plugin==NULL)
die(STATE_UNKNOWN, _("This requires np_init to be called"));
@ -544,7 +562,7 @@ state_data *np_state_read() {
fclose(statefile);
}
if(rc==FALSE) {
if(!rc) {
_cleanup_state_data();
}
@ -554,8 +572,8 @@ state_data *np_state_read() {
/*
* Read the state file
*/
int _np_state_read_file(FILE *f) {
int status=FALSE;
bool _np_state_read_file(FILE *f) {
bool status = false;
size_t pos;
char *line;
int i;
@ -609,7 +627,7 @@ int _np_state_read_file(FILE *f) {
if(this_monitoring_plugin->state->state_data->data==NULL)
die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
expected=STATE_DATA_END;
status=TRUE;
status=true;
break;
case STATE_DATA_END:
;
@ -621,10 +639,10 @@ int _np_state_read_file(FILE *f) {
}
/*
* 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.
* 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) {
@ -639,7 +657,7 @@ void np_state_write_string(time_t data_time, char *data_string) {
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);
@ -678,15 +696,15 @@ void np_state_write_string(time_t data_time, char *data_string) {
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);

12
lib/utils_base.h
View file

@ -2,9 +2,11 @@
#define _UTILS_BASE_
/* Header file for Monitoring Plugins utils_base.c */
#include "sha1.h"
#ifndef USE_OPENSSL
# include "sha256.h"
#endif
/* This file holds header information for thresholds - use this in preference to
/* This file holds header information for thresholds - use this in preference to
individual plugin logic */
/* This has not been merged with utils.h because of problems with
@ -19,7 +21,7 @@
typedef struct range_struct {
double start;
int start_infinity; /* FALSE (default) or TRUE */
bool start_infinity;
double end;
int end_infinity;
int alert_on; /* OUTSIDE (default) or INSIDE */
@ -59,7 +61,7 @@ range *parse_range_string (char *);
int _set_thresholds(thresholds **, char *, char *);
void set_thresholds(thresholds **, char *, char *);
void print_thresholds(const char *, thresholds *);
int check_range(double, range *);
bool check_range(double, range *);
int get_status(double, thresholds *);
/* Handle timeouts */
@ -77,7 +79,7 @@ void die (int, const char *, ...) __attribute__((noreturn,format(printf, 2, 3)))
#define NP_RANGE_UNPARSEABLE 1
#define NP_WARN_WITHIN_CRIT 2
/* a simple check to see if we're running as root.
/* a simple check to see if we're running as root.
* returns zero on failure, nonzero on success */
int np_check_if_root(void);

43
lib/utils_cmd.c
View file

@ -18,18 +18,18 @@
* Care has been taken to make sure the functions are async-safe. The one
* function which isn't is cmd_init() which it doesn't make sense to
* call twice anyway, so the api as a whole should be considered async-safe.
*
*
*
*
* 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/>.
*
@ -42,7 +42,20 @@
#include "common.h"
#include "utils.h"
#include "utils_cmd.h"
/* This variable must be global, since there's no way the caller
* can forcibly slay a dead or ungainly running program otherwise.
* Multithreading apps and plugins can initialize it (via CMD_INIT)
* in an async safe manner PRIOR to calling cmd_run() or cmd_run_array()
* for the first time.
*
* The check for initialized values is atomic and can
* occur in any number of threads simultaneously. */
static pid_t *_cmd_pids = NULL;
#include "utils_base.h"
#include "./maxfd.h"
#include <fcntl.h>
#ifdef HAVE_SYS_WAIT_H
@ -86,13 +99,7 @@ extern void die (int, const char *, ...)
void
cmd_init (void)
{
#ifndef maxfd
if (!maxfd && (maxfd = sysconf (_SC_OPEN_MAX)) < 0) {
/* possibly log or emit a warning here, since there's no
* guarantee that our guess at maxfd will be adequate */
maxfd = DEFAULT_MAXFD;
}
#endif
long maxfd = mp_open_max();
/* if maxfd is unnaturally high, we force it to a lower value
* ( e.g. on SunOS, when ulimit is set to unlimited: 2147483647 this would cause
@ -118,10 +125,6 @@ _cmd_open (char *const *argv, int *pfd, int *pfderr)
int i = 0;
/* if no command was passed, return with no error */
if (argv == NULL)
return -1;
if (!_cmd_pids)
CMD_INIT;
@ -152,6 +155,7 @@ _cmd_open (char *const *argv, int *pfd, int *pfderr)
/* close all descriptors in _cmd_pids[]
* This is executed in a separate address space (pure child),
* so we don't have to worry about async safety */
long maxfd = mp_open_max();
for (i = 0; i < maxfd; i++)
if (_cmd_pids[i] > 0)
close (i);
@ -161,7 +165,7 @@ _cmd_open (char *const *argv, int *pfd, int *pfderr)
}
/* parent picks up execution here */
/* close childs descriptors in our address space */
/* close children descriptors in our address space */
close (pfd[1]);
close (pfderr[1]);
@ -178,6 +182,7 @@ _cmd_close (int fd)
pid_t pid;
/* make sure the provided fd was opened */
long maxfd = mp_open_max();
if (fd < 0 || fd > maxfd || !_cmd_pids || (pid = _cmd_pids[fd]) == 0)
return -1;
@ -269,7 +274,6 @@ _cmd_fetch_output (int fd, output * op, int flags)
int
cmd_run (const char *cmdstring, output * out, output * err, int flags)
{
int fd, pfd_out[2], pfd_err[2];
int i = 0, argc;
size_t cmdlen;
char **argv = NULL;
@ -373,10 +377,10 @@ cmd_file_read ( char *filename, output *out, int flags)
if ((fd = open(filename, O_RDONLY)) == -1) {
die( STATE_UNKNOWN, _("Error opening %s: %s"), filename, strerror(errno) );
}
if(out)
out->lines = _cmd_fetch_output (fd, out, flags);
if (close(fd) == -1)
die( STATE_UNKNOWN, _("Error closing %s: %s"), filename, strerror(errno) );
@ -391,6 +395,7 @@ timeout_alarm_handler (int signo)
printf (_("%s - Plugin timed out after %d seconds\n"),
state_text(timeout_state), timeout_interval);
long maxfd = mp_open_max();
if(_cmd_pids) for(i = 0; i < maxfd; i++) {
if(_cmd_pids[i] != 0) kill(_cmd_pids[i], SIGKILL);
}

17
lib/utils_cmd.h
View file

@ -1,10 +1,10 @@
#ifndef _UTILS_CMD_
#define _UTILS_CMD_
/*
/*
* Header file for Monitoring Plugins utils_cmd.c
*
*
*
*
*/
/** types **/
@ -32,17 +32,8 @@ void cmd_init (void);
#define CMD_NO_ARRAYS 0x01 /* don't populate arrays at all */
#define CMD_NO_ASSOC 0x02 /* output.line won't point to buf */
/* This variable must be global, since there's no way the caller
* can forcibly slay a dead or ungainly running program otherwise.
* Multithreading apps and plugins can initialize it (via CMD_INIT)
* in an async safe manner PRIOR to calling cmd_run() or cmd_run_array()
* for the first time.
*
* The check for initialized values is atomic and can
* occur in any number of threads simultaneously. */
static pid_t *_cmd_pids = NULL;
RETSIGTYPE timeout_alarm_handler (int);
void timeout_alarm_handler (int);
#endif /* _UTILS_CMD_ */

155
lib/utils_disk.c
View file

@ -1,34 +1,35 @@
/*****************************************************************************
*
*
* Library for check_disk
*
*
* License: GPL
* Copyright (c) 1999-2007 Monitoring Plugins Development Team
*
*
* Description:
*
*
* This file contains utilities for check_disk. These are tested by libtap
*
*
*
*
* 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 "common.h"
#include "utils_disk.h"
#include "gl/fsusage.h"
#include <string.h>
void
np_add_name (struct name_list **list, const char *name)
@ -40,6 +41,42 @@ np_add_name (struct name_list **list, const char *name)
*list = new_entry;
}
/* @brief Initialises a new regex at the begin of list via regcomp(3)
*
* @details if the regex fails to compile the error code of regcomp(3) is returned
* and list is not modified, otherwise list is modified to point to the new
* element
* @param list Pointer to a linked list of regex_list elements
* @param regex the string containing the regex which should be inserted into the list
* @param clags the cflags parameter for regcomp(3)
*/
int
np_add_regex (struct regex_list **list, const char *regex, int cflags)
{
struct regex_list *new_entry = (struct regex_list *) malloc (sizeof *new_entry);
if (new_entry == NULL) {
die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
strerror(errno));
}
int regcomp_result = regcomp(&new_entry->regex, regex, cflags);
if (!regcomp_result) {
// regcomp succeeded
new_entry->next = *list;
*list = new_entry;
return 0;
} else {
// regcomp failed
free(new_entry);
return regcomp_result;
}
}
/* Initialises a new parameter at the end of list */
struct parameter_list *
np_add_parameter(struct parameter_list **list, const char *name)
@ -47,9 +84,10 @@ np_add_parameter(struct parameter_list **list, const char *name)
struct parameter_list *current = *list;
struct parameter_list *new_path;
new_path = (struct parameter_list *) malloc (sizeof *new_path);
new_path->name = (char *) name;
new_path->name = (char *) malloc(strlen(name) + 1);
new_path->best_match = NULL;
new_path->name_next = NULL;
new_path->name_prev = NULL;
new_path->freespace_bytes = NULL;
new_path->freespace_units = NULL;
new_path->freespace_percent = NULL;
@ -60,7 +98,7 @@ np_add_parameter(struct parameter_list **list, const char *name)
new_path->freeinodes_percent = NULL;
new_path->group = NULL;
new_path->dfree_pct = -1;
new_path->dused_pct = -1;
new_path->dused_pct = -1;
new_path->total = 0;
new_path->available = 0;
new_path->available_to_root = 0;
@ -75,13 +113,17 @@ np_add_parameter(struct parameter_list **list, const char *name)
new_path->dused_inodes_percent = 0;
new_path->dfree_inodes_percent = 0;
strcpy(new_path->name, name);
if (current == NULL) {
*list = new_path;
new_path->name_prev = NULL;
} else {
while (current->name_next) {
current = current->name_next;
}
current->name_next = new_path;
new_path->name_prev = current;
}
return new_path;
}
@ -90,6 +132,9 @@ np_add_parameter(struct parameter_list **list, const char *name)
struct parameter_list *
np_del_parameter(struct parameter_list *item, struct parameter_list *prev)
{
if (item == NULL) {
return NULL;
}
struct parameter_list *next;
if (item->name_next)
@ -97,10 +142,17 @@ np_del_parameter(struct parameter_list *item, struct parameter_list *prev)
else
next = NULL;
free(item);
if (next)
next->name_prev = prev;
if (prev)
prev->name_next = next;
if (item->name) {
free(item->name);
}
free(item);
return next;
}
@ -118,9 +170,7 @@ np_find_parameter(struct parameter_list *list, const char *name)
return NULL;
}
void
np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, int exact)
{
void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, bool exact) {
struct parameter_list *d;
for (d = desired; d; d= d->name_next) {
if (! d->best_match) {
@ -132,24 +182,25 @@ np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list
/* set best match if path name exactly matches a mounted device name */
for (me = mount_list; me; me = me->me_next) {
if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) < 0)
continue; /* skip if permissions do not suffice for accessing device */
if (strcmp(me->me_devname, d->name)==0)
best_match = me;
if (strcmp(me->me_devname, d->name)==0) {
if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) >= 0) {
best_match = me;
}
}
}
/* set best match by directory name if no match was found by devname */
if (! best_match) {
for (me = mount_list; me; me = me->me_next) {
if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) < 0)
continue; /* skip if permissions do not suffice for accessing device */
size_t len = strlen (me->me_mountdir);
if ((exact == FALSE && (best_match_len <= len && len <= name_len &&
if ((!exact && (best_match_len <= len && len <= name_len &&
(len == 1 || strncmp (me->me_mountdir, d->name, len) == 0)))
|| (exact == TRUE && strcmp(me->me_mountdir, d->name)==0))
|| (exact && strcmp(me->me_mountdir, d->name)==0))
{
best_match = me;
best_match_len = len;
if (get_fs_usage(me->me_mountdir, me->me_devname, &fsp) >= 0) {
best_match = me;
best_match_len = len;
}
}
}
}
@ -163,43 +214,57 @@ np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list
}
}
/* Returns TRUE if name is in list */
int
np_find_name (struct name_list *list, const char *name)
{
/* Returns true if name is in list */
bool np_find_name (struct name_list *list, const char *name) {
const struct name_list *n;
if (list == NULL || name == NULL) {
return FALSE;
return false;
}
for (n = list; n; n = n->next) {
if (!strcmp(name, n->name)) {
return TRUE;
return true;
}
}
return FALSE;
return false;
}
int
np_seen_name(struct name_list *list, const char *name)
{
/* Returns true if name is in list */
bool np_find_regmatch (struct regex_list *list, const char *name) {
int len;
regmatch_t m;
if (name == NULL) {
return false;
}
len = strlen(name);
for (; list; list = list->next) {
/* Emulate a full match as if surrounded with ^( )$
by checking whether the match spans the whole name */
if (!regexec(&list->regex, name, 1, &m, 0) && m.rm_so == 0 && m.rm_eo == len) {
return true;
}
}
return false;
}
bool np_seen_name(struct name_list *list, const char *name) {
const struct name_list *s;
for (s = list; s; s=s->next) {
if (!strcmp(s->name, name)) {
return TRUE;
return true;
}
}
return FALSE;
return false;
}
int
np_regex_match_mount_entry (struct mount_entry* me, regex_t* re)
{
bool np_regex_match_mount_entry (struct mount_entry* me, regex_t* re) {
if (regexec(re, me->me_devname, (size_t) 0, NULL, 0) == 0 ||
regexec(re, me->me_mountdir, (size_t) 0, NULL, 0) == 0 ) {
return TRUE;
} else {
return FALSE;
return true;
}
return false;
}

19
lib/utils_disk.h
View file

@ -10,6 +10,12 @@ struct name_list
struct name_list *next;
};
struct regex_list
{
regex_t regex;
struct regex_list *next;
};
struct parameter_list
{
char *name;
@ -24,6 +30,7 @@ struct parameter_list
char *group;
struct mount_entry *best_match;
struct parameter_list *name_next;
struct parameter_list *name_prev;
uintmax_t total, available, available_to_root, used,
inodes_free, inodes_free_to_root, inodes_used, inodes_total;
double dfree_pct, dused_pct;
@ -32,12 +39,14 @@ struct parameter_list
};
void np_add_name (struct name_list **list, const char *name);
int np_find_name (struct name_list *list, const char *name);
int np_seen_name (struct name_list *list, const char *name);
bool np_find_name (struct name_list *list, const char *name);
bool np_seen_name (struct name_list *list, const char *name);
int np_add_regex (struct regex_list **list, const char *regex, int cflags);
bool np_find_regmatch (struct regex_list *list, const char *name);
struct parameter_list *np_add_parameter(struct parameter_list **list, const char *name);
struct parameter_list *np_find_parameter(struct parameter_list *list, const char *name);
struct parameter_list *np_del_parameter(struct parameter_list *item, struct parameter_list *prev);
int search_parameter_list (struct parameter_list *list, const char *name);
void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, int exact);
int np_regex_match_mount_entry (struct mount_entry* me, regex_t* re);
void np_set_best_match(struct parameter_list *desired, struct mount_entry *mount_list, bool exact);
bool np_regex_match_mount_entry (struct mount_entry* me, regex_t* re);

20
lib/utils_tcp.c
View file

@ -1,29 +1,29 @@
/*****************************************************************************
*
*
* Library for check_tcp
*
*
* License: GPL
* Copyright (c) 1999-2013 Monitoring Plugins Development Team
*
*
* Description:
*
*
* This file contains utilities for check_tcp. These are tested by libtap
*
*
*
*
* 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 "common.h"