#!/usr/bin/perl

=pod

=head1 NAME

checkbandwidth - Alert on bandwidth high/low levels for a host/interface

=head1 DESCRIPTION

The checkbandwidth script uses the perl SNMP module to collect, store

and analyze date from the IF-MIB::ifXTable for the ifHCInOctets and

ifHCOutOctets counters.  It can be configured with high/low levels and

issue warnings, either through email or via output text and exit

codes.  Specifically, the exit codes (1 = warning, 2 = error) and text

output are designed to be used with Nagios.  It calculates bandwidth

by comparing the values from the last run against the values from the

current run and the amonut of time that has passeed between the two

runs [i.e. bandwidth = (this_run - last_run)/time].  Because we need

data from two runs, the first time it is run after configuration will

never detect an error until the second run.

Data is stored in ~/.snmp/checkbandwidth.json, which can be

removed/unlinked to reset the command's data store if needed.  Or the

-r switch can be used to just reset the data without wiping the

configuration.

=head1 SYNOPSIS

1) Setup your snmp.conf file with authentication parameters for your system:

    # snmpconf -g basic_setup

2) Add the interface on the host you want monitor, along with an optional

"threshold" parameters that you want to be warned about:

    # checkbandwidth --add-interface eth0 \

                     --max-in-bandwidth 300000=admin@example.com \

                     foo.example.com

3A) Then run the tool against the host on a regular basis (eg, every 5

minutes in cron):

    # checkbandwidth foo.example.com

    foo.example.com  wlan1    49200.1426 in   5538.7522 out (B/s) IO

The numbers reported are the measured bandwidth during this run.  The

"IO" letters are flags letting you know that the (I)nput or (O)utput

values are out of expected range.

3B) Run the tool inside of nagios:

    define command {

           command_name checkbandwidth

           # specific path to vendor_perl is to fix vir's /usr/local installation

           command_line /usr/bin/perl /usr/local/bin/checkbandwidth -L /var/spool/nagios/.snmp/checkbandwidth.json.lock -N -s $ARG1$

    }

=head1 OPTIONS

=head2 Configuration and setup:

=over

=item  -i STRING

=item  --add-interface=STRING

Add this interface to the list of things to report data for.

=item  -I INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

=item  --max-in-bandwidth=INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

=item  -O INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

=item  --max-out-bandwidth=INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

These setup options specify an maximum input and/or output bandwidth that will:

1) When running as a nagios script (using the --nagios flag), the

   script will display an appropriate message and exit with a return

   code based on whether the string passed to the flag is 'nagioswarn'

   or 'nagioscritical'.

2) When run manually or via cron, then the checkbandwidth will send an

   email address to ADDRESS about the error.

The INT field should be the bandwidth above which the error or warning

should occur.  If the :COUNT field is included, no messages will be

sent/generated until at least the COUNT'th time is seen (default: 1).

The frequency of the count is dependent on often often the script gets

called or the loop frequency occurs (--loop).

Note that the --add-interface (-i) flag is required for this flag to be useful.

See the EXAMPLES section below for more usage.

=item  -J INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

=item  --min-in-bandwidth=INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

=item  -Q INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

=item  --min-out-bandwidth=INT[:COUNT]=( 'nagioswarn' | 'nagioscritical' | ADDRESS )

These two are similar to --max-in-bandwidth and --max-out-bandwidth,

but set the low-water mark thresholds for an interface.

=back

=head2 Operation:

=over

=item  -c STRING

=item  --cache-file=STRING

Location to store persistent data file, which is a JSON encoded structure.

This defaults to ~/.snmp/checkbandwidth.json.

=item  -r

=item  --reset

Ignore all past data and restart the statists collection from scratch

for all hosts/interfaces.  This wipes the collected data without

wiping the configuration min/max warning/critical levels.

=item  -l INTEGER

=item  --loop=INTEGER

Run as a daemon and loop forever, displaying bandwidth performing

checks every INTEGER seconds and displaying an output summary line.

=back

