Checks remote processes via SNMP (David Alden)

git-svn-id: https://nagiosplug.svn.sourceforge.net/svnroot/nagiosplug/nagiosplug/trunk@801 f882894a-f735-0410-b71e-b25c423dba1c

1 files changed, 590 insertions, 0 deletions

diff --git a/contrib/check_snmp_procs.pl b/contrib/check_snmp_procs.pl
new file mode 100644
index 00000000..678f6d54
--- /dev/null
+++ b/contrib/check_snmp_procs.pl
@@ -0,0 +1,590 @@
+#!/usr/bin/perl -w
+#
+# check_snmp_procs.pl
+#    Nagios script to check processes on remote host via snmp
+#
+# 
+# Copyright (c) 2003 David Alden
+#
+# 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 2
+# 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, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#
+# History
+# -------
+#  02-25-2003 - Dave Alden <alden@math.ohio-state.edu>
+#    Initial creation
+#
+#
+# TODO
+# ----
+#    make it work with snmp version 3
+#    Suggestions???
+#
+#use strict;
+use Getopt::Long;
+use Net::SNMP qw (oid_lex_sort oid_base_match SNMP_VERSION_1);
+use lib utils.pm;
+use utils qw(%ERRORS &print_revision &support &usage);
+
+my $PROGNAME="check_snmp_procs";
+my $REVISION="1.0";
+
+#
+my $opt_authprotocol;
+my $opt_authpassword;
+my $opt_community    = 'ma4read';
+my $opt_critical;
+my $opt_help;
+my $opt_host         = 'euler';
+my $opt_oidname      = 'hrSWRunName';
+my $opt_port         = 161;
+my $opt_privpassword;
+my $opt_regexp       = 0;
+my $opt_snmp_version = '2c';
+my $opt_timeout      = $utils::TIMEOUT;
+my $opt_username;
+my $opt_verbose;
+my $opt_version;
+my $opt_wanted_procs;
+my $opt_warning;
+
+#
+my $max_no_processes = 999999;
+my $session;
+my $error;
+my $no_procs;
+my $exit_status;
+
+#
+my @wanted_procs;
+my %current_process_list;
+
+#
+my %OIDS = (hrSWRunName => '1.3.6.1.2.1.25.4.2.1.2',
+	    hrSWRunPath => '1.3.6.1.2.1.25.4.2.1.4');
+
+my %OIDS_L = (hrSWRunName => length($OIDS{hrSWRunName}),
+	      hrSWRunPath => length($OIDS{hrSWRunPath}));
+
+#
+$ENV{'PATH'}='';
+$ENV{'BASH_ENV'}=''; 
+$ENV{'ENV'}='';
+
+#
+Getopt::Long::Configure('bundling');
+if (GetOptions(
+	"a:s" => \$opt_authprotocol,  "authprotocol:s"  => \$opt_authprotocol,
+	"A:s" => \$opt_authpassword,  "authpassword:s"  => \$opt_authpassword,
+	"C:s" => \$opt_community,     "community:s"     => \$opt_community,
+        "c:s" => \$opt_critical,      "critical:s"      => \$opt_critical,
+	"h"   => \$opt_help,          "help"	        => \$opt_help,
+	"H:s" => \$opt_host,          "hostname:s"      => \$opt_host,
+	"o:s" => \$opt_oidname,       "oidname:s"       => \$opt_oidname,
+	"P=s" => \$opt_password,      "password=s"      => \$opt_password,
+	"p=i" => \$opt_port,          "port=i"          => \$opt_port,
+	"r"   => \$opt_regexp,        "regexp"          => \$opt_regexp,
+	"S"   => \$opt_snmp_version,  "snmpversion"     => \$opt_snmp_version,
+	"t=i" => \$opt_timeout,       "timeout=i"       => \$opt_timeout,
+	"U=s" => \$opt_username,      "username=s"      => \$opt_username,
+	"v"   => \$opt_verbose,       "verbose"         => \$opt_verbose,
+	"V"   => \$opt_version,       "version"         => \$opt_version,
+	"N=s" => \$opt_wanted_procs,  "names=s"         => \$opt_wanted_procs,
+        "w:s" => \$opt_warning,       "warning:s"       => \$opt_warning)
+    == 0) {
+	print_usage();
+	exit $ERRORS{'UNKNOWN'};
+}
+
+if ($opt_version) {
+	print_revision($PROGNAME, "\$Revision$REVISION \$");
+	exit $ERRORS{'OK'};
+}
+
+if ($opt_help) {
+	print_help();
+	exit $ERRORS{'OK'};
+}
+
+if (! utils::is_hostname($opt_host)){
+	usage();
+	exit $ERRORS{'UNKNOWN'};
+}
+
+($longest_wanted, @wanted_procs) = parse_wanted_procs($opt_verbose, $opt_wanted_procs, $opt_warning, $opt_critical);
+
+$SIG{'ALRM'} = sub {
+	print "Timeout: No Answer from Client\n";
+	exit $ERRORS{'UNKNOWN'};
+};
+alarm($opt_timeout);
+
+($longest_current, %current_process_list) = get_process_list($opt_verbose, $opt_host, $opt_username, $opt_privpassword, $opt_authprotocol, $opt_authpassword, $opt_community, $opt_port, $opt_oidname, $opt_snmp_version);
+
+$exit_status = compare_process_list($opt_regexp, \%current_process_list, @wanted_procs);
+
+if ($opt_verbose) {
+	print_info($longest_current, \%current_process_list, $longest_wanted, @wanted_procs);
+}
+
+exit($exit_status);
+
+
+#
+sub compare_process_list {
+
+	my($regexp, $current_process_list, @wanted_procs) = @_;
+	my($proc, $i, $no_running_procs, @warning, @critical);
+	my $exit = $ERRORS{'OK'};
+
+	for ($i = 0; $i <= $#wanted_procs; $i++) {
+
+		$proc = $wanted_procs[$i];
+
+		$no_running_procs = get_running_procs($regexp, $$proc{name}, $current_process_list);
+
+		$$proc{no_matches} += $no_running_procs;
+
+		if (($no_running_procs >= $$proc{warn_low}) &&
+		    ($no_running_procs <= $$proc{warn_high})) {
+
+			push(@warning, $$proc{name} . "($no_running_procs)");
+
+			if ($exit != $ERRORS{'CRITICAL'}) {
+				$exit = $ERRORS{'WARNING'};
+			}
+
+		} elsif (($no_running_procs < $$proc{minimum}) ||
+			 ($no_running_procs >= $$proc{critical_low}) &&
+			 ($no_running_procs <= $$proc{critical_high})) {
+
+			push(@critical, $$proc{name} . "($no_running_procs)");
+
+			$exit = $ERRORS{'CRITICAL'};
+		}
+	}
+
+	print "SNMPPROC ";
+
+	if ($#critical >= 0) {
+		print "CRITICAL:";
+	} elsif ($#warning >= 0) {
+		print "WARNING:";
+	} else {
+		print "OK";
+	}
+
+	foreach $i (@critical) {
+		print " $i";
+	}
+
+	if (($#critical >= 0) &&
+	    ($#warning >= 0)) {
+		print "  WARNING:";
+	}
+
+	foreach $i (@warning) {
+		print " $i";
+	}
+
+	print "\n";
+
+	return $exit;
+}
+
+
+#
+sub get_running_procs {
+
+	my($regex, $name, $process_list) = @_;
+	my $count = 0;
+	my $process;
+
+	$count = 0;
+
+	if ($regex) {
+
+		foreach $process (keys %{$process_list}) {
+
+			if ($process =~ /$name/) {
+				$count += $$process_list{$process};
+			}
+		}
+
+
+	} else {
+
+		if (!defined($count = $$process_list{$name})) {
+			$count = 0;
+		}
+	}
+
+	return $count;
+}
+
+
+#
+sub get_process_list {
+
+	my($verbose, $host, $username, $privpassword, $authprotocol, $authpassword, $community, $port, $oidname, $snmp_version) = @_;
+	my(%process_list, %process_pid_list, $result);
+	my $process_list_longest = 1, $not_done = 1;
+	my(@args, @oids, $oid, $name);
+
+	($session, $error) = Net::SNMP->session(
+		-hostname      =>  $host,
+		-community     =>  $community,
+		-port	       =>  $port,
+		-version       =>  $snmp_version,
+		defined($privpassword) ? (-privpassword  =>  $privpassword) : (),
+		defined($authpassword) ? (-authpassword  =>  $authpassword) : (),
+		defined($authprotocol) ? (-authprotocol  =>  $authprotocol) : (),
+		defined($username)     ? (-username      =>  $username) : ());
+
+	if (!defined($session)) {
+		print ("UNKNOWN: $error\n");
+		exit $ERRORS{'UNKNOWN'};
+	}
+
+	@args = (-varbindlist => [$OIDS{$oidname}]);
+
+	if ($session->version == SNMP_VERSION_1) {
+
+		while (defined($session->get_next_request(@args))) {
+
+			$oid = (keys(%{$session->var_bind_list}))[0];
+
+			last if (!oid_base_match($OIDS{$oidname}, $oid));
+
+			$name = $session->var_bind_list->{$oid};
+			$process_list{$name}++;
+
+			if ($verbose && ($process_list_longest < length($name))) {
+				$process_list_longest = length($name);
+			}
+
+			@args = (-varbindlist => [$oid]);
+		}
+
+	} else {
+
+		push(@args, -maxrepetitions => 25);
+
+		while ($not_done && defined($session->get_bulk_request(@args))) {
+
+			@oids = oid_lex_sort(keys(%{$session->var_bind_list}));
+
+			foreach $oid (@oids) {
+				if (!oid_base_match($OIDS{$oidname}, $oid)) {
+
+					$not_done = 0;
+
+				} else {
+
+					$name = $session->var_bind_list->{$oid};
+					$process_list{$name}++;
+
+					if ($verbose && ($process_list_longest < length($name))) {
+						$process_list_longest = length($name);
+					}
+
+					if ($session->var_bind_list->{$oid} eq 'endOfMibView') {
+						$not_done = 0;
+					}
+				}
+			}
+
+			if ($not_done) {
+				@args = (-maxrepetitions => 25, -varbindlist => [pop(@oids)]);
+			}
+		}
+	}
+
+	if ($session->error() ne '') {
+		print ("UNKNOWN: " . $session->error() . "\n");
+		exit $ERRORS{'UNKNOWN'};
+	}
+
+	$session->close;
+
+	return($process_list_longest, %process_list);
+}
+
+
+#
+sub parse_wanted_procs {
+
+	my($verbose, $wanted_procs, $warning, $critical) = @_;
+
+	my(@procs, $process, $i, $critical_low, $critical_high, $warn_low, $warn_high, $process_name, $process_min);
+	my(@process_array, @warn_array, @critical_array);
+	my $exit = 0;
+	my $longest_name = 1;
+
+	if (defined($wanted_procs)) {
+		@process_array = split(/,/, $wanted_procs);
+	}
+
+	if (defined($warning)) {
+		@warn_array = split(/,/, $warning);
+	}
+
+	if (defined($critical)) {
+		@critical_array = split(/,/, $critical);
+	}
+
+	if( defined($warning) && $#process_array != $#warn_array ) {
+
+		print "Error: Number of entries in process list($#process_array) and warn list($#warn_array) don't match\n";
+		exit $ERRORS{'UNKNOWN'};
+	}
+
+	if( defined($critical) && $#process_array != $#critical_array ) {
+
+		print "Error: Number of entries in process list and critical list don't match\n";
+		exit $ERRORS{'UNKNOWN'};
+	}
+
+	for ($i = 0; $i <= $#process_array; $i++) {
+
+		if ((($process_name, $process_min) = split(/:/, $process_array[$i])) != 2) {
+
+			$process_min = 1;
+		}
+
+		if ($verbose && ($longest_name < length($process_name))) {
+
+			$longest_name = length($process_name);
+		}
+
+		if (defined($critical_array[$i])) {
+			if ((($critical_low, $critical_high) = split(/:/, $critical_array[$i])) != 2) {
+
+				$critical_high = $critical_low;
+
+			} else {
+
+				if ($critical_high eq "") {
+					$critical_high = $max_no_processes;
+				}
+
+				if ($critical_low eq "") {
+					$critical_low = 0;
+				}
+			}
+		} else {
+
+			$critical_low = -1;
+			$critical_high = -1;
+		}
+
+		if (defined($warn_array[$i])) {
+			if ((($warn_low, $warn_high) = split(/:/, $warn_array[$i])) != 2) {
+
+				$warn_high = $warn_low;
+
+			} else {
+
+				if ($warn_high eq "") {
+					$warn_high = $max_no_processes;
+				}
+
+				if ($warn_low eq "") {
+					$warn_low = 0;
+				}
+			}
+		} else {
+
+			$warn_low = -1;
+			$warn_high = -1;
+		}
+
+		if ($critical_low > $critical_high) {
+			print "Error: $process_name critical low($critical_low) is larger than high($critical_high)\n";
+			$exit = 1;
+		}
+
+		if ($warn_low > $warn_high) {
+			print "Error: $process_name warn low($warn_low) is larger than high($warn_high)\n";
+			$exit = 1;
+		}
+
+		if (@critical_array &&
+		    ($process_min > $critical_low)) {
+			print "Error: $process_name minimum($process_min) is larger than critical low($critical_low)\n";
+			$exit = 1;
+		}
+
+		if (@warn_array &&
+		    ($process_min > $warn_low)) {
+			print "Error: $process_name minimum($process_min) is larger than warn low($warn_low)\n";
+			$exit = 1;
+		}
+
+		if (@warn_array && @critical_array &&
+		    ((($warn_low >= $critical_low) && ($warn_low <= $critical_high)) ||
+		     (($warn_high >= $critical_low) && ($warn_high <= $critical_high)))) {
+
+			print "Error: $process_name warn levels($warn_low:$warn_high) overlap with critical levels($critical_low:$critical_high)\n";
+			$exit = 1;
+		}
+
+		push(@procs,{
+			name          => $process_name,
+			critical      => defined($critical),
+			critical_low  => $critical_low,
+			critical_high => $critical_high,
+			minimum	      => $process_min,
+			warning       => defined($warning),
+			warn_low      => $warn_low,
+			warn_high     => $warn_high});
+	}
+
+	if ($exit) {
+		exit $ERRORS{'UNKNOWN'};
+	}
+
+	return($longest_name, @procs);
+}
+
+
+#
+sub print_info {
+
+	my ($longest_current, $current_process_list, $longest_wanted, @wanted_procs) = @_;
+
+	if ($longest_wanted < 7) {
+		$longest_wanted = 7;
+	} else {
+		$longest_wanted++;
+	}
+
+	printf("%s---------------------------------------------\n", "-" x $longest_wanted);
+	printf("|%-" . $longest_wanted . "s |      |  Min |     Warn    |   Critical  |\n", "Process");
+	printf("|%-" . $longest_wanted . "s | Qty  | Procs|  Low | High |  Low | High |\n", "Name");
+	printf("%s---------------------------------------------\n", "-" x $longest_wanted);
+
+	for (my $temp=0; $temp <= $#wanted_procs; $temp++) {
+
+		printf("|%-" . $longest_wanted . "s |%6d|%6d|%6d|%6d|%6d|%6d|\n",
+			$wanted_procs[$temp]{name},
+			$wanted_procs[$temp]{no_matches},
+			$wanted_procs[$temp]{minimum},
+			$wanted_procs[$temp]{critical_low},
+			$wanted_procs[$temp]{critical_high},
+			$wanted_procs[$temp]{warn_low},
+			$wanted_procs[$temp]{warn_high});
+	}
+
+	printf("%s---------------------------------------------\n\n", "-" x $longest_wanted);
+
+	if ($longest_current < 7) {
+		$longest_current = 7;
+	} else {
+		$longest_current++;
+	}
+
+	printf("%s----------\n", "-" x $longest_current);
+	printf("|%-" . $longest_current . "s |  Qty |\n", "Process");
+	printf("%s----------\n", "-" x $longest_current);
+
+	foreach my $result (sort keys %{$current_process_list}) {
+
+		printf("|%-" . $longest_current . "s |%6d|\n", $result,
+			$current_process_list{$result});
+	}
+	printf("%s----------\n", "-" x $longest_current);
+
+	return;
+}
+
+
+#
+sub print_usage {
+    print "Usage:
+ $PROGNAME -H <host> [-r] [-v]
+		  -N <processname>[:minimum][,<processname>[:minimum] ...]
+		  [-a <authprotocol>] [-A <authpassword>]
+		  [-U <username>] [-P <password>]
+		  [-o <oidname>] [ -S <snmpversion> ]
+		  [-C <snmp_community>] [-p <port>] [-t <timeout>]
+		  [-w <low>:<high>[,<low>:<high> ...]
+		  [-c <low>:<high>[,<low>:<high> ...]
+       $PROGNAME (-h | --help) for detailed help
+       $PROGNAME (-V | --version) for version information\n";
+}
+
+
+#
+sub print_help {
+	print_revision($PROGNAME, "\$Revision$REVISION \$");
+	print "Copyright (c) 2003 David Alden
+
+Check if processes are running on a host via snmp
+
+";
+
+	print_usage();
+
+	print "
+-a, --authprotocol=<authprotocol>
+   Set the authentication protocol used for authenticated SNMPv3 messages
+-A, --authpassword=<authpassword>
+   Set the authentication pass phrase used for authenticated SNMPv3 messages
+-c, --critical=<low>:<high>[,<low>:<high> ...]
+   exit with CRITICAL status if number of processes is between <low> and <high>
+-C, --community=<snmp_community>
+   SNMP read community (default: $opt_community)
+-h, --help
+   Show this help screen
+-H, --host=<host>
+   Check processes on the indiciated host
+-o, --oidname=<oidname>
+   Which oid tree to search, hrSWRunName or hrSWRunPath (default: $opt_oidname)
+-p, --port=<port>
+   Make connection on the indicated port (default: $opt_port)
+-N, --names=<processname>[:<minimum>][,<processname>[:<minimum>] ...]
+   Process names to check, (optional) minimum number of processes (default: 1)
+-P, --password=<privpassword>
+   Set the privacy pass phrase used for encrypted SNMPv3 messages
+-r, --regex
+   Use regular expression match for <process>
+-S, --snmpversion
+   Use snmp version specified (values: 1|2c|3, default: $opt_snmp_version)
+-t, --timeout
+   Plugin time out in seconds (default: $opt_timeout)
+-U, --username=<securityname>
+   Set the securityname used for encrypted SNMPv3 messages
+-v, --verbose
+   Print some extra debugging information (not advised for normal operation)
+-V, --version
+   Show version and license information
+-w, --warning=<low>:<high>[,<low>:<high> ...]
+   exit with WARNING status if number of processes is between <low> and <high>
+
+
+A CRITICAL error will be indicated unless there are at least <minimum> number
+of processes running (unless <minimum> is set to 0 -- useful if you don't
+mind that there are none of the processes running).
+
+If no processes are specified, the program will still connect to the remote
+host and download the current list of running processes.  It will then exit
+with an OK (unless it wasn't able to connect) -- useful if you want to make
+sure that the remote snmpd process is running and returning a list of procs.
+
+
+";
+	support();
+}