Merge branch 'master' into dev/check_ssh-patches

9 files changed, 153 insertions, 32 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index 01d73a64..1a47395d 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -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
diff --git a/lib/maxfd.c b/lib/maxfd.c
new file mode 100644
index 00000000..529b3568
--- /dev/null
+++ b/lib/maxfd.c
@@ -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);
+}
diff --git a/lib/maxfd.h b/lib/maxfd.h
new file mode 100644
index 00000000..45218d0f
--- /dev/null
+++ b/lib/maxfd.h
@@ -0,0 +1,9 @@
+#ifndef _MAXFD_
+#define _MAXFD_
+
+#define DEFAULT_MAXFD  256   /* fallback value if no max open files value is set */
+#define MAXFD_LIMIT   8192   /* upper limit of open files */
+
+long mp_open_max (void);
+
+#endif // _MAXFD_
diff --git a/lib/utils_base.c b/lib/utils_base.c
index c458cf61..0f521263 100644
--- a/lib/utils_base.c
+++ b/lib/utils_base.c
@@ -402,26 +402,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 sha256_ctx ctx;
         int i;
         char **argv = this_monitoring_plugin->argv;
-        unsigned char result[20];
         char keyname[41];
         char *p=NULL;
 
-        sha256_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++) {
+                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);
-        
+        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));
diff --git a/lib/utils_base.h b/lib/utils_base.h
index 59065504..9cb42767 100644
--- a/lib/utils_base.h
+++ b/lib/utils_base.h
@@ -2,7 +2,9 @@
 #define _UTILS_BASE_
 /* Header file for Monitoring Plugins utils_base.c */
 
-#include "sha256.h"
+#ifndef USE_OPENSSL
+# include "sha256.h"
+#endif
 
 /* This file holds header information for thresholds - use this in preference to 
    individual plugin logic */
diff --git a/lib/utils_cmd.c b/lib/utils_cmd.c
index 8b8e5708..f66fd573 100644
--- a/lib/utils_cmd.c
+++ b/lib/utils_cmd.c
@@ -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);
@@ -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;
@@ -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);
                 }
diff --git a/lib/utils_cmd.h b/lib/utils_cmd.h
index 6f3aeb81..f1b06c82 100644
--- a/lib/utils_cmd.h
+++ b/lib/utils_cmd.h
@@ -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_ */
diff --git a/lib/utils_disk.c b/lib/utils_disk.c
index 582d3ea1..f5ac0b30 100644
--- a/lib/utils_disk.c
+++ b/lib/utils_disk.c
@@ -29,6 +29,7 @@
 #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)
@@ -196,6 +233,30 @@ np_find_name (struct name_list *list, const char *name)
   return FALSE;
 }
 
+/* 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;
+}
+
 int
 np_seen_name(struct name_list *list, const char *name)
 {
diff --git a/lib/utils_disk.h b/lib/utils_disk.h
index 3b5a45f8..6b83ac74 100644
--- a/lib/utils_disk.h
+++ b/lib/utils_disk.h
@@ -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;
@@ -35,6 +41,8 @@ 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);
+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);