=head2 Nagios mode:

The following options only make sense when acting as an interface with

nagios.  An example nagios command definition is as follows:

    define command {

           command_name checkbandwidth

           command_line /usr/local/bin/checkbandwidth -c /var/spool/nagios/.snmp/checkbandwidth.nagios.json -L /var/spool/nagios/.snmp/checkbandwidth.nagios.json.lock -N $ARG1

    }

Note that if you need to specify perl module paths, you'll need to call it as:

    /usr/bin/perl -I /usr/lib64/perl5/vendor_perl/ /usr/local/bin/checkbandwidth

You can then use a service definition such as this one:

    define service {

           service_description  bandwidth

           host_name            localhost

           check_command        checkbandwidth!localhost

           use                  ...

    }

Recommendation: Use a different configuration file for nagios hosts

than other command line usage.

Recommendation: Use a lock file (-L) to ensure that data from two

parallel calls in nagios won't be written to at once, causing the file

to be corrupted.

Recommendation: If you're monitoring a large number of hosts, use a

sepearate configuration file (and lock file) for each host by passing

an argument like -c /var/spool/nagios/.snmp/checkbandwidth.nagios.$ARG1.json

=over

=item  -N

=item  --nagios

Operate in nagios mode, which will display appropriate nagios display

error codes and exit with an exit code that nagios will process.

=item  -s 

=item --nagios-summary

Place a basic summary line of bandwidth in the output even when no

errors are currently present.  Otherwise, the output will simply be

"All interfaces ok"

=item  -L LOCKFILE

=item  --lock-file LOCKFILE

Use this file as a lockfile to ensure multiple checkbandwidth's

running won't try to write to the file at the same time.

=back

=head2 Sending mail on errors from cron

When not in nagios mode, checkbandwidth will send mail if an error

condition is reached.  The following options specify the SMTP server

parameters used to send mail.

=over

=item  -S STRING

=item  --smtp-server=STRING

The hostname or IP address of the SMTP serve to use.

=item  -P INTEGER

=item  --port=INTEGER

The port number of the SMTP server to use.

=item  -F STRING

=item  --from=STRING

The email address to put in the From: line.

=item  -q

=item  --quiet

Don't output data to the terminal (i.e., email only).

=back

=head2 Debugging:

=over

=item  -d

=item  --dump

Dump the raw JSON data when finished.

=item  -v

=item  --verbose

Log (debugging) messages to stderr about what is being done

=item  -n

=item  --noop

Don't store the collected information from the SNMP agent to the

persistent data storage file.  I.E., only compare the results to last time.

[This is highly useful when you just want to check the server from the

command line using a data store configuration cache that is being used

by another daemon (--loop mode) or by nagios], without affecting the

timing between runs]

=back

=head1 EXAMPLES

=head2 Example Setup

With these goals:

* monitor eth0

* send a message to root@localhost when the input bandwidth goes above 50000 B/s

* send a message to ops@localhost when the input bandwidth goes above 100000 B/s

This can be configured as following:

    # checkbandwidth -i eth0 -I 50000=root@localhost localhost

    # checkbandwidth -i eth0 -I 100000=ops@localhost localhost

If we want to add new configuration in the future, say for the output

interface at 50000 but with a minimum number of 3 "times seen", we can do so:

    # checkbandwidth -i eth0 -O 50000:3=root@localhost localhost

Testing it on a regalur basis is as simple as running:

    # checkbandwidth

    localhost       eth0           3907.2973 in        1638.1081 out (B/s)

=head2 Nagios usage example

* monitor eth0

* Alert at nagios 'warning' when the input bandwidth goes above 50000 B/s

* Alert at nagios 'critical' when the input bandwidth goes above 100000 B/s

    # checkbandwidth -i eth0 -I 50000=nagioswarning -O 50000=nagioswarning localhost

    # checkbandwidth -i eth0 -I 50000=nagioscritical -O 50000=nagioscritical localhost

(and you may or may not want to add -s to always include summary information)

=head1 BUGS / TODO

