File Coverage

blib/lib/Cisco/Accounting.pm

Criterion	Covered	Total	%
statement	18	226	7.9
branch	0	98	0.0
condition	0	34	0.0
subroutine	6	24	25.0
pod	12	12	100.0
total	36	394	9.1

package Cisco::Accounting;

## ----------------------------------------------------------------------------------------------
## Cisco::Accounting
##
## Cisco and IPCAD ip accounting parser and aggregator
##
## $Id: Accounting.pm 125 2007-08-18 22:10:25Z mwallraf $
## $Author: mwallraf $
## $Date: 2007-08-19 00:10:25 +0200 (Sun, 19 Aug 2007) $
##
## This program is free software; you can redistribute it and/or
## modify it under the same terms as Perl itself.
## ----------------------------------------------------------------------------------------------


our $VERSION = '1.01';

use warnings;
use strict;
use Carp;
#use Data::Dumper; ## for debugging only

require 5.002;

use Net::Telnet::Wrapper;

use Cisco::Accounting::Interface;	## object that represents a single interface
use Cisco::Accounting::Data;		## object that represents the parsed accounting data



sub new()  {
	my ($this, %parms) = @_;
	my  $class = ref($this) || $this;
	my  $self = {};

	$self->{'session'} = '';	# this will contain our session to Net::Telnet::Wrapper

	$self->{'host'} = $parms{'host'} || "";		# router to connect to
	$self->{'user'} = $parms{'user'} || "";		# login username
	$self->{'pwd'} = $parms{'pwd'} || "";		# login password
	$self->{'tacacs'} = $parms{'tacacs'} || "";		# tacacs password
	$self->{'enable_user'} = $parms{'enable_user'} || "";	# enable username
	$self->{'enable_pwd'} = $parms{'enable_pwd'} || "";	# enable password
	$self->{'persistent'} = (defined($parms{'persistent'}))?($parms{'persistent'}):(1);	# if enabled then we don't close any sessions unless close() is called
	$self->{'lastpoll_details'} = $parms{'lastpoll_details'} || 0;

	$self->{'interfaces'} = [];	# array of Cisco::Accounting::Interface objects
	$self->{'data'} = '';		# this will contain the output (Cisco::Accounting::Data object)
	$self->{'lastpoll_data'} = '';

	$self->{'acct_type'} = $parms{'acct_type'} || "cisco";	# "cisco" ip accounting, "ipcad" is also -limited- supported
	$self->{'keep_history'} = (defined($parms{'keep_history'}))?($parms{'keep_history'}):(1);	# keep summarized historical data for each poll

	$self->{'telnet_options'} = $parms{'telnet_options'};

	bless($self, $class);
	&_init($class);
	return($self);
}


# initialization
sub _init  {
	my $class=shift;
}


##
## fetch all interfaces on a cisco device that support ip accounting
## returns array of Cisco::Accounting::Interface objects
## this procedured should be used with eval {}
##
sub get_interfaces()  {
	my ($self) = shift;

	my $disconnect;
	my @interfaces;	# resulting array of Cisco::Accounting::Interface objects

	eval {
		if (!$self->{'session'})  {
			$disconnect = 1;
			## make a connection to the device
			$self->_connect();
		}

		## get the interface information
		if ($self->{'acct_type'} =~ /cisco/i)  {
			my @result = $self->{'session'}->cmd("show ip int");
			@interfaces = &_parse_cisco_interfaces(\@result) if (scalar @result);
		}
		elsif ($self->{'acct_type'} =~ /ipcad/i)  {
			my @result = $self->{'session'}->cmd("rsh localhost stat");
			@interfaces = &_parse_ipcad_interfaces(\@result) if (scalar @result);
		}

		## close the connection again
		if ( ($disconnect > 0) && ($self->{'persistent'} <= 0) )  {
			$self->_disconnect();
		}
	};
	if ($@)  {
		croak $@;
	}

	@{$self->{'interfaces'}} = @interfaces;

	return @{$self->{'interfaces'}};
}


##
## Disable ip accounting on one or more interfaces
## parameters = array of interface id's as known in $self->{'interfaces'}
## ** this assumes you've run get_interfaces first ! **
## ** this assumes that you have enough rights to go to config mode **
##
sub enable_accounting()  {
	my ($self) = shift;
	my (@int_id) = @_;

	$self->_modify_accounting_settings(1, @int_id);
}


##
## Disable ip accounting on one or more interfaces
## parameters = array of interface id's as known in $self->{'interfaces'}
## ** this assumes you've run get_interfaces first ! **
## ** this assumes that you have enough rights to go to config mode **
##
sub disable_accounting()  {
	my ($self) = shift;
	my (@int_id) = @_;

	$self->_modify_accounting_settings(0, @int_id);
}



