#!/bin/bash
# $Header: $
# vim:nu:ai:sw=4:ts=4:
#
# Nagios check script to check for free/used memory
# Created by Wolfram Schlich <wschlich@gentoo.org>
# Distributed under the terms of the GNU General Public License v3
#
# External dependencies:
# - ip
# - grep
#

##
## nagios state specific exit codes
##

declare -i state_ok=0
declare -i state_warning=1
declare -i state_critical=2
declare -i state_unknown=3
declare -i state_dependent=4

##
## functions
##

function usage() {
	echo
	echo "Usage: ${0##*/} <-f|-u> -w WARN_VALUE -c CRIT_VALUE"
	echo
	echo "  -f: WARN when free memory < WARN_VALUE, CRIT when free memory < CRIT_VALUE"
	echo "  -u: WARN when used memory > WARN_VALUE, CRIT when used memory > CRIT_VALUE"
	echo
	echo "  WARN_VALUE: absolute value (e.g. 65536) or percentage (10%)"
	echo "  CRIT_VALUE: absolute value (e.g. 65536) or percentage (10%)"
	echo
}

##
## main()
##

## check required external binaries
if [[ ! -x "$(type -p free 2>/dev/null)" ]]; then
	echo "ERROR: 'free' not executable"
	exit ${state_unknown}
fi
if [[ ! -x "$(type -p grep 2>/dev/null)" ]]; then
	echo "ERROR: 'grep' not executable"
	exit ${state_unknown}
fi

## check args
while getopts ':w:c:fu' opt; do
	case "${opt}" in
		## warn value
		w)
			declare -i warn_value=0
			case ${OPTARG} in
				*%)
					warn_value=${OPTARG%\%}
					warn_value_type=pct
					;;
				*)
					warn_value=${OPTARG}
					warn_value_type=abs
					;;
			esac
			if [[ ${warn_value} -eq 0 ]]; then
				echo "ERROR - warn_value is invalid"
				exit ${state_unknown}
			fi
			;;
		## crit value
		c)
			declare -i crit_value=0
			case ${OPTARG} in
				*%)
					crit_value=${OPTARG%\%}
					crit_value_type=pct
					;;
				*)
					crit_value=${OPTARG}
					crit_value_type=abs
					;;
			esac
			if [[ ${crit_value} -eq 0 ]]; then
				echo "ERROR - crit_value is invalid"
				exit ${state_unknown}
			fi
			;;
		## check free memory
		f)
			if [[ -z "${check}" ]]; then
				check=free
			fi
			;;
		## check used memory
		u)
			if [[ -z "${check}" ]]; then
				check=used
			fi
			;;
		## option without a required argument
		:)
			echo "ERROR - option -${OPTARG} requires an argument"
			exit ${state_unknown}
			;;
		## unknown option
		\?)
			echo "ERROR - unknown option -${OPTARG}"
			exit ${state_unknown}
			;;
		## this should never happen
		*)
			echo "ERROR - there's an error in the matrix!"
			exit ${state_unknown}
			;;
	esac
done
## check if command line options were given at all
if [ ${OPTIND} -eq 1 ]; then
	echo "ERROR - no command line option specified"
	exit ${state_unknown}
fi
## shift off options + arguments
let OPTIND--; shift ${OPTIND}; unset OPTIND

## get free/used memory
usedkb_freekb=$(free 2>/dev/null | grep 'buffers/cache:' 2>/dev/null)
usedkb_freekb=${usedkb_freekb##*:}
set -- ${usedkb_freekb}
declare -i usedkb=0
declare -i freekb=0
declare -i totalkb=0
usedkb=${1}; shift
freekb=${1}; shift
let totalkb=${usedkb}+${freekb}
set --
declare -i usedpct=0
declare -i freepct=0
let usedpct="(${usedkb}*100)/${totalkb}"
let freepct="(${freekb}*100)/${totalkb}"

## comparisons
case ${check} in
	free)
		case ${crit_value_type} in
			abs)
				if [[ ${freekb} -lt ${crit_value} ]]; then
					echo "MEMORY CRITICAL - ${freekb}kB free < ${crit_value}kB"
					exit ${state_critical}
				fi
				;;
			pct)
				if [[ ${freepct} -lt ${crit_value} ]]; then
					echo "MEMORY CRITICAL - ${freepct}% free < ${crit_value}%"
					exit ${state_critical}
				fi
				;;
		esac
		case ${warn_value_type} in
			abs)
				if [[ ${freekb} -lt ${warn_value} ]]; then
					echo "MEMORY WARNING - ${freekb}kB free < ${warn_value}kB"
					exit ${state_warning}
				fi
				;;
			pct)
				if [[ ${freepct} -lt ${warn_value} ]]; then
					echo "MEMORY WARNING - ${freepct}% free < ${warn_value}%"
					exit ${state_warning}
				fi
				;;
		esac
		echo "MEMORY OK - ${freekb}kB / ${freepct}% free, ${usedkb}kB / ${usedpct}% used"
		exit ${state_ok}
		;;
	used)
		case ${crit_value_type} in
			abs)
				if [[ ${usedkb} -gt ${crit_value} ]]; then
					echo "MEMORY CRITICAL - ${usedkb}kB used > ${crit_value}kB"
					exit ${state_critical}
				fi
				;;
			pct)
				if [[ ${usedpct} -gt ${crit_value} ]]; then
					echo "MEMORY CRITICAL - ${usedpct}% used > ${crit_value}%"
					exit ${state_critical}
				fi
				;;
		esac
		case ${warn_value_type} in
			abs)
				if [[ ${usedkb} -gt ${warn_value} ]]; then
					echo "MEMORY WARNING - ${usedkb}kB used > ${warn_value}kB"
					exit ${state_warning}
				fi
				;;
			pct)
				if [[ ${usedpct} -gt ${warn_value} ]]; then
					echo "MEMORY WARNING - ${usedpct}% used > ${warn_value}%"
					exit ${state_warning}
				fi
				;;
		esac
		echo "MEMORY OK - ${freekb}kB / ${freepct}% free, ${usedkb}kB / ${usedpct}% used"
		exit ${state_ok}
		;;
	*)
		;;
esac

## should never reach this
echo "ERROR - there's an error in the matrix!"
exit ${state_unknown}