* There is no way to automatically remove a configured option.  IE,

  once an delivery address is designated, there is no way to remove it

  without manually editing the json file.

=head1 AUTHOR

Wes Hardaker <hardaker@users.sourceforge.net>

USC/ISI

=head1 COPYRIGHT and LICENSING

See the Net-SNMP COPYING file for licensing information for this script.

=cut

use JSON;

use Data::Dumper;

use Mail::Sender;

use SNMP;

use Fcntl ':flock';

use strict;

my %opts = (

            c => "$ENV{HOME}/.snmp/checkbandwidth.json",

            S => 'localhost',

            F => 'root',

            P => 25,

            );

my %storage;

my ($NAGIOS_NORMAL, $NAGIOS_WARNING, $NAGIOS_CRITICAL) = (0,1,2);

my $nagiosexit = $NAGIOS_NORMAL;

my $nagiosstr = "";

LocalGetOptions(\%opts,

           ["GUI:separator",     "Configuration and setup:"],

           ["i|add-interface=s", "Add this interface to the list of things to monitor"],

           ["I|max-in-bandwidth=s", "Alert to ADDRESS on bandwidth > INT, COUNT times; STRING format: INT[:COUNT]=ADDRESS"],

           ["O|max-out-bandwidth=s", "Alert to ADDRESS on bandwidth > INT, COUNT times; STRING format: INT[:COUNT]=ADDRESS"],

           ["J|min-in-bandwidth=s", "Alert to ADDRESS on bandwidth < INT, COUNT times; STRING format: INT[:COUNT]=ADDRESS"],

           ["Q|min-out-bandwidth=s", "Alert to ADDRESS on bandwidth < INT, COUNT times; STRING format: INT[:COUNT]=ADDRESS"],

           ["GUI:separator",     "Operation:"],

           ["c|cache-file=s", 	 "Location to store persistent data"],

           ["r|reset",         	 "Ignore all past data and start from scratch for all hosts/interfaces"],

           ["l|loop=i",          "Loop forever, displaying bandwidth every INTEGER seconds"],

           ["GUI:separator",     "Nagios mode:"],

           ["N|nagios",          "Operate in nagios mode, displaying errors/exit code for a given host"],

           ["s|nagios-summary",  "Always include summary information in the nagios output"],

           ["L|lock-file=s",     "Use a lockfile to ensure no simultaneous runs"],

           ["GUI:separator",     "Sending mail:"],

           ["S|smtp-server=s",   "SMTP server to use"],

           ["P|port=i",          "SMTP port to use"],

           ["F|from=s",          "From address to use"],

           ["GUI:separator",     "Debugging:"],

           ["q|quiet",           "Don't output data to the terminal (i.e., email only)"],

           ["d|dump",         	 "Dump the raw JSON data when finished"], 

           ["v|verbose",      	 "Log (debugging) messages to stderr about what is being done"],

           ["n|noop",         	 "Don\'t store persistent data ; compare only to last time"],

          ) || die "Illegal usage; see -h for help";

my @hosts = @ARGV; # remaining arguments should be hosts

my $cache = read_cache();

if ($#hosts == -1) {

	@hosts = keys(%{$cache->{'hosts'}});

	Verbose("loading hosts from cache: ", join(", ", @hosts));

}

my $lockfileh;

if ($opts{'d'}) {

	print to_json($cache, { ascii => 1, pretty => 1}),"\n";

} elsif ($opts{'i'}) {

	add_interface($cache, $opts{'i'}, $opts{'I'}, $opts{'O'}, $opts{'J'}, $opts{'Q'}, \@hosts);

} else {

	# just process per norm

	do {

		if ($opts{'L'}) {

			open($lockfileh, ">>$opts{L}");

			my $have_lock = flock($lockfileh, LOCK_EX | LOCK_NB);

			if (! $have_lock) {

				print STDERR "failed to get lock on $opts{L}\n";

				print "failed to get lock on $opts{L}\n";

				exit($NAGIOS_NORMAL);

			}

		}

		$cache = process_hosts($cache, \@hosts);

		if (defined($opts{'l'})) {

			Output("");

			save_cache($cache);

			sleep($opts{'l'});

		}

	} while ($opts{'l'});

}