##
## parse output of 1 poll (show ip accounting) and update $self->{'data'}
## returns the reference to the output
## this procedure should be used with eval{}
##
sub do_accounting()  {
	my ($self) = shift;

	my (@output);
	my $disconnect = 0;

	# if the connection is not yet active then we assume that it has to be closed again
	if (!$self->{'session'})  {
		$disconnect = 1;
		eval {
			$self->_connect();
		};
		if ($@)  {
			croak $@;
		}
	}

	eval {
		if ($self->{'acct_type'} =~ /cisco/i)  {
			@output = $self->{'session'}->cmd("show ip accounting");
		}
		elsif ($self->{'acct_type'} =~ /ipcad/i)  {
			@output = $self->{'session'}->cmd("rsh localhost show ip accounting");
		}
	};
	if ($@) {
		## if this failed we assume that our connection was lost
		$self->{'session'} = '';
		croak $@;
	}


	## create a new Cisco::Accounting::Data object if needed
	if (!$self->{'data'})  {
		$self->{'data'} = Cisco::Accounting::Data->new('keep_history' => $self->{'keep_history'});
	}
	$self->{'data'}->parse(\@output);

	## check if we need to store lastpoll_data details
	if ($self->{'lastpoll_details'} > 0)  {
		$self->{'lastpoll_data'} = Cisco::Accounting::Data->new('keep_history' => 0);
		$self->{'lastpoll_data'}->parse(\@output);
	}

	if ( ($disconnect > 0) && ($self->{'persistent'} <= 0) )  {
		$self->_disconnect();
	}

	return $self->{'data'}->get_data();
}


##
## returns a reference to the output
##
sub get_output()  {
	my ($self) = shift;

	if ($self->{'data'})  {
		return $self->{'data'}->get_data();
	}
	else  {
		return 0;
	}
}


##
## returns a reference to the output
##
sub get_lastpoll_output()  {
	my ($self) = shift;

	if ($self->{'lastpoll_data'})  {
		return $self->{'lastpoll_data'}->get_data();
	}
	else  {
		return 0;
	}
}

##
## return reference to hash with polling statistics
##
sub get_statistics()  {
	my ($self) = shift;

	if ($self->{'data'})  {
		return	$self->{'data'}->get_stats();
	}
	else  {
		return 0;
	}
}


##
## return reference to hash with polling statistics
##
sub get_history()  {
	my ($self) = shift;

	if ($self->{'data'})  {
		return	$self->{'data'}->get_history();
	}
	else  {
		return 0;
	}
}

##
## clears the output buffer
##
sub clear_output()  {
	my ($self) = shift;

	$self->{'data'} = '';
}


##
## clears ip accounting information on the remote device
## this procedure should be used with eval {}
##
sub clear_accounting()  {
	my ($self) = shift;

	my $disconnect = 0;

	# if the connection is not yet active then we assume that it has to be closed again
	if (!$self->{'session'})  {
		$disconnect = 1;
		eval {
			$self->_connect();
		};
		if ($@)  {
			croak $@;
		}
	}

	eval {
		if ($self->{'acct_type'} =~ /cisco/i)  {
			$self->{'session'}->cmd('clear ip accounting');
		}
		elsif ($self->{'acct_type'} =~ /ipcad/i)  {
			my @output = $self->{'session'}->cmd("rsh localhost clear ip accounting");
			if (  grep { $_ =~ /permission denied/i } @output)  {
				croak "cannot clear ip accounting : permission denied";
			}
		}
	};
	if ($@) {
		croak $@;
	}

	if ( ($disconnect > 0) && ($self->{'persistent'} <= 0) )  {
		$self->_disconnect();
	}
}


##
## Send a keepalive (new line character), do not do any error checking here
## Useful if 'persistent' is enabled, but still it's up to you to call the keepalive in time before session times out
##
sub keepalive()  {
	my ($self) = shift;

	if ($self->{'session'})  {
		eval  {
			$self->{'session'}->cmd(" ");
		};
	}
}




### TODO: do not go to config mode unless really needed

