#!/usr/bin/perl -w
#
# Check Cisco ISDN Calls
#
# Plugin uses SNMP connection to router.
#
# Copyright (C) 2009 by Herbert Stadler
# email: hestadler@gmx.at
#
# Used MIB: CISCO-CALL-HISTORY-MIB
# OID: 1.3.6.1.4.1.9.9.27
#
#
#
# License Information:
# 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 .
#
#
############################################################################
use POSIX;
use strict;
use Getopt::Long;
#use Data::Dumper;
use lib ".";
use lib "/usr/lib/nagios/plugins";
use lib "/usr/lib64/nagios/plugins";
use lib "/usr/local/nagios/libexec";
use utils qw(%ERRORS);
use SNMP;
use Net::SNMP qw(oid_lex_sort oid_base_match :debug);
use constant TRANSLATE_OIDs => 0;
use constant DEFAULT_CHECKPERIOD => 3600;
use constant NOT_AVAILABLE => "---N/A---";
my ($opt_version,$opt_help,$opt_verbose);
my ($opt_timeout,$opt_license);
my ($opt_hostname,$opt_community,$opt_port,$opt_snmpvers);
my ($opt_snmpdebug,$opt_snmptimeout,$opt_warn,$opt_crit);
my ($opt_desthosts,$opt_checkperiod);
my ($PROGNAME,$REVISION);
my ($state,$msg);
my ($g_snmpdebug);
my $DEFAULT_TIMEOUT =30;
my $DEFAULT_SNMPTIMEOUT =2;
my $sysUpTime = "1.3.6.1.2.1.1.3";
my $sysDescr = "1.3.6.1.2.1.1.1";
my $sysLocation = "1.3.6.1.2.1.1.6";
# MIB OID's of CISCO-CALL-HISTORY-MIB
my $HistoryMib = "1.3.6.1.4.1.9.9.27";
my $HistoryMibObjects = $HistoryMib . ".1";
my $History = $HistoryMibObjects . ".1";
my $HistoryTableMaxLength = $History . ".1";
my $HistoryRetainTimer = $History . ".2";
my $HistoryTable = $History . ".3";
my $HistoryEntry = $HistoryTable . ".1";
my $HistoryStartTime = $HistoryEntry . ".1";
my $HistoryIndex = $HistoryEntry . ".2";
my $HistoryCallingNumber = $HistoryEntry . ".3";
my $HistoryCalledNumber = $HistoryEntry . ".4";
my $HistoryInterfaceNumber = $HistoryEntry . ".5";
my $HistoryDestinationAddress = $HistoryEntry . ".6";
my $HistoryDestinationHostName = $HistoryEntry . ".7";
my $HistoryCallDisconnectCause = $HistoryEntry . ".8";
my $HistoryCallConnectionTime = $HistoryEntry . ".9";
my $HistoryCallDisconnectTime = $HistoryEntry . ".10";
my $HistoryDialReason = $HistoryEntry . ".11";
my $HistoryConnectTimeOfDay = $HistoryEntry . ".12";
my $HistoryDisconnectTimeOfDay = $HistoryEntry . ".13";
my $HistoryTransmitPackets = $HistoryEntry . ".14";
my $HistoryTransmitBytes = $HistoryEntry . ".15";
my $HistoryReceivePackets = $HistoryEntry . ".16";
my $HistoryReceiveBytes = $HistoryEntry . ".17";
my %Val_HistoryCallDisconnectCause = (
1 => "other",
2 => "normalDisconnectSent",
3 => "normalDisconnectReceived",
4 => "networkOutOfOrder",
5 => "callRejected",
6 => "userBusy",
7 => "noCircuitChannelAvailable",
8 => "interworkingError",
);
$ENV{'PATH'}='';
$ENV{'BASH_ENV'}='';
$ENV{'ENV'}='';
$PROGNAME = "check_cisco_isdn";
$REVISION = "1.0";
# Array for ISDN Destination Hosts
my $h_desthosts={};
# Parameters for warning & critical
my $h_para={};
# checking commandline arguments
my $arg_status = check_args();
if ($arg_status){
print "ERROR: some arguments wrong\n";
exit ($ERRORS{"UNKNOWN"});
}
if ($opt_snmpdebug) {
my $module="Net::SNMP";
printf( "%-20s Version: %s\n", $module, $module->VERSION );
}
# set alarmhandler for timeouthandling
$SIG{'ALRM'} = sub {
print ("ERROR: plugin timed out after $opt_timeout seconds \n");
exit ($ERRORS{"UNKNOWN"});
};
alarm($opt_timeout);
my ($snmp_session,$snmp_error)=open_snmp_session($opt_hostname);
if ( ! defined ($snmp_session)) {
print "ERROR: Could not open connection: $snmp_error \n";
exit ($ERRORS{'UNKNOWN'});
}
# Do not convert TimeTicks in a TimeFormat
$snmp_session->translate([ '-timeticks'=>0,'-endofmibview'=>0,'-nosuchobject'=>0,'-nosuchinstance'=>0 ]);
if ( $opt_verbose ) {
printf("SNMP TranslateMask: %d\n", $snmp_session->translate());
}
# Get some single OID's
my $a_oids=();
push (@{$a_oids},$sysUpTime);
push (@{$a_oids},$sysDescr);
push (@{$a_oids},$sysLocation);
push (@{$a_oids},$HistoryTableMaxLength);
push (@{$a_oids},$HistoryRetainTimer);
my $h_ValOid=get_request($a_oids);
# get Cisco History Table
my $h_HistTable=get_table_request($HistoryTable);
$snmp_session->close;
if ( $opt_verbose ) {
print_Single_OIDs($h_ValOid);
print_History_Table($h_HistTable);
printf ("\nNumber of DestinationHosts: %d\n",scalar keys %{$h_desthosts});
if ( keys %{$h_desthosts}) {
foreach my $key (keys %{$h_desthosts}) {
printf ("ISDN DestinationHost: %s\n",$key);
}
}
}
# Array for indexvalues OID's
my $a_index=();
foreach my $key (keys (%{$h_HistTable})) {
if ( oid_base_match($HistoryCallConnectionTime,$key)) {
my $diff=Oid_Base_Subtract($HistoryCallConnectionTime,$key);
next if ( ! defined ($diff));
push (@{$a_index},$diff);
if ( $opt_verbose ) {
printf ("Index-Values: %s\n",$diff);
}
}
}
# Hashes for open & closed history values
my $h_open={};
my $h_closed={};
# loop over all "index values" and process the history entries
foreach my $key (oid_lex_sort(@{$a_index})) {
if ( defined ($h_HistTable->{$HistoryCallConnectionTime.".".$key})){
# Connection opened
if ( defined ($h_HistTable->{$HistoryCallDisconnectTime.".".$key})){
# already history, DisconnectTime available
fill_array($h_closed,$HistoryDestinationHostName,$key,"DestinationHostName");
my $timeopen=$h_HistTable->{$HistoryCallDisconnectTime.".".$key} - $h_HistTable->{$HistoryCallConnectionTime.".".$key};
fill_array_abs($h_closed,$timeopen,$key,"TimeOpen");
fill_array($h_closed,$HistoryDisconnectTimeOfDay,$key,"DisconnectTimeOfDay");
fill_array($h_closed,$HistoryCallConnectionTime,$key,"ConnectionTime");
fill_array($h_closed,$HistoryCallDisconnectTime,$key,"DisconnectTime");
}else{
# still open
fill_array($h_open,$HistoryDestinationHostName,$key,"DestinationHostName");
my $timeopen=$h_ValOid->{$sysUpTime.".0"} - $h_HistTable->{$HistoryCallConnectionTime.".".$key};
fill_array_abs($h_open,$timeopen,$key,"TimeOpen");
fill_array($h_open,$HistoryCallConnectionTime,$key,"ConnectionTime");
fill_array_abs($h_open,$h_ValOid->{$sysUpTime.".0"},$key,"DisconnectTime");
}
}
}
# Now we start with error checking
# --------------------------------
# Array for entries for the defined checkperiod
my $h_chkperiod={};
my $sw_first_line=1;
# connections still open
foreach my $dest (keys %{$h_open}) {
if ( scalar keys %{$h_desthosts} > 0 ) {
# check if single "Destinations" exits
next if ( ! exists($h_desthosts->{$dest}));
}
foreach my $timestamp (keys %{$h_open->{$dest}}) {
my $time_sec = $h_open->{$dest}{$timestamp}{TimeOpen} / 100;
if ( $opt_verbose ) {
if ( $sw_first_line == 1 ) {
$sw_first_line = 0;
printf ("\n");
}
printf ("LineOpen : %-20s, %0.2f sec\n",$dest,$time_sec);
}
Check_Time_Window ($dest,$h_open->{$dest}{$timestamp}{ConnectionTime},$h_open->{$dest}{$timestamp}{DisconnectTime});
}
}
$sw_first_line = 1;
# connections already closed
foreach my $dest (keys %{$h_closed}) {
if ( scalar keys %{$h_desthosts} > 0 ) {
next if ( ! exists($h_desthosts->{$dest}));
}
foreach my $timestamp (keys %{$h_closed->{$dest}}) {
my $time_sec = $h_closed->{$dest}{$timestamp}{TimeOpen} / 100;
my $dtofday = $h_closed->{$dest}{$timestamp}{DisconnectTimeOfDay};
if ( $opt_verbose ) {
if ( $sw_first_line == 1 ) {
$sw_first_line = 0;
printf ("\n");
}
printf ("LineClosed: %-20s, %0.2f sec, %s\n",$dest,$time_sec,$dtofday);
}
Check_Time_Window ($dest,$h_closed->{$dest}{$timestamp}{ConnectionTime},$h_closed->{$dest}{$timestamp}{DisconnectTime});
}
}
# set standard values for program exit
$msg = "ISDN OK - No Problems found";
$state = $ERRORS{'OK'};
my $l_tmsg;
foreach my $dest (keys %{$h_chkperiod}) {
my $time_sec = $h_chkperiod->{$dest}{TimeOpen} / 100;
if ( $opt_verbose ) {
printf ("TotalValues: %s, %0.2f secs\n",$dest, $time_sec);
}
if ( $time_sec < $h_para->{IdsnOpenTimeWarn} ) {
# everything ok
my $l_tmess=sprintf("OK:%s:%d sec",$dest,$time_sec);
Set_Error_Msg ($ERRORS{'OK'},$l_tmess);
}elsif ( $time_sec < $h_para->{IdsnOpenTimeCrit} ) {
# in warning area
my $l_tmess=sprintf("W:%s:%d sec",$dest,$time_sec);
Set_Error_Msg ($ERRORS{'WARNING'},$l_tmess);
} else {
# in critical area
my $l_tmess=sprintf("C:%s:%d sec",$dest,$time_sec);
Set_Error_Msg ($ERRORS{'CRITICAL'},$l_tmess);
}
}
# and now "over and out"
if ( $state != $ERRORS{'OK'} ) {
if ( $state == $ERRORS{'CRITICAL'} ) {
$msg="ISDN CRITICAL - ".$l_tmsg;
} elsif ( $state == $ERRORS{'WARNING'} ) {
$msg="ISDN WARNING - ".$l_tmsg;
} else {
$msg="ISDN UNKNOWN - ".$l_tmsg;
}
}
print "$msg\n";
exit ($state);
#--------------------------------------------------------------------------#
# S U B R O U T I N E S #
#--------------------------------------------------------------------------#
#--------------------------------------------------------------------------
sub Check_Time_Window {
#--------------------------------------------------------------------------
my ($Destination,$ConnectionTime,$DisconnectTime)=@_;
# this is our reference time
my $timenow=$h_ValOid->{$sysUpTime.".0"};
my $windowstart=$timenow - ($opt_checkperiod * 100);
if ( $DisconnectTime < $windowstart ) {
# out of TimeWindow back to where we came from
return;
}
my $open_hsec;
if ( $ConnectionTime < $windowstart ) {
# we have to calculate the difference now
$open_hsec = $DisconnectTime - $windowstart;
}else{
# we can take the whole time
$open_hsec = $DisconnectTime - $ConnectionTime;
}
# Add up all "open seconds" in the TimeWindow
if ( ! exists ($h_chkperiod->{$Destination}{TimeOpen})) {
$h_chkperiod->{$Destination}{TimeOpen}=0;
}
if ( $opt_verbose ) {
printf ("Adding %s, %0.02f secs\n",$Destination,$open_hsec/100);
}
$h_chkperiod->{$Destination}{TimeOpen}+=$open_hsec;
}
#--------------------------------------------------------------------------
sub Get_DestinationHostName {
#--------------------------------------------------------------------------
my ($index)=@_;
# give back the DestinationHostname
if ( defined ($h_HistTable->{$HistoryDestinationHostName.".".$index})){
return($h_HistTable->{$HistoryDestinationHostName.".".$index});
}
if ( $opt_verbose ) {
printf("DestinationHostName not found for index: %s\n",$index);
}
# sometimes the OID's for the Hostnames are not filled, so we return
# the telephonenumber
if ( defined ($h_HistTable->{$HistoryCallingNumber.".".$index})){
if ( $h_HistTable->{$HistoryCallingNumber.".".$index} ne NOT_AVAILABLE ){
return($h_HistTable->{$HistoryCallingNumber.".".$index});
}
}
if ( defined ($h_HistTable->{$HistoryCalledNumber.".".$index})){
if ( $h_HistTable->{$HistoryCalledNumber.".".$index} ne NOT_AVAILABLE ){
return($h_HistTable->{$HistoryCalledNumber.".".$index});
}
}
return("");
}
#--------------------------------------------------------------------------
sub fill_array {
#--------------------------------------------------------------------------
my ($h_array,$source,$index,$fnam)=@_;
if ( defined ($h_HistTable->{$source.".".$index})){
my ($timestamp,$other)=split('\.',$index);
my $dhn=Get_DestinationHostName($index);
$h_array->{$dhn}{$timestamp}{$fnam}=$h_HistTable->{$source.".".$index};
}
}
#--------------------------------------------------------------------------
sub fill_array_abs {
#--------------------------------------------------------------------------
my ($h_array,$source,$index,$fnam)=@_;
if ( defined ($source)){
my ($timestamp,$other)=split('\.',$index);
my $dhn=Get_DestinationHostName($index);
#-- for debugging
my $f_out=0;
my $lxx="";
if ( ! defined($dhn) ) {
$f_out=1;
$lxx.="dhn undefined,";
$dhn="";
}
if ( ! defined($timestamp) ) {
$f_out=1;
$lxx.="timestamp undefined,";
$timestamp="";
}
if ( ! defined($fnam) ) {
$f_out=1;
$lxx.="fnam undefined,";
$fnam="";
}
if ( ! defined($source) ) {
$f_out=1;
$lxx.="source undefined,";
$source="";
}
if ( $f_out == 1 ) {
open (OUTD,">>/tmp/ISDN_Debugging.txt");
printf(OUTD "lxx :%s\n",$lxx||"");
printf(OUTD "dhn: :%s\n",$dhn||"");
printf(OUTD "timest:%s\n",$timestamp||"");
printf(OUTD "fnam :%s\n",$fnam||"");
printf(OUTD "source:%s\n",$source||"");
foreach my $key (oid_lex_sort(keys (%{$h_HistTable}))) {
printf (OUTD "%-50s: %s\n",$key,$h_HistTable->{$key});
}
printf(OUTD "%s\n","------------");
close(OUTD);
}
#-- for debugging
$h_array->{$dhn}{$timestamp}{$fnam}=$source;
}
}
#--------------------------------------------------------------------------
sub Make_Hex {
#--------------------------------------------------------------------------
my ($str)=@_;
$str =~ s/(.)/' %' . unpack("H8", $1)/eg;
return($str);
}
#--------------------------------------------------------------------------
sub Oid_Base_Subtract {
#--------------------------------------------------------------------------
my ($base, $oid)=@_;
$base || return ($oid);
$oid || return (undef);
$base =~ s/^\.//o;
$oid =~ s/^\.//o;
$base = pack('N*', split('\.', $base));
$oid = pack('N*', split('\.', $oid));
my $blength = length($base);
if (! substr($oid, 0, $blength) eq $base) {
return(undef);
}
# replace all with blanks
substr($oid, 0, $blength,"");
my $ret = join(".",unpack('N*',$oid));
return($ret);
}
#--------------------------------------------------------------------------
sub open_snmp_session {
#--------------------------------------------------------------------------
my ($l_host)=@_;
# open SNMP Session to Router
my ($snmp_session,$snmp_error)=Net::SNMP->session(
-hostname => $l_host,
-community => $opt_community || 'public',
-port => $opt_port || 161,
-timeout => $opt_snmptimeout,
-retries => 3,
-debug => $g_snmpdebug,
-maxmsgsize => 32768,
-version => $opt_snmpvers,
);
return ($snmp_session,$snmp_error);
}
#--------------------------------------------------------------------------
sub Set_Error_Msg {
#--------------------------------------------------------------------------
my ($l_StateNew,$l_messtxt)=@_;
if ($l_StateNew == $ERRORS{'OK'}) {
return;
}
# warning, critical, unknown Messages
if ($state < $l_StateNew) {
$state = $l_StateNew;
}
if (defined ($l_tmsg)){
$l_tmsg.=",";
}
$l_tmsg.=$l_messtxt;
}
#--------------------------------------------------------------------------
sub get_table_request {
#--------------------------------------------------------------------------
my ($l_oid)=@_;
my $l_snmp_result=$snmp_session->get_table(
-baseoid => $l_oid
);
if ($snmp_session->error_status != 0) {
if ( $snmp_session->error=~/table is empty/ ) {
return ($l_snmp_result);
}
printf ("ERROR %d: get_table_request: (%s) %s\n",$snmp_session->error_status,$l_oid,$snmp_session->error);
$snmp_session->close;
exit $ERRORS{'UNKNOWN'};
}
return ($l_snmp_result);
}
#--------------------------------------------------------------------------
sub get_request {
#--------------------------------------------------------------------------
my ($l_oid)=@_;
my $l_snmp_result=$snmp_session->get_next_request(
-varbindlist => $l_oid,
);
if ($snmp_session->error_status != 0) {
print "ERROR %d get_request: ",$snmp_session->error_status,$snmp_session->error,"\n";
$snmp_session->close;
exit $ERRORS{'UNKNOWN'};
}
return ($l_snmp_result);
}
#--------------------------------------------------------------------------
sub check_args {
#--------------------------------------------------------------------------
Getopt::Long::Configure('bundling');
GetOptions
("V" => \$opt_version,
"version" => \$opt_version,
"L" => \$opt_license,
"license" => \$opt_license,
"v" => \$opt_verbose,
"verbose" => \$opt_verbose,
"D" => \$opt_snmpdebug,
"debug" => \$opt_snmpdebug,
"h|?" => \$opt_help,
"help" => \$opt_help,
"T=i" => \$opt_snmptimeout,
"snmptimeout=i" => \$opt_snmptimeout,
"t=i" => \$opt_timeout,
"timeout=i" => \$opt_timeout,
"H=s" => \$opt_hostname,
"hostname=s" => \$opt_hostname,
"C=s" => \$opt_community,
"community=s" => \$opt_community,
"p=i" => \$opt_port,
"port=i" => \$opt_port,
"s=s" => \$opt_snmpvers,
"snmpvers=s" => \$opt_snmpvers,
"w=s" => \$opt_warn,
"warn=s" => \$opt_warn,
"c=s" => \$opt_crit,
"crit=s" => \$opt_crit,
"I=s" => \$opt_desthosts,
"idesthost=s" => \$opt_desthosts,
"P=i" => \$opt_checkperiod,
"chekperiod=i" => \$opt_checkperiod,
);
if ($opt_license) {
print_gpl($PROGNAME,$REVISION);
exit ($ERRORS{'OK'});
}
if ($opt_version) {
print_revision($PROGNAME,$REVISION);
exit ($ERRORS{'OK'});
}
if ($opt_help) {
print_help();
exit ($ERRORS{'OK'});
}
if ( ! defined($opt_hostname)){
print "\nERROR: Hostname not defined\n\n";
print_usage();
exit ($ERRORS{'UNKNOWN'});
}
unless (defined $opt_snmpvers) {
$opt_snmpvers = "snmpv2c";
}
if ( ($opt_snmpvers ne "snmpv1") && ($opt_snmpvers ne "snmpv2c") ){
print "\nERROR: SNMP version unknown\n\n";
print_usage();
exit ($ERRORS{'UNKNOWN'});
}
unless (defined $opt_warn) {
print "\nERROR: parameter -w not defined\n\n";
print_usage();
exit ($ERRORS{'UNKNOWN'});
}
unless (defined $opt_crit) {
print "\nERROR: parameter -c not defined\n\n";
print_usage();
exit ($ERRORS{'UNKNOWN'});
}
unless (defined $opt_timeout) {
$opt_timeout = $DEFAULT_TIMEOUT;
}
unless (defined $opt_snmptimeout) {
$opt_snmptimeout = $DEFAULT_SNMPTIMEOUT;
}
unless (defined $opt_port) {
$opt_port = 161;
}
unless (defined $opt_checkperiod) {
$opt_checkperiod = DEFAULT_CHECKPERIOD;
}
if ($opt_snmpdebug) {
$g_snmpdebug = DEBUG_ALL;
}else{
$g_snmpdebug = DEBUG_NONE;
}
if ($opt_desthosts) {
my @a_dh=split(',',$opt_desthosts);
foreach my $dh (@a_dh) {
$h_desthosts->{$dh}="";
}
}
my ($IsdnOpen);
($IsdnOpen)=split(',',$opt_warn);
$h_para->{IdsnOpenTimeWarn}=$IsdnOpen;
($IsdnOpen)=split(',',$opt_crit);
$h_para->{IdsnOpenTimeCrit}=$IsdnOpen;
return ($ERRORS{'OK'});
}
#--------------------------------------------------------------------------
sub print_usage {
#--------------------------------------------------------------------------
print "Usage: $PROGNAME [-h] [-L] [-t ] [-T ] [-v] [-V] [-C ] [-p ] [-s snmpv1|snmpv2c] -H [-I ] [-P ] -w -c \n";
}
#--------------------------------------------------------------------------
sub print_help {
#--------------------------------------------------------------------------
print_revision($PROGNAME,$REVISION);
printf ("\n");
print_usage();
printf ("\n");
printf (" Check ISDN Lines via SNMP\n");
printf (" using Cisco Mib CISCO-CALL-HISTORY\n\n");
printf ("-t (--timeout) Timeout in seconds (default = %d)\n",$DEFAULT_TIMEOUT);
printf ("-T (--snmptimeout) SNMP CallTimeout in seconds (default = %d)\n",$DEFAULT_SNMPTIMEOUT);
printf ("-H (--hostname) Host to monitor\n");
printf ("-I (--idesthost) Check ISDN Destination Hostname (multiple possible)\n");
printf ("-s (--snmpvers) SNMP Version [snmpv1|snmpv2c]\n");
printf ("-C (--community) SNMP Community\n");
printf ("-p (--port) SNMP Port\n");
printf ("-P (--checkperiod) Timewindow to check of open lines (default = %d secs)\n",DEFAULT_CHECKPERIOD);
printf ("-w (--warn) Parameters warning\n");
printf ("-c (--crit) Parameters critical\n");
printf ("-h (--help) Help\n");
printf ("-V (--version) Programm version\n");
printf ("-v (--verbose) Print some useful information\n");
printf ("-L (--license) Print license information\n");
printf ("\n\n");
}
#--------------------------------------------------------------------------
sub print_Single_OIDs {
#--------------------------------------------------------------------------
my ($table)=@_;
printtable ("CISCO ISDN OIDs");
my $translated;
foreach my $key (oid_lex_sort(keys (%{$table}))) {
$translated=$key;
if (TRANSLATE_OIDs) {
$translated=SNMP::translateObj($translated);
}
printtabular($translated,$table->{$key});
}
}
#--------------------------------------------------------------------------
sub print_History_Table {
#--------------------------------------------------------------------------
my ($table)=@_;
printtable ("CISCO ISDN History Table");
my $translated;
foreach my $key (oid_lex_sort(keys (%{$table}))) {
$translated=$key;
if (TRANSLATE_OIDs) {
$translated=SNMP::translateObj($translated);
}
printtabular($translated,$table->{$key});
}
}
#--------------------------------------------------------------------------
sub printhead {
#--------------------------------------------------------------------------
my ($l_head)=@_;
printf ("\n%-40s\n",$l_head);
}
#--------------------------------------------------------------------------
sub printtable {
#--------------------------------------------------------------------------
my ($l_head)=@_;
printf ("\n%-40s\n",$l_head);
my $len=length($l_head);
my $line="=" x $len;
printf ("%-40s\n",$line);
}
#--------------------------------------------------------------------------
sub printscalar {
#--------------------------------------------------------------------------
my ($l_arg,$l_val)=@_;
printf ("%-35s: %-30s\n",$l_arg,$l_val);
}
#--------------------------------------------------------------------------
sub printtabular {
#--------------------------------------------------------------------------
my ($l_arg,$l_val)=@_;
printf ("%-50s: %s\n",$l_arg,$l_val);
}
#--------------------------------------------------------------------------
sub print_gpl {
#--------------------------------------------------------------------------
print <.
EOD
}
#--------------------------------------------------------------------------
sub print_revision {
#--------------------------------------------------------------------------
my ($l_prog,$l_revision)=@_;
print <
for more information call:
check_cisco_isdn -h
=head1 AUTHOR
Herbert Stadler, Austria (hestadler@gmx.at)
May 2009
This plugin is a contribution to the nagios community.
=head1 REQUIRED SOFTWARE
from search.cpan.org
Net::SNMP Package e.g: Net-SNMP-5.2.0.tar.gz
Used MIB (not necessary for executing the script)
CISCO-CALL-HISTORY-MIB
easy to find on "http://tools.cisco.com"
=head1 HOW TO CHECK THE ROUTER-SNMP FUNCTIONALITY
snmpwalk -v 1 -c public 1.3.6.1.4.1.9.9.27
should return a lot of lines
=head1 CHECK ROUTER CONFIGURATION
please check the following router parameters:
HistoryTableMaxLength
"The upper limit on the number of entries that the
HistoryTable may contain. A value of 0
will prevent any history from being retained. When
this table is full, the oldest entry will be deleted
and the new one will be created."
HistoryRetainTimer
"The minimum amount of time that an HistoryEntry
will be maintained before being deleted. A value of
0 will prevent any history from being retained, but
will not prevent callCompletion traps being genarated."
=head1 CHECK PLUGIN FUNCTIONALITY VIA COMMANDLINE
example:
//check_cisco_isdn -H 10.37.116.2 -w 10 -c 20 -C public -v -P 300
Checking of last 300 seconds if isdn-line is longer than 10/20 seconds open.
Normally the router returns a lot of "ISDN-Destinations" if you want to check only one destination use parameter "-I". Multiple Entries are possible separated by ",".
//check_cisco_isdn -H 10.37.116.2 -w 10 -c 20 -C public -v -P 300 -I
=head1 CONFIGURATION IN NAGIOS
Copy this plugin to the nagios plugin installation directory
e.g.: /usr/lib(64)/nagios/plugins
COMMAND DEFINITION:
# "check_cisco_isdn" command definition
define command{
command_name check_cisco_isdn
command_line $USER1$/check_cisco_isdn -H $HOSTADDRESS$ -w "$ARG1$" -c "$ARG2$" -P "$ARG3$" -C "$ARG4$"
}
=head1 PLUGIN HISTORY
Version 1.0 - 2009-05-18 first release
=head1 COPYRIGHT AND DISCLAIMER
Copyright (C) 2009 by Herbert Stadler
email: hestadler@gmx.at
License Information:
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 .
=cut