1 files changed, 140 insertions, 21 deletions

diff --git a/lib/output.c b/lib/output.c
index 61fbf832..3c04d63d 100644
--- a/lib/output.c
+++ b/lib/output.c
@@ -13,9 +13,11 @@
 
 // == Global variables
 static mp_output_format output_format = MP_FORMAT_DEFAULT;
+static mp_output_detail_level level_of_detail = MP_DETAIL_ALL;
 
 // == Prototypes ==
-static char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check, unsigned int indentation);
+static char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check,
+                                                                 unsigned int indentation);
 static inline cJSON *json_serialize_subcheck(mp_subcheck subcheck);
 
 // == Implementation ==
@@ -40,7 +42,7 @@ static inline char *fmt_subcheck_perfdata(mp_subcheck check) {
 
         while (subchecks != NULL) {
                 if (added > 0) {
-                        added = asprintf(&result, "%s%s", result, fmt_subcheck_perfdata(subchecks->subcheck));
+                        added = asprintf(&result, "%s %s", result, fmt_subcheck_perfdata(subchecks->subcheck));
                 } else {
                         // TODO free previous result here?
                         added = asprintf(&result, "%s", fmt_subcheck_perfdata(subchecks->subcheck));
@@ -57,7 +59,11 @@ static inline char *fmt_subcheck_perfdata(mp_subcheck check) {
  * It sets useful defaults
  */
 mp_check mp_check_init(void) {
-        mp_check check = {0};
+        mp_check check = {
+                .evaluation_function = &mp_eval_check_default,
+                .default_output_override = NULL,
+                .default_output_override_content = NULL,
+        };
         return check;
 }
 
@@ -120,7 +126,8 @@ void mp_add_perfdata_to_subcheck(mp_subcheck check[static 1], const mp_perfdata
  */
 int mp_add_subcheck_to_subcheck(mp_subcheck check[static 1], mp_subcheck subcheck) {
         if (subcheck.output == NULL) {
-                die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__, "Sub check output is NULL");
+                die(STATE_UNKNOWN, "%s - %s #%d: %s", __FILE__, __func__, __LINE__,
+                        "Sub check output is NULL");
         }
 
         mp_subcheck_list *tmp = NULL;
@@ -160,7 +167,7 @@ int mp_add_subcheck_to_subcheck(mp_subcheck check[static 1], mp_subcheck subchec
 void mp_add_summary(mp_check check[static 1], char *summary) { check->summary = summary; }
 
 /*
- * Generate the summary string of a mp_check object based on it's subchecks
+ * Generate the summary string of a mp_check object based on its subchecks
  */
 char *get_subcheck_summary(mp_check check) {
         mp_subcheck_list *subchecks = check.subchecks;
@@ -170,7 +177,7 @@ char *get_subcheck_summary(mp_check check) {
         unsigned int critical = 0;
         unsigned int unknown = 0;
         while (subchecks != NULL) {
-                switch (subchecks->subcheck.state) {
+                switch (mp_compute_subcheck_state(subchecks->subcheck)) {
                 case STATE_OK:
                         ok++;
                         break;
@@ -193,16 +200,33 @@ char *get_subcheck_summary(mp_check check) {
         return result;
 }
 
+mp_state_enum mp_compute_subcheck_state(const mp_subcheck subcheck) {
+        if (subcheck.evaluation_function == NULL) {
+                return mp_eval_subcheck_default(subcheck);
+        }
+        return subcheck.evaluation_function(subcheck);
+}
+
 /*
- * Generate the result state of a mp_subcheck object based on it's own state and it's subchecks states
+ * Generate the result state of a mp_subcheck object based on its own state and its subchecks
+ * states
  */
-mp_state_enum mp_compute_subcheck_state(const mp_subcheck check) {
-        if (check.state_set_explicitly) {
-                return check.state;
+mp_state_enum mp_eval_subcheck_default(mp_subcheck subcheck) {
+        if (subcheck.evaluation_function != NULL) {
+                return subcheck.evaluation_function(subcheck);
         }
 
-        mp_subcheck_list *scl = check.subchecks;
-        mp_state_enum result = check.default_state;
+        if (subcheck.state_set_explicitly) {
+                return subcheck.state;
+        }
+
+        mp_subcheck_list *scl = subcheck.subchecks;
+
+        if (scl == NULL) {
+                return subcheck.default_state;
+        }
+
+        mp_state_enum result = STATE_OK;
 
         while (scl != NULL) {
                 result = max_state_alt(result, mp_compute_subcheck_state(scl->subcheck));
@@ -212,10 +236,18 @@ mp_state_enum mp_compute_subcheck_state(const mp_subcheck check) {
         return result;
 }
 
+mp_state_enum mp_compute_check_state(const mp_check check) {
+        // just a safety check
+        if (check.evaluation_function == NULL) {
+                return mp_eval_check_default(check);
+        }
+        return check.evaluation_function(check);
+}
+
 /*
- * Generate the result state of a mp_check object based on it's own state and it's subchecks states
+ * Generate the result state of a mp_check object based on its own state and its subchecks states
  */
-mp_state_enum mp_compute_check_state(const mp_check check) {
+mp_state_enum mp_eval_check_default(const mp_check check) {
         assert(check.subchecks != NULL); // a mp_check without subchecks is invalid, die here
 
         mp_subcheck_list *scl = check.subchecks;
@@ -229,6 +261,21 @@ mp_state_enum mp_compute_check_state(const mp_check check) {
         return result;
 }
 
+// Remove troublesome symbols from plugin output
+char *sanitize_output_insitu(char *input) {
+        if (input == NULL) {
+                return input;
+        }
+
+        for (char *walker = input; *walker != '\0'; walker++) {
+                if (*walker == '|') {
+                        *walker = ' ';
+                }
+        }
+
+        return input;
+}
+
 /*
  * Generate output string for a mp_check object
  * Non static to be available for testing functions
@@ -238,6 +285,11 @@ char *mp_fmt_output(mp_check check) {
 
         switch (output_format) {
         case MP_FORMAT_MULTI_LINE: {
+                if (check.default_output_override != NULL) {
+                        result = check.default_output_override(check.default_output_override_content);
+                        break;
+                }
+
                 if (check.summary == NULL) {
                         check.summary = get_subcheck_summary(check);
                 }
@@ -247,7 +299,11 @@ char *mp_fmt_output(mp_check check) {
                 mp_subcheck_list *subchecks = check.subchecks;
 
                 while (subchecks != NULL) {
-                        asprintf(&result, "%s\n%s", result, fmt_subcheck_output(MP_FORMAT_MULTI_LINE, subchecks->subcheck, 1));
+                        if (level_of_detail == MP_DETAIL_ALL ||
+                                mp_compute_subcheck_state(subchecks->subcheck) != STATE_OK) {
+                                asprintf(&result, "%s\n%s", result,
+                                                 fmt_subcheck_output(MP_FORMAT_MULTI_LINE, subchecks->subcheck, 1));
+                        }
                         subchecks = subchecks->next;
                 }
 
@@ -258,12 +314,15 @@ char *mp_fmt_output(mp_check check) {
                         if (pd_string == NULL) {
                                 asprintf(&pd_string, "%s", fmt_subcheck_perfdata(subchecks->subcheck));
                         } else {
-                                asprintf(&pd_string, "%s %s", pd_string, fmt_subcheck_perfdata(subchecks->subcheck));
+                                asprintf(&pd_string, "%s %s", pd_string,
+                                                 fmt_subcheck_perfdata(subchecks->subcheck));
                         }
 
                         subchecks = subchecks->next;
                 }
 
+                result = sanitize_output_insitu(result);
+
                 if (pd_string != NULL && strlen(pd_string) > 0) {
                         asprintf(&result, "%s|%s", result, pd_string);
                 }
@@ -327,22 +386,58 @@ static char *generate_indentation_string(unsigned int indentation) {
 /*
  * Helper function to generate the output string of mp_subcheck
  */
-static inline char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check, unsigned int indentation) {
+static inline char *fmt_subcheck_output(mp_output_format output_format, mp_subcheck check,
+                                                                                unsigned int indentation) {
         char *result = NULL;
         mp_subcheck_list *subchecks = NULL;
 
         switch (output_format) {
-        case MP_FORMAT_MULTI_LINE:
-                asprintf(&result, "%s\\_[%s] - %s", generate_indentation_string(indentation), state_text(mp_compute_subcheck_state(check)),
-                                 check.output);
+        case MP_FORMAT_MULTI_LINE: {
+                char *tmp_string = NULL;
+                if ((tmp_string = strchr(check.output, '\n')) != NULL) {
+                        // This is a multiline string, put the correct indentation in before proceeding
+                        char *intermediate_string = "";
+                        bool have_residual_chars = false;
+
+                        while (tmp_string != NULL) {
+                                *tmp_string = '\0';
+                                asprintf(&intermediate_string, "%s%s\n%s", intermediate_string, check.output,
+                                                 generate_indentation_string(
+                                                         indentation + 1)); // one more indentation to make it look better
+
+                                if (*(tmp_string + 1) != '\0') {
+                                        check.output = tmp_string + 1;
+                                        have_residual_chars = true;
+                                } else {
+                                        // Null after the \n, so this is the end
+                                        have_residual_chars = false;
+                                        break;
+                                }
+
+                                tmp_string = strchr(check.output, '\n');
+                        }
+
+                        // add the rest (if any)
+                        if (have_residual_chars) {
+                                char *tmp = check.output;
+                                xasprintf(&check.output, "%s%s%s", intermediate_string,
+                                                  generate_indentation_string(indentation + 1), tmp);
+                        } else {
+                                check.output = intermediate_string;
+                        }
+                }
+                asprintf(&result, "%s\\_[%s] - %s", generate_indentation_string(indentation),
+                                 state_text(mp_compute_subcheck_state(check)), check.output);
 
                 subchecks = check.subchecks;
 
                 while (subchecks != NULL) {
-                        asprintf(&result, "%s\n%s", result, fmt_subcheck_output(output_format, subchecks->subcheck, indentation + 1));
+                        asprintf(&result, "%s\n%s", result,
+                                         fmt_subcheck_output(output_format, subchecks->subcheck, indentation + 1));
                         subchecks = subchecks->next;
                 }
                 return result;
+        }
         default:
                 die(STATE_UNKNOWN, "Invalid format");
         }
@@ -539,3 +634,27 @@ parsed_output_format mp_parse_output_format(char *format_string) {
 void mp_set_format(mp_output_format format) { output_format = format; }
 
 mp_output_format mp_get_format(void) { return output_format; }
+
+void mp_set_level_of_detail(mp_output_detail_level level) { level_of_detail = level; }
+
+mp_output_detail_level mp_get_level_of_detail(void) { return level_of_detail; }
+
+mp_state_enum mp_eval_ok(mp_check overall) {
+        (void)overall;
+        return STATE_OK;
+}
+
+mp_state_enum mp_eval_warning(mp_check overall) {
+        (void)overall;
+        return STATE_WARNING;
+}
+
+mp_state_enum mp_eval_critical(mp_check overall) {
+        (void)overall;
+        return STATE_CRITICAL;
+}
+
+mp_state_enum mp_eval_unknown(mp_check overall) {
+        (void)overall;
+        return STATE_UNKNOWN;
+}