##
## Enable (1) or Disable (0) ip accounting depending on $status
##
sub _modify_accounting_settings()  {
	my ($self) = shift;
	my ($status) = shift;
	my (@int_id) = @_;

	## IPCAD interfaces are always enabled
	if ($self->{'acct_type'} =~ /ipcad/i)  {
		## nothing to do
		return;
	}

	## first check if we need to do something
	next unless ((scalar @int_id) > 0);
	next unless ((scalar @{$self->{'interfaces'}}) > 0);

	my $disconnect = 0;
	my ($id, $int);

	# if the connection is not yet active then we assume that it has to be closed again
	if (!$self->{'session'})  {
		$disconnect = 1;
		eval {
			$self->_connect();
		};
		if ($@)  {
			croak $@;
		}
	}

	eval {
		if ($self->{'acct_type'} =~ /cisco/i)  {
			## go to config mode
			$self->{'session'}->config();
			foreach $int (@{$self->{'interfaces'}})  {
				## only enable/disable ip accounting if needed
				if ((grep { $int->get_id() =~ /^$_$/}  @int_id) && ($int->get_accounting_status() != $status))  {
					$self->{'session'}->cmd('interface '.$int->get_interface());
					my $set_no = "";
					$set_no = "no" unless ($status > 0);
					$self->{'session'}->cmd("$set_no ip accounting output-packets");
					$self->{'session'}->cmd('exit');
					# change the interface status
					$int->set_accounting_status($status);
				}
			}
			## quit config mode
			$self->{'session'}->cmd('exit');
		}
	};
	if ($@) {
		croak $@;
	}

	if ( ($disconnect > 0) && ($self->{'persistent'} <= 0) )  {
		$self->_disconnect();
	}
}


##
## open a new telnet connection, login and save session in $self->{'session'}
##
sub _connect()  {
	my ($self) = shift;

	my $device_class;
	my $enable = 1;

	if ($self->{'acct_type'} =~ /cisco/i)  {
		$device_class = "Cisco::IOS";
		$enable = 1;
	}
	elsif ($self->{'acct_type'} =~ /ipcad/i)  {
		$device_class = "Unix::General";
		$enable = 0;
	}

	## open a new connection
	eval {
		$self->{'session'} = Net::Telnet::Wrapper->new('device_class' => $device_class, -host => $self->{'host'}, %{$self->{'telnet_options'}});
	};
	if ($@)  {
		$self->{'session'} = '';
		croak "Unable to connect to device ".$self->{'host'};
	}

	## login to enable mode
	eval {
		$self->{'session'}->login( 'name' => $self->{'user'}, 'passwd' => $self->{'pwd'}, 'Passcode' => $self->{'passcode'});
		if ($enable)  {
			$self->{'session'}->enable( 'name' => $self->{'enable_user'}, 'passwd' => $self->{'enable_pwd'}, 'Passcode' => $self->{'passcode'});
		}
	};
	if ($@)  {
		croak "Unable to login to device ".$self->{'host'};
	}
}


##
## close telnet connection, remove session from $self->{'session'}
##
sub _disconnect()  {
	my ($self) = shift;

	return unless ($self->{'session'});

	eval {
		$self->Quit();
	};

	$self->{'session'} = '';
}



##
## fetch all interfaces on a cisco device that support ip accounting
## returns array of Cisco::Accounting::Interface objects
##
sub _parse_cisco_interfaces()  {
	my ($interfaces) = shift;

	my ($int);
	my (@result);
	my ($current_int);
	my ($current_enabled);
	my ($id) = 0;

	foreach $int (@{$interfaces})  {
		$int =~ s/\n//;

		# new interface found, only fetch interfaces that support ip accounting
		if ($int =~ /^(\S+)/)  {
			$current_int = $1;
		}
		elsif ($int =~ /IP output packet accounting is/i)  {
			if ($int =~ /enabled/i)  {
				$current_enabled = 1;
			}
			else  {
				$current_enabled = 0;
			}

			my $interface = Cisco::Accounting::Interface->new($id, $current_int, $current_enabled);
			push(@result, $interface);
			$id++;
			$current_int = "";
			$current_enabled = "";
		}
	}

	return @result;
}



##
## fetch all interfaces from a host running IPCAD
## returns array of Cisco::Accounting::Interface objects
##
sub _parse_ipcad_interfaces()  {
	my ($interfaces) = shift;

	my ($int);
	my (@result);
	my ($current_int);
	my ($current_enabled);
	my ($id) = 0;

	foreach $int (@{$interfaces})  {
		$int =~ s/\n//;

		# new interface found, these interfaces ALWAYS have ip accounting enabled ??  TODO: need to verify this
		if ($int =~ /Interface (.*):/i)  {
			$current_int = $1;
			$current_enabled = 1;

			my $interface = Cisco::Accounting::Interface->new($id, $current_int, $current_enabled);
			push (@result, $interface);
			$id++;
			$current_int = "";
			$current_enabled = "";
		}
	}

	return @result;
}

1;  # End of Cisco::Accounting


__END__