

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: check_snmp_process_monitor.pl</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>#!/usr/bin/perl
# author: Al Tobey &lt;albert.tobey@priority-health.com&gt;
# what:   monitor a process using the host-resources mib
# license: GPL - http://www.fsf.org/licenses/gpl.txt
#
# Todo:
# * implement memory and cpu utilization checks
# * maybe cache pids in DBM files if snmp agents get overworked
###############################################################################
# to get a list of processes over snmp try this command:
# snmptable -v2c -c public hostname hrSWRunTable
# for just a list of valid arguments for the &#039;-e&#039; option:
# snmpwalk -v2c -c public hostname hrSWRunName |perl -pe &#039;s:.*/::&#039;
###############################################################################

use strict;
require 5.6.0;
use lib qw( /opt/nagios/libexec /usr/local/libexec );
use utils qw(%ERRORS $TIMEOUT &amp;print_revision &amp;support &amp;usage);
use SNMP 5.0;
use Getopt::Long;
use Storable;
use vars qw( $exit $opt_version $opt_timeout $opt_help $opt_command $opt_host $opt_community $opt_verbose $opt_warning $opt_critical $opt_memory $opt_cpu $opt_port $opt_regex $opt_stats $opt_cache $opt_nocache $cache_exp $interpreters $snmp_session $PROGNAME $TIMEOUT );

$PROGNAME      = &quot;snmp_process_monitor.pl&quot;;
$opt_verbose   = undef;
$opt_host      = undef;
$opt_community = &#039;public&#039;;
$opt_command   = undef;
$opt_warning   = [ 1, -1 ];
$opt_critical  = [ 1, -1 ];
$opt_memory    = undef;
$opt_cpu       = undef;
$opt_port      = 161;
$opt_cache     = 1;
$opt_nocache   = undef;
$cache_exp     = 600;
$exit          = $ERRORS{OK};
$interpreters  = &#039;(perl|/bin/sh|/usr/bin/sh|/bin/bash|/bin/ksh|python)&#039;;
our $cachefile = &#039;/var/opt/nagios/tmp/&#039;; # completed later
our %processes = ();

