From 992a4555ac975285f959dd2d3228b1d71ab23123 Mon Sep 17 00:00:00 2001 From: Lorenz Kästle <12514511+RincewindsHat@users.noreply.github.com> Date: Mon, 8 Jun 2026 07:35:45 +0200 Subject: check_ups: implement modern output (#2272) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Lorenz Kästle --- plugins/check_ups.c | 367 ++++++++++++++++++++++++------------------- plugins/check_ups.d/config.h | 79 ++++++---- 2 files changed, 250 insertions(+), 196 deletions(-) diff --git a/plugins/check_ups.c b/plugins/check_ups.c index 54decce3..ac6bf574 100644 --- a/plugins/check_ups.c +++ b/plugins/check_ups.c @@ -36,6 +36,9 @@ const char *progname = "check_ups"; const char *copyright = "2000-2024"; const char *email = "devel@monitoring-plugins.org"; +#include "output.h" +#include "perfdata.h" +#include "thresholds.h" #include "common.h" #include "netutils.h" #include "utils.h" @@ -86,264 +89,273 @@ int main(int argc, char **argv) { /* set socket timeout */ alarm(socket_timeout); + mp_check overall = mp_check_init(); + + mp_subcheck sc_retrieve_status = mp_subcheck_init(); + /* get the ups status if possible */ determine_status_result query_result = determine_status(config); if (query_result.errorcode != OK) { - return STATE_CRITICAL; + xasprintf(&sc_retrieve_status.output, "%s", "Failed to retrieve status from UPS tools"); + mp_add_subcheck_to_check(&overall, sc_retrieve_status); + mp_exit(overall); } + xasprintf(&sc_retrieve_status.output, "%s", "Retrieved status from UPS tools"); + mp_add_subcheck_to_check(&overall, sc_retrieve_status); + int ups_status_flags = query_result.ups_status; int supported_options = query_result.supported_options; // Exit result - mp_state_enum result = STATE_UNKNOWN; - char *message = NULL; + mp_subcheck sc_ups_status = mp_subcheck_init(); if (supported_options & UPS_STATUS) { - char *ups_status = strdup(""); - result = STATE_OK; + mp_state_enum ups_state_result = STATE_OK; if (ups_status_flags & UPSSTATUS_OFF) { - xasprintf(&ups_status, "Off"); - result = STATE_CRITICAL; + xasprintf(&sc_ups_status.output, "Off"); + ups_state_result = STATE_CRITICAL; } else if ((ups_status_flags & (UPSSTATUS_OB | UPSSTATUS_LB)) == (UPSSTATUS_OB | UPSSTATUS_LB)) { - xasprintf(&ups_status, _("On Battery, Low Battery")); - result = STATE_CRITICAL; + xasprintf(&sc_ups_status.output, _("On Battery, Low Battery")); + ups_state_result = STATE_CRITICAL; } else { if (ups_status_flags & UPSSTATUS_OL) { - xasprintf(&ups_status, "%s%s", ups_status, _("Online")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _("Online")); } if (ups_status_flags & UPSSTATUS_OB) { - xasprintf(&ups_status, "%s%s", ups_status, _("On Battery")); - result = max_state(result, STATE_WARNING); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _("On Battery")); + ups_state_result = max_state(ups_state_result, STATE_WARNING); } if (ups_status_flags & UPSSTATUS_LB) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Low Battery")); - result = max_state(result, STATE_WARNING); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Low Battery")); + ups_state_result = max_state(ups_state_result, STATE_WARNING); } if (ups_status_flags & UPSSTATUS_CAL) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Calibrating")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Calibrating")); } if (ups_status_flags & UPSSTATUS_RB) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Replace Battery")); - result = max_state(result, STATE_WARNING); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, + _(", Replace Battery")); + ups_state_result = max_state(ups_state_result, STATE_WARNING); } if (ups_status_flags & UPSSTATUS_BYPASS) { - xasprintf(&ups_status, "%s%s", ups_status, _(", On Bypass")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", On Bypass")); // Bypassing the battery is likely a bad thing - result = STATE_CRITICAL; + ups_state_result = STATE_CRITICAL; } if (ups_status_flags & UPSSTATUS_OVER) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Overload")); - result = max_state(result, STATE_WARNING); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Overload")); + ups_state_result = max_state(ups_state_result, STATE_WARNING); } if (ups_status_flags & UPSSTATUS_TRIM) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Trimming")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Trimming")); } if (ups_status_flags & UPSSTATUS_BOOST) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Boosting")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Boosting")); } if (ups_status_flags & UPSSTATUS_CHRG) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Charging")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Charging")); } if (ups_status_flags & UPSSTATUS_DISCHRG) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Discharging")); - result = max_state(result, STATE_WARNING); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Discharging")); + ups_state_result = max_state(ups_state_result, STATE_WARNING); } if (ups_status_flags & UPSSTATUS_ALARM) { - xasprintf(&ups_status, "%s%s", ups_status, _(", ALARM")); - result = STATE_CRITICAL; + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", ALARM")); + ups_state_result = STATE_CRITICAL; } if (ups_status_flags & UPSSTATUS_UNKNOWN) { - xasprintf(&ups_status, "%s%s", ups_status, _(", Unknown")); + xasprintf(&sc_ups_status.output, "%s%s", sc_ups_status.output, _(", Unknown")); } } - xasprintf(&message, "%sStatus=%s ", message, ups_status); + xasprintf(&sc_ups_status.output, "Status: %s", sc_ups_status.output); + sc_ups_status = mp_set_subcheck_state(sc_ups_status, ups_state_result); } int res; char temp_buffer[MAX_INPUT_BUFFER]; - char *performance_data = strdup(""); /* get the ups utility voltage if possible */ + mp_subcheck sc_voltage = mp_subcheck_init(); + sc_voltage = mp_set_subcheck_default_state(sc_voltage, STATE_OK); res = get_ups_variable("input.voltage", temp_buffer, config); if (res == NOSUCHVAR) { supported_options &= ~UPS_UTILITY; } else if (res != OK) { - return STATE_CRITICAL; + sc_voltage = mp_set_subcheck_state(sc_voltage, STATE_CRITICAL); + xasprintf(&sc_voltage.output, "%s", "Failed to detect voltage"); + mp_add_subcheck_to_check(&overall, sc_voltage); + mp_exit(overall); } else { supported_options |= UPS_UTILITY; double ups_utility_voltage = 0.0; ups_utility_voltage = atof(temp_buffer); - xasprintf(&message, "%sUtility=%3.1fV ", message, ups_utility_voltage); + xasprintf(&sc_voltage.output, "Utility: %3.1fV", ups_utility_voltage); double ups_utility_deviation = 0.0; - if (ups_utility_voltage > 120.0) { ups_utility_deviation = 120.0 - ups_utility_voltage; } else { ups_utility_deviation = ups_utility_voltage - 120.0; } - - if (config.check_variable == UPS_UTILITY) { - if (config.check_crit && ups_utility_deviation >= config.critical_value) { - result = STATE_CRITICAL; - } else if (config.check_warn && ups_utility_deviation >= config.warning_value) { - result = max_state(result, STATE_WARNING); - } - xasprintf(&performance_data, "%s", - perfdata("voltage", (long)(1000 * ups_utility_voltage), "mV", - config.check_warn, (long)(1000 * config.warning_value), - config.check_crit, (long)(1000 * config.critical_value), true, 0, - false, 0)); - } else { - xasprintf(&performance_data, "%s", - perfdata("voltage", (long)(1000 * ups_utility_voltage), "mV", false, 0, false, - 0, true, 0, false, 0)); - } + mp_perfdata pd_voltage_deviation = perfdata_init(); + pd_voltage_deviation.label = "voltage_deviation"; + pd_voltage_deviation.uom = "V"; + pd_voltage_deviation.value = mp_create_pd_value(ups_utility_deviation); + + pd_voltage_deviation = + mp_pd_set_thresholds(pd_voltage_deviation, config.utility_thresholds); + sc_voltage = mp_set_subcheck_state(sc_voltage, mp_get_pd_status(pd_voltage_deviation)); + mp_add_perfdata_to_subcheck(&sc_voltage, pd_voltage_deviation); + + mp_perfdata pd_voltage = perfdata_init(); + pd_voltage.label = "voltage"; + pd_voltage.uom = "V"; + pd_voltage.value = mp_create_pd_value(ups_utility_voltage); + mp_add_perfdata_to_subcheck(&sc_voltage, pd_voltage); + + mp_add_subcheck_to_check(&overall, sc_voltage); } /* get the ups battery percent if possible */ + mp_subcheck sc_battery_charge = mp_subcheck_init(); + sc_battery_charge = mp_set_subcheck_default_state(sc_battery_charge, STATE_OK); res = get_ups_variable("battery.charge", temp_buffer, config); if (res == NOSUCHVAR) { supported_options &= ~UPS_BATTPCT; } else if (res != OK) { - return STATE_CRITICAL; + sc_battery_charge = mp_set_subcheck_state(sc_battery_charge, STATE_CRITICAL); + xasprintf(&sc_battery_charge.output, "%s", "Failed to detect battery charge"); + mp_add_subcheck_to_check(&overall, sc_battery_charge); + mp_exit(overall); } else { supported_options |= UPS_BATTPCT; - double ups_battery_percent = 0.0; - ups_battery_percent = atof(temp_buffer); - xasprintf(&message, "%sBatt=%3.1f%% ", message, ups_battery_percent); + double ups_battery_percent = atof(temp_buffer); + xasprintf(&sc_battery_charge.output, "Battery charge: %3.1f%%", ups_battery_percent); - if (config.check_variable == UPS_BATTPCT) { - if (config.check_crit && ups_battery_percent <= config.critical_value) { - result = STATE_CRITICAL; - } else if (config.check_warn && ups_battery_percent <= config.warning_value) { - result = max_state(result, STATE_WARNING); - } - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("battery", (long)ups_battery_percent, "%", config.check_warn, - (long)(config.warning_value), config.check_crit, - (long)(config.critical_value), true, 0, true, 100)); - } else { - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("battery", (long)ups_battery_percent, "%", false, 0, false, 0, true, - 0, true, 100)); - } + mp_perfdata pd_battery_charge = perfdata_init(); + pd_battery_charge = mp_set_pd_value(pd_battery_charge, ups_battery_percent); + pd_battery_charge.label = "battery"; + pd_battery_charge.uom = "%"; + pd_battery_charge = mp_pd_set_thresholds(pd_battery_charge, config.battery_thresholds); + mp_add_perfdata_to_subcheck(&sc_battery_charge, pd_battery_charge); + + sc_battery_charge = + mp_set_subcheck_state(sc_battery_charge, mp_get_pd_status(pd_battery_charge)); + + // if (config.check_crit && ups_battery_percent <= config.critical_value) { + // } else if (config.check_warn && ups_battery_percent <= config.warning_value) { + mp_add_subcheck_to_check(&overall, sc_battery_charge); } /* get the ups load percent if possible */ res = get_ups_variable("ups.load", temp_buffer, config); + mp_subcheck sc_load_percent = mp_subcheck_init(); + mp_set_subcheck_default_state(sc_load_percent, STATE_OK); if (res == NOSUCHVAR) { supported_options &= ~UPS_LOADPCT; } else if (res != OK) { - return STATE_CRITICAL; + sc_load_percent = mp_set_subcheck_state(sc_load_percent, STATE_CRITICAL); + xasprintf(&sc_load_percent.output, "%s", "Failed to detect load"); + mp_add_subcheck_to_check(&overall, sc_load_percent); + mp_exit(overall); } else { supported_options |= UPS_LOADPCT; - double ups_load_percent = 0.0; - ups_load_percent = atof(temp_buffer); - xasprintf(&message, "%sLoad=%3.1f%% ", message, ups_load_percent); + double ups_load_percent = atof(temp_buffer); + xasprintf(&sc_load_percent.output, "Load :%3.1f%% ", ups_load_percent); - if (config.check_variable == UPS_LOADPCT) { - if (config.check_crit && ups_load_percent >= config.critical_value) { - result = STATE_CRITICAL; - } else if (config.check_warn && ups_load_percent >= config.warning_value) { - result = max_state(result, STATE_WARNING); - } - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("load", (long)ups_load_percent, "%", config.check_warn, - (long)(config.warning_value), config.check_crit, - (long)(config.critical_value), true, 0, true, 100)); - } else { - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("load", (long)ups_load_percent, "%", false, 0, false, 0, true, 0, - true, 100)); - } + mp_perfdata pd_load_percent = perfdata_init(); + pd_load_percent.label = "load"; + pd_load_percent.uom = "%"; + pd_load_percent.value = mp_create_pd_value(ups_load_percent); + pd_load_percent = mp_pd_set_thresholds(pd_load_percent, config.load_thresholds); + + sc_load_percent = mp_set_subcheck_state(sc_load_percent, mp_get_pd_status(pd_load_percent)); + + // if (config.check_crit && ups_load_percent >= config.critical_value) { + // } else if (config.check_warn && ups_load_percent >= config.warning_value) { } /* get the ups temperature if possible */ res = get_ups_variable("ups.temperature", temp_buffer, config); + mp_subcheck sc_temperature = mp_subcheck_init(); + sc_temperature = mp_set_subcheck_default_state(sc_temperature, STATE_OK); if (res == NOSUCHVAR) { supported_options &= ~UPS_TEMP; } else if (res != OK) { - return STATE_CRITICAL; + sc_temperature = mp_set_subcheck_state(sc_temperature, STATE_CRITICAL); + xasprintf(&sc_temperature.output, "%s", "Failed to detect temperature"); + mp_add_subcheck_to_check(&overall, sc_temperature); + mp_exit(overall); } else { supported_options |= UPS_TEMP; - double ups_temperature = 0.0; - char *tunits; + double ups_temperature = atof(temp_buffer); + mp_perfdata pd_temperature = perfdata_init(); + pd_temperature.label = "temp"; if (config.temp_output_c) { - tunits = "degC"; - ups_temperature = atof(temp_buffer); - xasprintf(&message, "%sTemp=%3.1fC", message, ups_temperature); + xasprintf(&sc_temperature.output, "Temperature: %3.1fC", ups_temperature); + pd_temperature.uom = "C"; } else { - tunits = "degF"; - ups_temperature = (atof(temp_buffer) * 1.8) + 32; - xasprintf(&message, "%sTemp=%3.1fF", message, ups_temperature); + ups_temperature = (ups_temperature * 1.8) + 32; + xasprintf(&sc_temperature.output, "Temperature: %3.1fF", ups_temperature); + pd_temperature.uom = "F"; } - if (config.check_variable == UPS_TEMP) { - if (config.check_crit && ups_temperature >= config.critical_value) { - result = STATE_CRITICAL; - } else if (config.check_warn && ups_temperature >= config.warning_value) { - result = max_state(result, STATE_WARNING); - } - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("temp", (long)ups_temperature, tunits, config.check_warn, - (long)(config.warning_value), config.check_crit, - (long)(config.critical_value), true, 0, false, 0)); - } else { - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("temp", (long)ups_temperature, tunits, false, 0, false, 0, true, 0, - false, 0)); - } + pd_temperature = mp_set_pd_value(pd_temperature, ups_temperature); + pd_temperature = mp_pd_set_thresholds(pd_temperature, config.temperature_thresholds); + + sc_temperature = mp_set_subcheck_state(sc_temperature, mp_get_pd_status(pd_temperature)); + + // if (config.check_crit && ups_temperature >= config.critical_value) { + // } else if (config.check_warn && ups_temperature >= config.warning_value) { } /* get the ups real power if possible */ res = get_ups_variable("ups.realpower", temp_buffer, config); + mp_subcheck sc_real_power = mp_subcheck_init(); + sc_real_power = mp_set_subcheck_default_state(sc_real_power, STATE_OK); if (res == NOSUCHVAR) { supported_options &= ~UPS_REALPOWER; } else if (res != OK) { - return STATE_CRITICAL; + sc_real_power = mp_set_subcheck_state(sc_real_power, STATE_CRITICAL); + xasprintf(&sc_real_power.output, "%s", "Failed to detect real power"); + mp_add_subcheck_to_check(&overall, sc_real_power); + mp_exit(overall); } else { supported_options |= UPS_REALPOWER; - double ups_realpower = 0.0; - ups_realpower = atof(temp_buffer); - xasprintf(&message, "%sReal power=%3.1fW ", message, ups_realpower); - - if (config.check_variable == UPS_REALPOWER) { - if (config.check_crit && ups_realpower >= config.critical_value) { - result = STATE_CRITICAL; - } else if (config.check_warn && ups_realpower >= config.warning_value) { - result = max_state(result, STATE_WARNING); - } - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("realpower", (long)ups_realpower, "W", config.check_warn, - (long)(config.warning_value), config.check_crit, - (long)(config.critical_value), true, 0, false, 0)); - } else { - xasprintf(&performance_data, "%s %s", performance_data, - perfdata("realpower", (long)ups_realpower, "W", false, 0, false, 0, true, 0, - false, 0)); - } + + double ups_realpower = atof(temp_buffer); + xasprintf(&sc_temperature.output, "Real power: %3.1fW ", ups_realpower); + + mp_perfdata pd_real_power = perfdata_init(); + pd_real_power.label = "realpower"; + pd_real_power = mp_set_pd_value(pd_real_power, ups_realpower); + pd_real_power.uom = "W"; + pd_real_power = mp_pd_set_thresholds(pd_real_power, config.real_power_thresholds); + + // if (config.check_crit && ups_realpower >= config.critical_value) { + // } else if (config.check_warn && ups_realpower >= config.warning_value) { } /* if the UPS does not support any options we are looking for, report an * error */ if (supported_options == UPS_NONE) { - result = STATE_CRITICAL; - xasprintf(&message, _("UPS does not support any available options\n")); + mp_subcheck sc_any_option = mp_subcheck_init(); + sc_any_option = mp_set_subcheck_state(sc_any_option, STATE_CRITICAL); + xasprintf(&sc_any_option.output, _("UPS does not support any available options\n")); + mp_add_subcheck_to_check(&overall, sc_any_option); } /* reset timeout */ alarm(0); - printf("UPS %s - %s|%s\n", state_text(result), message, performance_data); - exit(result); + mp_exit(overall); } /* determines what options are supported by the UPS */ @@ -502,26 +514,27 @@ check_ups_config_wrapper process_arguments(int argc, char **argv) { return result; } - int c; - for (c = 1; c < argc; c++) { - if (strcmp("-to", argv[c]) == 0) { - strcpy(argv[c], "-t"); - } else if (strcmp("-wt", argv[c]) == 0) { - strcpy(argv[c], "-w"); - } else if (strcmp("-ct", argv[c]) == 0) { - strcpy(argv[c], "-c"); + for (int i = 1; i < argc; i++) { + if (strcmp("-to", argv[i]) == 0) { + strcpy(argv[i], "-t"); + } else if (strcmp("-wt", argv[i]) == 0) { + strcpy(argv[i], "-w"); + } else if (strcmp("-ct", argv[i]) == 0) { + strcpy(argv[i], "-c"); } } int option = 0; - while (1) { - c = getopt_long(argc, argv, "hVTH:u:p:v:c:w:t:", longopts, &option); + ups_test_type test_selection = UPS_NONE; + mp_thresholds tmp_thr = mp_thresholds_init(); + while (true) { + int counter = getopt_long(argc, argv, "hVTH:u:p:v:c:w:t:", longopts, &option); - if (c == -1 || c == EOF) { + if (counter == -1 || counter == EOF) { break; } - switch (c) { + switch (counter) { case '?': /* help */ usage5(); case 'H': /* hostname */ @@ -545,33 +558,41 @@ check_ups_config_wrapper process_arguments(int argc, char **argv) { usage2(_("Port must be a positive integer"), optarg); } break; - case 'c': /* critical time threshold */ + case 'c': /* critical voltage threshold */ if (is_intnonneg(optarg)) { - result.config.critical_value = atoi(optarg); - result.config.check_crit = true; + mp_range_parsed tmp = mp_parse_range_string(optarg); + if (tmp.error != MP_PARSING_SUCCESS) { + usage2(_("Critical voltage must be a valid range expression"), optarg); + } else { + tmp_thr = mp_thresholds_set_crit(tmp_thr, tmp.range); + } } else { - usage2(_("Critical time must be a positive integer"), optarg); + usage2(_("Critical voltage must be a positive integer"), optarg); } break; - case 'w': /* warning time threshold */ + case 'w': /* warning voltage threshold */ if (is_intnonneg(optarg)) { - result.config.warning_value = atoi(optarg); - result.config.check_warn = true; + mp_range_parsed tmp = mp_parse_range_string(optarg); + if (tmp.error != MP_PARSING_SUCCESS) { + usage2(_("Warning voltage must be a valid range expression"), optarg); + } else { + tmp_thr = mp_thresholds_set_warn(tmp_thr, tmp.range); + } } else { - usage2(_("Warning time must be a positive integer"), optarg); + usage2(_("Warning voltage must be a positive integer"), optarg); } break; case 'v': /* variable */ if (!strcmp(optarg, "LINE")) { - result.config.check_variable = UPS_UTILITY; + test_selection = UPS_UTILITY; } else if (!strcmp(optarg, "TEMP")) { - result.config.check_variable = UPS_TEMP; + test_selection = UPS_TEMP; } else if (!strcmp(optarg, "BATTPCT")) { - result.config.check_variable = UPS_BATTPCT; + test_selection = UPS_BATTPCT; } else if (!strcmp(optarg, "LOADPCT")) { - result.config.check_variable = UPS_LOADPCT; + test_selection = UPS_LOADPCT; } else if (!strcmp(optarg, "REALPOWER")) { - result.config.check_variable = UPS_REALPOWER; + test_selection = UPS_REALPOWER; } else { usage2(_("Unrecognized UPS variable"), optarg); } @@ -604,6 +625,23 @@ check_ups_config_wrapper process_arguments(int argc, char **argv) { result.config.server_address = strdup("127.0.0.1"); } + switch (test_selection) { + case UPS_UTILITY: + result.config.utility_thresholds = tmp_thr; + case UPS_BATTPCT: + result.config.battery_thresholds = tmp_thr; + case UPS_LOADPCT: + result.config.load_thresholds = tmp_thr; + case UPS_REALPOWER: + result.config.real_power_thresholds = tmp_thr; + case UPS_TEMP: + result.config.temperature_thresholds = tmp_thr; + case UPS_NONE: + case UPS_STATUS: + default: { + } + } + return validate_arguments(result); } @@ -647,7 +685,10 @@ void print_help(void) { printf(" %s %s\n", _("Valid values for STRING are"), "LINE, TEMP, BATTPCT, LOADPCT or REALPOWER"); - printf(UT_WARN_CRIT); + printf(" %s\n", "-w, --warning"); + printf(" %s\n", _("Set warning threshold on metric selected via --variable")); + printf(" %s\n", "-c, --critical"); + printf(" %s\n", _("Set critical threshold on metric selected via --variable")); printf(UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); diff --git a/plugins/check_ups.d/config.h b/plugins/check_ups.d/config.h index e05edceb..900363fd 100644 --- a/plugins/check_ups.d/config.h +++ b/plugins/check_ups.d/config.h @@ -1,31 +1,36 @@ #pragma once #include "../../config.h" +#include "thresholds.h" #include -#define UPS_NONE 0 /* no supported options */ -#define UPS_UTILITY 1 /* supports utility line */ -#define UPS_BATTPCT 2 /* supports percent battery remaining */ -#define UPS_STATUS 4 /* supports UPS status */ -#define UPS_TEMP 8 /* supports UPS temperature */ -#define UPS_LOADPCT 16 /* supports load percent */ -#define UPS_REALPOWER 32 /* supports real power */ - -#define UPSSTATUS_NONE 0 -#define UPSSTATUS_OFF 1 -#define UPSSTATUS_OL 2 -#define UPSSTATUS_OB 4 -#define UPSSTATUS_LB 8 -#define UPSSTATUS_CAL 16 -#define UPSSTATUS_RB 32 /*Replace Battery */ -#define UPSSTATUS_BYPASS 64 -#define UPSSTATUS_OVER 128 -#define UPSSTATUS_TRIM 256 -#define UPSSTATUS_BOOST 512 -#define UPSSTATUS_CHRG 1024 -#define UPSSTATUS_DISCHRG 2048 -#define UPSSTATUS_UNKNOWN 4096 -#define UPSSTATUS_ALARM 8192 +typedef enum { + UPS_NONE = 0, /* no supported options */ + UPS_UTILITY = 1, /* supports utility line */ + UPS_BATTPCT = 2, /* supports percent battery remaining */ + UPS_STATUS = 4, /* supports UPS status */ + UPS_TEMP = 8, /* supports UPS temperature */ + UPS_LOADPCT = 16, /* supports load percent */ + UPS_REALPOWER = 32, /* supports real power */ +} ups_test_type; + +typedef enum { + UPSSTATUS_NONE = 0, + UPSSTATUS_OFF = 1, + UPSSTATUS_OL = 2, + UPSSTATUS_OB = 4, + UPSSTATUS_LB = 8, + UPSSTATUS_CAL = 16, + UPSSTATUS_RB = 32, /*Replace Battery */ + UPSSTATUS_BYPASS = 64, + UPSSTATUS_OVER = 128, + UPSSTATUS_TRIM = 256, + UPSSTATUS_BOOST = 512, + UPSSTATUS_CHRG = 1024, + UPSSTATUS_DISCHRG = 2048, + UPSSTATUS_UNKNOWN = 4096, + UPSSTATUS_ALARM = 8192, +} ups_status_type; enum { PORT = 3493 @@ -35,20 +40,28 @@ typedef struct ups_config { unsigned int server_port; char *server_address; char *ups_name; - double warning_value; - double critical_value; - bool check_warn; - bool check_crit; - int check_variable; + + mp_thresholds utility_thresholds; + mp_thresholds battery_thresholds; + mp_thresholds load_thresholds; + mp_thresholds real_power_thresholds; + mp_thresholds temperature_thresholds; + bool temp_output_c; } check_ups_config; check_ups_config check_ups_config_init(void) { - check_ups_config tmp = {0}; - tmp.server_port = PORT; - tmp.server_address = NULL; - tmp.ups_name = NULL; - tmp.check_variable = UPS_NONE; + check_ups_config tmp = { + .server_port = PORT, + .server_address = NULL, + .ups_name = NULL, + + .utility_thresholds = mp_thresholds_init(), + .battery_thresholds = mp_thresholds_init(), + .load_thresholds = mp_thresholds_init(), + .real_power_thresholds = mp_thresholds_init(), + .temperature_thresholds = mp_thresholds_init(), + }; return tmp; } -- cgit v1.2.3-74-g34f1