save_cache($cache);

if ($lockfileh) {

	unlink($lockfileh);

	flock($lockfileh, LOCK_UN);  # it's ok if it fails

}

nagios_exit() if ($opts{'N'});

sub read_cache {

	# read in the json-based cache file

	my $cache = {};

	my ($buf, $content);

	if (-f $opts{'c'}) {

		Verbose("Reading cache file from '$opts{c}'");

		open(my $cacheh, "<", $opts{'c'});

		while (read($cacheh, $buf, 4096 * 16) > 0) {

			$content .= $buf;

		}

		close($cacheh);

		$cache = from_json($content); # cheap hack

	}

	return $cache;

}

sub process_hosts($$) {

	my ($cache, $hosts) = @_;

	# process hosts

	foreach my $host (sort @$hosts) {

		Verbose("Procesing host '$host'");

		my $sess = get_snmp_session($host);

		# we always want the uptime

		my @vars;

		push @vars, ['sysUpTime',0];

		foreach my $interface (sort keys(%{$cache->{'hosts'}{$host}{'interfaces'}})) {

			push @vars, ['ifHCInOctets', $cache->{'hosts'}{$host}{'interfaces'}{$interface}{'index'}];

			push @vars, ['ifHCOutOctets', $cache->{'hosts'}{$host}{'interfaces'}{$interface}{'index'}];

		}

		my $list = new SNMP::VarList(@vars);

		my $res = $sess->get($list);

		my $sysUpTime = shift @$list;

		my $sysUpTime = $sysUpTime->[2];

		my $sysUpTimeDiff = $sysUpTime - $cache->{'hosts'}{$host}{'sysUpTime'};

		foreach my $interface (sort keys(%{$cache->{'hosts'}{$host}{'interfaces'}})) {

			my $ifHCInOctets = shift @$list;

			my $ifHCOutOctets = shift @$list;

			my $ifData = $cache->{'hosts'}{$host}{'interfaces'}{$interface};

			if ($opts{'r'} ||

			    !exists($ifData->{'data'}{'ifHCInOctets'}) ||

			    !exists($cache->{'hosts'}{$host}{'sysUpTime'}) ||

			    $sysUpTimeDiff < 0) {

				# reset all past data or...

				# no data is collected yet -- just store the sysUpTime

				# XXX: should collect engine boots too

				$ifData->{'data'}{'ifHCInOctets'}  = $ifHCInOctets->[2];

				$ifData->{'data'}{'ifHCOutOctets'} = $ifHCOutOctets->[2];

				Verbose("interface $interface on $host needs to start with new data");

			} else {

				# the great analysis

				my $diffIn  = $ifHCInOctets->[2] - $ifData->{'data'}{'ifHCInOctets'};

				my $diffOut = $ifHCOutOctets->[2] - $ifData->{'data'}{'ifHCOutOctets'};

				Verbose("$interface   in: $ifHCInOctets->[2] - $ifData->{'data'}{'ifHCInOctets'}");

				Verbose("$interface diff: $diffIn/$sysUpTimeDiff = " . (100 * $diffIn/$sysUpTimeDiff) . " B/s");

				Verbose("$interface  out: $ifHCOutOctets->[2] - $ifData->{'data'}{'ifHCOutOctets'}");

				Verbose("$interface diff: $diffOut/$sysUpTimeDiff = " . (100 * $diffOut/$sysUpTimeDiff) . " B/s");

				my $inRate = (100 * $diffIn/$sysUpTimeDiff);

				my $outRate = (100 * $diffOut/$sysUpTimeDiff);

				my $inMarker = " ";

				my $outMarker = " ";

				# check maximum bandwidth limits

				if (defined($ifData->{'maxInBandwidth'})) {

					foreach my $limit (@{$ifData->{'maxInBandwidth'}}) {

						if ($inRate > 0 && $inRate > $limit->{'rate'}) {

							$inMarker = "I";

							$ifData->{'maxInBandwidthCount'} ++;

							if ($ifData->{'maxInBandwidthCount'} == $limit->{'maxcount'} || $opts{'N'}) {

								Verbose("  input too high!!!  $inRate > $limit->{'rate'} ; emailing $limit->{'email'}");

								send_rate_message($limit->{'email'},

								                  $host, $interface, 'in', 'gt',

								                  $ifData->{'maxInBandwidthCount'},

								                  $inRate, $limit->{'rate'});

							}

						} else {

							$ifData->{'maxInBandwidthCount'} = 0;

						}

					}

				}

				if (defined($ifData->{'maxOutBandwidth'})) {

					foreach my $limit (@{$ifData->{'maxOutBandwidth'}}) {

						if ($outRate > 0 && $outRate > $limit->{'rate'}) {

							$outMarker = "O";

							$ifData->{'maxOutBandwidthCount'} ++;

							if ($ifData->{'maxOutBandwidthCount'} == $limit->{'maxcount'} || $opts{'N'}) {

								Verbose("  output too high!!! $outRate > $limit->{'rate'} ; emailing $limit->{'email'}");

								send_rate_message($limit->{'email'},

								                  $host, $interface, 'out', 'gt',

								                  $ifData->{'maxOutBandwidthCount'},

								                  $outRate, $limit->{'rate'});

							}

						} else {

							$ifData->{'maxOutBandwidthCount'} = 0;

						}

					}

				}

				# check minimum bandwidth limits

				if (defined($ifData->{'minInBandwidth'})) {

					foreach my $limit (@{$ifData->{'minInBandwidth'}}) {

						if ($inRate > 0 && $inRate < $limit->{'rate'}) {

							$inMarker = "I";

							$ifData->{'minInBandwidthCount'} ++;

							if ($ifData->{'minInBandwidthCount'} == $limit->{'maxcount'} || $opts{'N'}) {

								Verbose("  input too low!!!  $inRate < $limit->{'rate'} ; emailing $limit->{'email'}");

								send_rate_message($limit->{'email'},

								                  $host, $interface, 'in', 'lt',

								                  $ifData->{'minInBandwidthCount'},

								                  $inRate, $limit->{'rate'});

							}

						} else {

							$ifData->{'minInBandwidthCount'} = 0;

						}

					}

				}

				if (defined($ifData->{'minOutBandwidth'})) {

					foreach my $limit (@{$ifData->{'minOutBandwidth'}}) {

						if ($outRate > 0 && $outRate < $limit->{'rate'}) {

							$outMarker = "O";

							$ifData->{'minOutBandwidthCount'} ++;

							if ($ifData->{'minOutBandwidthCount'} == $limit->{'maxcount'} || $opts{'N'}) {

								Verbose("  output too low!!! $outRate < $limit->{'rate'} ; emailing $limit->{'email'}");

								send_rate_message($limit->{'email'},

								                  $host, $interface, 'out', 'lt',

								                  $ifData->{'minOutBandwidthCount'},

								                  $outRate, $limit->{'rate'});

							}

						} else {

							$ifData->{'minOutBandwidthCount'} = 0;

						}

					}

				}

				Output(sprintf("%-15s %-8s %16.0f in %16.0f out (B/s) %s%s",

				               $host, $interface,

				               $inRate, $outRate,

				               $inMarker, $outMarker));

				# Update the cache data.  Maybe.

				if (! $opts{'n'}) {

					$ifData->{'data'}{'ifHCInOctets'}  = $ifHCInOctets->[2];

					$ifData->{'data'}{'ifHCOutOctets'} = $ifHCOutOctets->[2];

				}

			}

		}

		# store the sysUpTime

		$cache->{'hosts'}{$host}{'sysUpTime'} = $sysUpTime unless ($opts{'n'});

	}

	return $cache;

}