sub process_options {
    my( $opt_crit, $opt_warn ) = ();
    Getopt::Long::Configure( &#039;bundling&#039; );
    GetOptions(
        &#039;V&#039;     =&gt; \$opt_version,       &#039;version&#039;     =&gt; \$opt_version,
        &#039;v&#039;     =&gt; \$opt_verbose,       &#039;verbose&#039;     =&gt; \$opt_verbose,
        &#039;h&#039;     =&gt; \$opt_help,          &#039;help&#039;        =&gt; \$opt_help,
        &#039;s&#039;     =&gt; \$opt_stats,         &#039;statistics&#039;  =&gt; \$opt_stats,
                                        &#039;nocache&#039;     =&gt; \$opt_nocache,
        &#039;H:s&#039;   =&gt; \$opt_host,          &#039;hostname:s&#039;  =&gt; \$opt_host,
        &#039;p:i&#039;   =&gt; \$opt_port,          &#039;port:i&#039;      =&gt; \$opt_port,
        &#039;C:s&#039;   =&gt; \$opt_community,     &#039;community:s&#039; =&gt; \$opt_community,
        &#039;c:s&#039;   =&gt; \$opt_crit,          &#039;critical:s&#039;  =&gt; \$opt_crit,
        &#039;w:s&#039;   =&gt; \$opt_warn,          &#039;warning:s&#039;   =&gt; \$opt_warn,
        &#039;t:i&#039;   =&gt; \$TIMEOUT,           &#039;timeout:i&#039;   =&gt; \$TIMEOUT,    
        &#039;e:s&#039;   =&gt; \$opt_command,       &#039;command:s&#039;   =&gt; \$opt_command,
        &#039;r:s&#039;   =&gt; \$opt_regex,         &#039;regex:s&#039;     =&gt; \$opt_regex,
        &#039;cpu:i&#039; =&gt; \$opt_cpu,           &#039;memory:i&#039;    =&gt; \$opt_memory,
    );
    if ( defined($opt_version) ) { local_print_revision(); }
    if ( defined($opt_verbose) ) { $SNMP::debugging = 1; }
    if ( !defined($opt_host) || defined($opt_help) || (!defined($opt_command) &amp;&amp; !defined($opt_regex)) ) {
        print_help();
        exit $ERRORS{UNKNOWN};
    }

    if ( defined($opt_crit) ) {
        if ( $opt_crit =~ /,/ ) {
            $opt_critical = [ split(&#039;,&#039;, $opt_crit) ];
        }
        else {
            $opt_critical = [ $opt_crit, -1 ];
        }
    }
    if ( defined($opt_warn) ) {
        if ( $opt_warn =~ /,/ ) {
            $opt_warning = [ split(&#039;,&#039;, $opt_warn) ];
        }
        else {
            $opt_warning = [ $opt_crit, -1 ];
        }
    }
    if ( defined($opt_memory) ) { $opt_memory = 0 }
    if ( defined($opt_cpu)    ) { $opt_cpu    = 0 }
    if ( defined($opt_nocache)) { $opt_cache  = 0 }

    # complete the cachefile&#039;s name
    $cachefile .= $opt_host . &#039;.proc&#039;;
}

sub local_print_revision {
        print_revision( $PROGNAME, &#039;$Revision: 84 $ &#039; )
}

sub print_usage {
    print &quot;Usage: $PROGNAME -H &lt;host&gt; -C &lt;snmp_community&gt; -e &lt;command&gt; [-w &lt;low&gt;,&lt;high&gt;] [-c &lt;low&gt;,&lt;high&gt;] [-t &lt;timeout&gt;] [-s|--statistics] [--memory] [--cpu] [--nocache]\n&quot;;
}

sub print_help {
    local_print_revision();
    print &quot;Copyright (c) 2002 Al Tobey &lt;albert.tobey\@priority-health.com&gt;\n\n&quot;,
          &quot;SNMP Process Monitor plugin for Nagios\n\n&quot;;
    print_usage();
    print &lt;&lt;EOT;
-v, --verbose
   print extra debugging information
-h, --help
   print this help message
-H, --hostname=HOST
   name or IP address of host to check
-C, --community=COMMUNITY NAME
   community name for the host&#039;s SNMP agent
-e, --command=COMMAND NAME (ps -e style)
   what command should be monitored?
-r, --regex=Perl RE
   use a perl regular expression to find your process
-w, --warning=INTEGER[,INTEGER]
   minimum and maximum number of processes before a warning is issued (Default 1,-1)
-c, --critical=INTEGER[,INTEGER]
   minimum and maximum number of processes before a critical is issued (Default 1,-1)
--memory
   combined with &#039;-s&#039;, will print the number of bytes of real memory used by process
--cpu
   combined with &#039;-s&#039;, will print the number of seconds of cpu time consumed by process
EOT
}

sub verbose (@) {
    return if ( !defined($opt_verbose) );
    print @_;
}

sub check_for_errors {
    if ( $snmp_session-&gt;{ErrorNum} ) {
        %processes = ();
        print &quot;UNKNOWN - error retrieving SNMP data: $snmp_session-&gt;{ErrorStr}\n&quot;;
        exit $ERRORS{UNKNOWN};
    }
}

sub init_cache {
    if ( !defined($opt_cache) ) {
        %processes = ();
        return;
    }
    if ( -r $cachefile ) {
        eval {
            verbose &quot;loading cache from $cachefile\n&quot;;
            %processes = %{ retrieve( $cachefile ) };
        };
        if ( $@ ) {
            verbose &quot;cache loading failed - using blank cache: $@\n&quot;;
            %processes = ()
        }
    }
    else {
        %processes = ();
    }
}

sub snmpget {
    my $tmpvar = SNMP::Varbind-&gt;new( shift );
    $snmp_session-&gt;get( $tmpvar );
    check_for_errors();
    return $tmpvar-&gt;val;
}

sub update_cache {
    # expire the cache after $cache_exp seconds
    if ( $opt_cache != 0 &amp;&amp; exists($processes{__last_update})
      &amp;&amp; $processes{__last_update} &gt;= time - $cache_exp )  {
        verbose &quot;cache file is recent enough - using it\n&quot;;
        return 1;
    }

    verbose &quot;retrieving full listing of processes from $opt_host\n&quot;;
    my $process_count = snmpget( [&#039;hrSystemProcesses&#039;, 0] );

    # retrieve the data from the remote host
	my ($names) = $snmp_session-&gt;bulkwalk( 0, $process_count + 1, [[&#039;hrSWRunName&#039;]] );
	check_for_errors();

    # make sure the number of processes from the bulkwalk is close to hrSystemProcesses
    if ( scalar(@$names) + 10 &lt; $process_count ) {
        print &quot;UNKNOWN - only &quot;, scalar(@$names), &quot; of &quot;,$process_count, &quot; processes returned\n&quot;;;
        exit $ERRORS{UNKNOWN};
    }

    # sort through the process names and create a nice hash of processes
	foreach my $row ( @$names ) {
        my %hash = {};
	    $hash{name}     = $row-&gt;val;
        $hash{abs_name} = $row-&gt;val;
	    $hash{name}     =~ s#.*/##; # strip path
	
	    if ( defined($opt_regex) ||
	        ($row-&gt;val =~ m#$interpreters$#
	        &amp;&amp; $opt_command !~ m#$interpreters$#) ) {
	
	        # fetch the runtime parameters of the process
            my $parameters = snmpget( [&#039;hrSWRunParameters&#039;, $row-&gt;iid] );
	
	        # only strip if we&#039;re looking for a specific command
	        if ( defined($opt_command) ) {
	            verbose &quot;process &quot;,$row-&gt;iid,&quot; uses $1 as an interpreter - getting parameters\n&quot;;
	            $hash{name} = $parameters;
	            $hash{name} =~ s#.*/##;    # strip path name off the front
	            $hash{name} =~ s/\s+.*$//; # strip everything from the first space to the end
	        }
	        else {
	            # use the full &#039;ps -efl&#039; style listing for regular expression matching
                my $path = snmpget( [&#039;hrSWRunPath&#039;, $row-&gt;iid] );
	            $hash{name} = &quot;$path $parameters&quot;;
	        }
	    }
        # store in the global hash
        $processes{$row-&gt;iid} = \%hash;
	}

    # update the timestamp so the cache can expire
    $processes{__last_update} = time;
    return 0;
}

# process the %processes hash and see if there any matches for our command or regex
sub check_for_matches {
    my $ret_match = 0;
	foreach my $key ( keys(%processes) ) {
        next if ( $key eq &#039;__last_update&#039; );
        my $match = 0;

        # static matches are letter-for-letter (-e)
	    if ( defined($opt_command)  &amp;&amp; $processes{$key}-&gt;{name} eq  $opt_command ) { $match++; }
        # use /o to make sure the user-supplied regex (-r) is only compiled once
	    elsif ( defined($opt_regex) &amp;&amp; $processes{$key}-&gt;{name} =~ /$opt_regex/o ) { $match++; }

        # verify the cache&#039;s entry by doing an snmpget
        if ( $match &gt; 0 &amp;&amp; $opt_cache != 0 ) {
            my $proc = snmpget( [&#039;hrSWRunName&#039;, $key] );
            --$match if ( !$proc || $proc ne $processes{$key}-&gt;{abs_name} );
        }
        # get the process memory usage if requested
        if ( $match &gt; 0 &amp;&amp; defined($opt_memory) ) {
            $opt_memory += snmpget( [&#039;hrSWRunPerfMem&#039;, $key] );
        }
        # get the process cpu usage if requested
        if ( $match &gt; 0 &amp;&amp; defined($opt_cpu) ) {
            $opt_cpu += snmpget( [&#039;hrSWRunPerfCPU&#039;, $key] );
        }

	    verbose &quot;process &#039;$processes{$key}-&gt;{name}&#039; has pid $processes{$key}-&gt;{pid} and index $key\n&quot;
            if ( $match &gt; 0 );

        $ret_match += $match;
	}
	return $ret_match;
}
# =========================================================================== #
# =====&gt; MAIN
# =========================================================================== #
process_options();

alarm( $TIMEOUT ); # make sure we don&#039;t hang Nagios

# intialize the cache, if it&#039;s enabled
init_cache();

# create a session for conversing with the remote SNMP agent
$snmp_session = new SNMP::Session(
    DestHost =&gt; $opt_host,
    Community =&gt; $opt_community,
    RemotePort =&gt; $opt_port,
    Version   =&gt; &#039;2c&#039;
);

my $usage = update_cache();
my $count = check_for_matches();

# always try twice if caching is enabled - once with cache and once without
if ( $usage != 0 &amp;&amp; $opt_cache != 0 &amp;&amp; $count &lt;= 0 ) {
    verbose &quot;did not find process in cache - trying a refresh\n&quot;;
    %processes = ();
    update_cache();
    $count = check_for_matches();
}


# the default, OK message
my $message = &quot;OK - $count process(es) found resembling &#039;&quot;. ($opt_command || $opt_regex);

# warning, critical
if ( ($opt_warning-&gt;[0] &gt; 0 &amp;&amp; $opt_warning-&gt;[0]  &gt;  $count)
  || ($opt_warning-&gt;[1] &gt; 0 &amp;&amp; $opt_warning-&gt;[1]  &lt;= $count) ) {
    $message = &quot;WARNING - no processes found resembling &#039;&quot;. ($opt_command || $opt_regex);
    $exit = $ERRORS{WARNING};
}
if ( ($opt_critical-&gt;[0] &gt; 0 &amp;&amp; $opt_critical-&gt;[0]  &gt;  $count)
  || ($opt_critical-&gt;[1] &gt; 0 &amp;&amp; $opt_critical-&gt;[1]  &lt;= $count) ) {
    $message = &quot;CRITICAL - no processes found resembling &#039;&quot;. ($opt_command || $opt_regex);
    $exit = $ERRORS{CRITICAL};
}

# output the status message
print $message, &quot;&#039;&quot;;

# print the number of processes if statistics are requested
if ( defined($opt_stats) ) {
    print &quot;|count=$count&quot;;
    if ( defined($opt_memory) ) {
        print &quot;:memory=&quot;, $opt_memory;
    }
    if ( defined($opt_cpu) ) {
        $opt_cpu = $opt_cpu / 100;
        printf &quot;:cpu=%.2f&quot;, $opt_cpu;
    }
}

# store a copy of the %processes hash if we&#039;re using caching
if ( $exit == $ERRORS{OK} &amp;&amp; $opt_cache != 0 ) {
    eval {
        unlink( $cachefile ) if ( -e $cachefile );
        store( \%processes, $cachefile );
    };
}

print &quot;\n&quot;;
exit $exit;


</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib64/nagios/plugins/contrib/check_snmp_process_monitor.pl'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flib64%2Fnagios%2Fplugins%2Fcontrib' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>