monitoring-plugins/lib/utils_base.c

/*****************************************************************************
*
* utils_base.c
*
* License: GPL
* Copyright (c) 2006 Nagios Plugins Development Team
*
* Last Modified: $Date$
*
* 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/>.
* 
* $Id$
*
*****************************************************************************/

#include "common.h"
#include <stdarg.h>
#include "utils_base.h"

void
die (int result, const char *fmt, ...)
{
	va_list ap;
	va_start (ap, fmt);
	vprintf (fmt, ap);
	va_end (ap);
	exit (result);
}

void set_range_start (range *this, double value) {
	this->start = value;
	this->start_infinity = FALSE;
}

void set_range_end (range *this, double value) {
	this->end = value;
	this->end_infinity = FALSE;
}

range
*parse_range_string (char *str) {
	range *temp_range;
	double start;
	double end;
	char *end_str;

	temp_range = (range *) malloc(sizeof(range));

	/* Set defaults */
	temp_range->start = 0;
	temp_range->start_infinity = FALSE;
	temp_range->end = 0;
	temp_range->end_infinity = TRUE;
	temp_range->alert_on = OUTSIDE;

	if (str[0] == '@') {
		temp_range->alert_on = INSIDE;
		str++;
	}

	end_str = index(str, ':');
	if (end_str != NULL) {
		if (str[0] == '~') {
			temp_range->start_infinity = TRUE;
		} else {
			start = strtod(str, NULL);	/* Will stop at the ':' */
			set_range_start(temp_range, start);
		}
		end_str++;		/* Move past the ':' */
	} else {
		end_str = str;
	}
	end = strtod(end_str, NULL);
	if (strcmp(end_str, "") != 0) {
		set_range_end(temp_range, end);
	}

	if (temp_range->start_infinity == TRUE || 
		temp_range->end_infinity == TRUE ||
		temp_range->start <= temp_range->end) {
		return temp_range;
	}
	free(temp_range);
	return NULL;
}

/* New range string parsing routines, for the v2 thresholds syntax */
/* Returns range if OK, otherwise errors. Sets utils_errno if error */
int utils_errno;
range *
_parse_range_string_v2 (char *str) {
	range *temp_range;
	double start;
	double end;
	char *end_str;

	temp_range = (range *) malloc(sizeof(range));

	/* Initialise */
	temp_range->start = 0;
	temp_range->start_infinity = FALSE;
	temp_range->end = 0;
	temp_range->end_infinity = FALSE;
	temp_range->alert_on = INSIDE;

	if (str[0] == '^') {
		temp_range->alert_on = OUTSIDE;
		str++;
	}

	end_str = index(str, ':');
	if (end_str == NULL) {
		utils_errno = NP_RANGE_MISSING_COLON;
		free(temp_range);
		temp_range = NULL;
		return NULL;
	}
	end_str++;
	if (str[0] == ':') {
		temp_range->start_infinity = TRUE;
	} else {
		start = strtod(str, NULL);	/* Will stop at ':' */
		set_range_start(temp_range, start);
	}
	if (strcmp(end_str, "") != 0) {
		end = strtod(end_str, NULL);
		set_range_end(temp_range, end);
	} else {
		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;
	}
	free(temp_range);
	temp_range = NULL;
	utils_errno = NP_RANGE_UNPARSEABLE;
	return NULL;
}

void
_die_on_parse_error(int errorcode) {
	switch (errorcode) {
	case NP_RANGE_UNPARSEABLE:
		die(STATE_UNKNOWN, _("Range format incorrect\n"));
	case NP_WARN_WITHIN_CRIT:
		die(STATE_UNKNOWN, _("Warning level is a subset of critical and will not be alerted\n"));
	case NP_RANGE_MISSING_COLON:
		die(STATE_UNKNOWN, _("Range is missing a colon\n"));
	case NP_MEMORY_ERROR:
		die(STATE_UNKNOWN, _("Memory error\n"));
	}
}

thresholds
*_parse_thresholds_string(char *string) {
	thresholds *temp_thresholds = NULL;
	char *separator = NULL;
	char *temp_string = NULL;
	range *temp_range = NULL;
	int rc;

	temp_thresholds = malloc(sizeof(temp_thresholds));
	if (temp_thresholds == NULL) {
		utils_errno = NP_MEMORY_ERROR;
		return NULL;
	}

	temp_thresholds->warning = NULL;
	temp_thresholds->critical = NULL;

	if (string == NULL || strcmp(string, "") == 0)
		return temp_thresholds;

	if((temp_string = strdup(string)) == NULL) {
		free(temp_thresholds);
		utils_errno = NP_MEMORY_ERROR;
		return NULL;
	}

	/* Find critical part and parse the range */
	separator = index(temp_string, '/');
	if (separator) {
		*separator = '\0';
		separator++;
	}
	if ((strcmp(temp_string, "") != 0) && (temp_range = _parse_range_string_v2( temp_string )) == NULL) {
		free(temp_thresholds);
		free(temp_string);
		/* utils_errno already set */
		return NULL;
	}
	temp_thresholds->critical = temp_range;

	if (separator == NULL || strcmp(separator, "") == 0) {
		return temp_thresholds;
	}
	/* UOM not processed yet */
	if(( temp_range = _parse_range_string_v2( separator )) == NULL) {
		free(temp_thresholds);
		free(temp_string);
		return NULL;
	}
	temp_thresholds->warning = temp_range;
	return temp_thresholds;
}