sub add_interface($$$$$) {

	my ($cache, $interface, $maxInBandwidth, $maxOutBandwidth, $minInBandwidth, $minOutBandwidth, $hosts) = @_;

	foreach my $host (@$hosts) {

		Verbose("adding interface $interface to $host");

		my $session = get_snmp_session($host);

		my $tabledata = $session->gettable('ifTable');

		my $found = 0;

		foreach my $key (keys(%$tabledata)) {

			# each key is an interface number; find the matching interface

			if ($tabledata->{$key}{'ifDescr'} eq $interface) {

				# found it!

				Verbose("found $interface on $host at $key; adding it");

				$cache->{'hosts'}{$host}{'interfaces'}{$interface}{'index'} = $key;

				if ($maxInBandwidth) {

					my ($ratespec, $email) = split(/=/, $maxInBandwidth);

					my ($rate, $count)     = split(/:/, $ratespec);

					if (!defined($count)) {

						$rate = $ratespec;

						$count = 1;

					}

					push @{$cache->{'hosts'}{$host}{'interfaces'}{$interface}{'maxInBandwidth'}},

					  { rate => $rate,

					    email => $email,

					    maxcount => $count };

				}

				if ($maxOutBandwidth) {

					my ($ratespec, $email) = split(/=/, $maxOutBandwidth);

					my ($rate, $count)     = split(/:/, $ratespec);

					if (!defined($count)) {

						$rate = $ratespec;

						$count = 1;

					}

					push @{$cache->{'hosts'}{$host}{'interfaces'}{$interface}{'maxOutBandwidth'}},

					  { rate => $rate,

					    email => $email,

					    maxcount => $count};

				}

				if ($minInBandwidth) {

					my ($ratespec, $email) = split(/=/, $minInBandwidth);

					my ($rate, $count)     = split(/:/, $ratespec);

					if (!defined($count)) {

						$rate = $ratespec;

						$count = 1;

					}

					push @{$cache->{'hosts'}{$host}{'interfaces'}{$interface}{'minInBandwidth'}},

					  { rate => $rate,

					    email => $email,

					    maxcount => $count };

				}

				if ($minOutBandwidth) {

					my ($ratespec, $email) = split(/=/, $minOutBandwidth);

					my ($rate, $count)     = split(/:/, $ratespec);

					if (!defined($count)) {

						$rate = $ratespec;

						$count = 1;

					}

					push @{$cache->{'hosts'}{$host}{'interfaces'}{$interface}{'minOutBandwidth'}},

					  { rate => $rate,

					    email => $email,

					    maxcount => $count};

				}

				$found = 1;

				Output("Configured $interface for $host");

			}

		}

		if (!$found) {

			Log("  failed to find interface '$interface' on '$host'");

		}

	}

}

