#!/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