thresholds
*parse_thresholds_string(char *string)
{
	thresholds *my_threshold;
	if ((my_threshold = _parse_thresholds_string(string)) == NULL)
		_die_on_parse_error(utils_errno);
	return my_threshold;
}

/* returns 0 if okay, otherwise 1 */
int
_set_thresholds(thresholds **my_thresholds, char *warn_string, char *critical_string)
{
	thresholds *temp_thresholds = NULL;

	temp_thresholds = malloc(sizeof(temp_thresholds));

	temp_thresholds->warning = NULL;
	temp_thresholds->critical = NULL;

	if (warn_string != NULL) {
		if ((temp_thresholds->warning = parse_range_string(warn_string)) == NULL) {
			return NP_RANGE_UNPARSEABLE;
		}
	}
	if (critical_string != NULL) {
		if ((temp_thresholds->critical = parse_range_string(critical_string)) == NULL) {
			return NP_RANGE_UNPARSEABLE;
		}
	}

	*my_thresholds = temp_thresholds;

	return 0;
}

void
set_thresholds(thresholds **my_thresholds, char *warn_string, char *critical_string)
{
	switch (_set_thresholds(my_thresholds, warn_string, critical_string)) {
	case 0:
		return;
	case NP_RANGE_UNPARSEABLE:
		die(STATE_UNKNOWN, _("Range format incorrect"));
	case NP_WARN_WITHIN_CRIT:
		die(STATE_UNKNOWN, _("Warning level is a subset of critical and will not be alerted"));
		break;
	}
}

void print_thresholds(thresholds *my_threshold) {
	if (! my_threshold) {
		printf("Threshold not set");
	} else {
		if (my_threshold->warning) {
			printf("Warning: start=%g end=%g; ", my_threshold->warning->start, my_threshold->warning->end);
		} else {
			printf("Warning not set; ");
		}
		if (my_threshold->critical) {
			printf("Critical: start=%g end=%g", my_threshold->critical->start, my_threshold->critical->end);
		} else {
			printf("Critical not set");
		}
	}
	printf("\n");
}

/* Returns TRUE if alert should be raised based on the range */
int
check_range(double value, range *my_range)
{
	int no = FALSE;
	int yes = TRUE;
	
	if (my_range->alert_on == INSIDE) {
		no = TRUE;
		yes = 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) {
		if (my_range->start <= value) {
			return no;
		} else {
			return yes;
		}
	} else if (my_range->start_infinity == TRUE && my_range->end_infinity == FALSE) {
		if (value <= my_range->end) {
			return no;
		} else {
			return yes;
		}
	} else {
		return no;
	}
}

/* Returns status */
int
get_status(double value, thresholds *my_thresholds)
{
	if (my_thresholds->critical != NULL) {
		if (check_range(value, my_thresholds->critical) == TRUE) {
			return STATE_CRITICAL;
		}
	}
	if (my_thresholds->warning != NULL) {
		if (check_range(value, my_thresholds->warning) == TRUE) {
			return STATE_WARNING;
		}
	}
	return STATE_OK;
}

char *np_escaped_string (const char *string) {
	char *data;
	int i, j=0;
	data = strdup(string);
	for (i=0; data[i]; i++) {
		if (data[i] == '\\') {
			switch(data[++i]) {
				case 'n':
					data[j++] = '\n';
					break;
				case 'r':
					data[j++] = '\r';
					break;
				case 't':
					data[j++] = '\t';
					break;
				case '\\':
					data[j++] = '\\';
					break;
				default:
					data[j++] = data[i];
			}
		} else {
			data[j++] = data[i];
		}
	}
	data[j] = '\0';
	return data;
}

int np_check_if_root(void) { return (geteuid() == 0); }

int np_warn_if_not_root(void) {
	int status = np_check_if_root();
	if(!status) {
		printf(_("Warning: "));
		printf(_("This plugin must be either run as root or setuid root.\n"));
		printf(_("To run as root, you can use a tool like sudo.\n"));
		printf(_("To set the setuid permissions, use the command:\n"));
		/* XXX could we use something like progname? */
		printf("\tchmod u+s yourpluginfile\n");
	}
	return status;
}