my %session_cache;

sub get_snmp_session($) {

	my ($host) = @_;

	if (exists($session_cache{$host})) {

		return $session_cache{$host};

	}

	my @args;

	if (-f "/etc/snmp/perl/$host.conf") {

		open(CC, "/etc/snmp/perl/$host.conf");

		while (<CC>) {

			next if (/^\s*#/);

			chomp;

			push @args, split();

		}

	}

	# hack to work around perl not handling per-host files correctly

	$session_cache{$host} = new SNMP::Session(DestHost => $host, @args);

	return	$session_cache{$host};

}

sub save_cache($) {

	my ($cache) = @_;

	# save data to the json cache (maybe)

	if (!$opts{'n'}) {

		my $dir = $opts{'c'};

		$dir =~ s/(.*)\/.*/$1/;

		if (! -d $dir) {

			mkdir($dir);

			if (! -d $dir) {

				Log("failed to create directory $dir");

			} else {

				Verbose("note: created directory $dir");

			}

		}

		# XXX: mkdir

		Verbose("Writing cache file to '$opts{c}'"); 

		my $jsondata = to_json($cache);

		open(my $outh, ">", $opts{'c'} . $$);

		print $outh $jsondata,"\n";

		$outh->close();

		rename($opts{'c'} . $$, $opts{'c'});

	}

}

sub send_rate_message($$$$$$) {

	my ($to, $host, $interface, $direction, $highlow, $count, $measured, $max) = @_;

	if ($opts{'N'} && ($to eq 'nagioswarn' || $to eq 'nagioscritical')) {

		# nagios mode ; collect simple output for later

		nagios_collect($to, $host, $interface, $direction, $highlow, $count, $measured, $max);

	} elsif($to ne 'nagioswarn' && $to ne 'nagioscritical') {

		# send email

		my $word = ($highlow eq '>' ? 'exceeded' : 'too low');

		send_message($to,

		             "rate $word: $host/$interface=$direction ($count times)",

		             "Rate limit $word for:\n\n" .

		             "\thost:\t\t$host\n" .

		             "\tinterface:\t$interface ($direction)\n" .

		             "\trate:\t\t$measured\n" .

		             "\tmax allowed:\t$max\n" .

		             "\tcount:\t\t$count times in a row\n");

	}

}

sub send_message($$$) {

	my ($to, $subject, $text) = @_;

	my $sender = new Mail::Sender { smtp => $opts{'S'} ,

	                                port => $opts{'P'},

	                                from => $opts{'F'},

                                  };

	my $status =

	  $sender->MailMsg({

	                    to      => $to,

	                    subject => $subject,

	                    msg     => $text

	                   });

	if ($status < 0) {

		Log("Failed to send mail with error code $status: $Mail::Sender::Error");

	}

}

sub nagios_collect($$$$$$) {

	my ($to, $host, $interface, $direction, $highlow, $count, $measured, $max) = @_;

	if ($to eq 'nagioscritical') {

		$nagiosexit = $NAGIOS_CRITICAL;

	} elsif ($to eq 'nagioswarn' && $nagiosexit < $NAGIOS_CRITICAL) {

		$nagiosexit = $NAGIOS_WARNING;

	}

	$nagiosstr .= sprintf(", %s $direction %16.0f B/s $highlow %s", $interface, $measured, $max);

}

sub nagios_exit() {

	if ($nagiosstr eq '') {

		$nagiosstr = "All interfaces ok: " . join(", ", keys(%{$cache->{'hosts'}{$hosts[0]}{'interfaces'}}));

	} else {

		$nagiosstr =~ s/^, //;

	}

	print $nagiosstr, "\n";

	exit $nagiosexit;

}

sub Verbose {

	if ($opts{'v'}) {

		print STDERR @_, "\n";

	}

}

sub Log {

	print STDERR @_,"\n";

}

sub Output {

	if (! $opts{'q'} && !$opts{'N'}) {

		print @_, "\n";

	}

	if ($opts{'N'} && $opts{'s'}) {

		$nagiosstr .= ", " . join(" ", @_);

	}

}

#### portability for not requiring Getopt::GUI::Long directly

sub LocalGetOptions {

	if (eval {require Getopt::GUI::Long;}) {

		import Getopt::GUI::Long;

		# optional configure call

		Getopt::GUI::Long::Configure(qw(display_help no_ignore_case allow_zero));

		return GetOptions(@_);

	}

	require Getopt::Long;

	import Getopt::Long;

	# optional configure call

	Getopt::Long::Configure(qw(auto_help no_ignore_case));

	GetOptions(LocalOptionsMap(@_));

}

sub LocalOptionsMap {

	my ($st, $cb, @opts) = ((ref($_[0]) eq 'HASH') 

	                        ? (1, 1, $_[0]) : (0, 2));

	for (my $i = $st; $i <= $#_; $i += $cb) {

		if ($_[$i]) {

			next if (ref($_[$i]) eq 'ARRAY' && $_[$i][0] =~ /^GUI:/);

			push @opts, ((ref($_[$i]) eq 'ARRAY') ? $_[$i][0] : $_[$i]);

			push @opts, $_[$i+1] if ($cb == 2);

		}

	}

	return @opts;

}

# Local Variables:

# tab-width: 4

# End: