#!/usr/bin/perl
use Getopt::Std;
use DBI;
use Term::ReadLine;
use SNMP;
use AutoLoader;
use IO::File;
BEGIN {
$opts{'t'} = ! eval { require Text::FormatTable; };
$ansicolor = eval { require Term::ANSIColor; };
}
# override some of the functions to force our colorized semantics.
# This is really ugly, but if you pass colorized strings directly to
# Text::FormatTable then it calculates the string lengths incorrectly.
# Children: don't try this at home. We're trained professionals.
if ($colorize) {
eval {
#
# colorized strings.
#
package color_string;
require Term::ANSIColor;
use overload
'""' => \&string_it
;
sub string_it {
if ($_[0][3]) {
if ($_[0][3] == 1) {
return color_it();
} else {
$_[0][3] -= 1;
return $_[0][1];
}
}
return $_[0][1];
}
sub colorize_next {
$_[0][3] = 2;
}
sub color_it {
my $str = $_[1] || $_[0][1];
return $_[0][0] . $str . $_[0][2];
}
sub new {
my $this = [Term::ANSIColor::color($_[2]), $_[1],
Term::ANSIColor::color('reset')];
return bless($this, $_[0]);
}
}
}
if ($opts{'t'} == 0 && $colorize) {
eval {
package Text::FormatTable;
sub _l_box($$)
{
my ($width, $text) = @_;
my $lines = _wrap($width, $text);
map {
if (ref($text) eq "color_string") {
$_ .= $text->color_it($_) . ' 'x($width-length($_));
} else {
$_ .= ' 'x($width-length($_));
}
} @$lines;
return $lines;
}
sub _r_box($$)
{
my ($width, $text) = @_;
my $lines = _wrap($width, $text);
map {
if (ref($text) eq "color_string") {
$_ = ' 'x($width-length($_)) . $text->color_it($_);
} else {
$_ = ' 'x($width-length($_)) . $_;
}
} @$lines;
return $lines;
}
}
}
if (!$ansicolor) {
$begin = $end = "*";
}
$SNMP::use_enums=1;
#defaults
$opts{'d'} = "\t";
$opts{'v'} = 1;
$opts{'l'} = 'authNoPriv';
$params = "";
getopts('hd:tR:u:l:v:a:A:x:X:p:c:t:r:',\%opts);
usage() if ($#ARGV == -1 || $opts{'h'});
my %parammap = {
'v' => 'Version',
'u' => 'SecName',
'a' => 'AuthProto',
'A' => 'AuthPass',
'x' => 'PrivProto',
'X' => 'PrivPass',
'p' => 'RemotePort',
't' => 'Timeout',
'r' => 'Retries',
'c' => 'Community',
'l' => 'SecLevel'
};
foreach my $x (keys(%opts)) {
if ($parammap{$x}) {
$params .= ";ad_SNMP_$parammap{$x}=$x";
}
push @sessparams,$parammap{$x},$x;
}
my $host = shift @ARGV;
$params .= ";ad_SNMP_DestHost=" . $host;
push @sessparms,'DestHost', $host;
# connect to the DBI interface
$AnyData::Storage::SNMP::debugre = $opts{'R'} if ($opts{'R'});
($dbh = DBI->connect("dbi:AnyData:ad_default=SNMP$params"))
|| die "\tConnection problem: $DBI::errstr\n";
$AnyData::Storage::SNMP::debugre = $opts{'R'} if ($opts{'R'});
$prompt = "netsh> ";
load_rcs();
# setup terminal prompter
$ENV{'PERL_RL'}='o=0' if (!exists($ENV{'PERL_RL'}));
# the ornaments are too ugly
$term = new Term::ReadLine 'netsh';
if ($#ARGV >= 0) {
# command line command
netsh(join(" ",@ARGV));
} else {
# interactive shell
while($cmd = $term->readline($prompt)) {
last if ($cmd eq "exit" || $cmd eq "quit" || $cmd eq "q");
netsh($cmd, \%conf);
}
}
# load all configuration files we can find.
sub load_rcs {
if (-f "$ENV{'HOME'}/.snmp/netshrc") {
source_file("$ENV{'HOME'}/.snmp/netshrc");
}
if (-d "$ENV{'HOME'}/.snmp/netsh") {
foreach my $i (glob("$ENV{'HOME'}/.snmp/netsh/*")) {
if (-f "$i" && "$i" !~ /.*(~|.bak)$/) {
source_file("$i");
}
}
}
}
# command definition for sourcing a particular file
sub source_file {
my $fh = new IO::File;
if ($fh->open("<$_[0]")) {
while(<$fh>) {
if (s/<<\s*(\w+)$//) {
my $stopat = $1;
my $lines = $_;
while(<$fh>) {
last if (/$stopat/);
$lines .= $_;
}
$_ = $lines;
}
netsh($_);
}
} else {
print STDERR "no such file: $_[0]\n";
}
}
# export data into an external file
sub my_export {
shift;
if (!$insh) {
my $cmd = "create table exporttable (" . join (" varchar(255), ",@{$sth->{NAME}}) . " varchar(255))";
$exporth->do($cmd);
$cmd = "insert into exporttable values(" . ('?, ' x ($#_)) . "?)";
$insh = $exporth->prepare($cmd);
}
$insh->execute(@_);
}
# the main processing function.
sub netsh {
my $stmt = shift;
chomp($stmt); # remove trailing white space
$stmt =~ s/^\s+//; # remove leading white space
$stmt =~ s/;*$//; # get rid of trailing semicolons
return if ($stmt =~ /^\s*$/);
return if ($stmt =~ /^\s*\#/);
my ($name, $args) = ($stmt =~ /^(\w+)\s*(.*)$/);
#define alias
# print "doing [$multi_alias]: $stmt\n";
if ($name eq "alias" || $multi_alias) {
if ($multi_alias) {
if ($stmt =~ /^prompt\s+(\d+)\s+[\"\'](.+)[\"\']/) {
$aliases{$current_alias}{'prompts'}[$1] = $2;
return;
} elsif ($stmt =~ /^prompt\s+(\d+)\s+(.+)/) {
my $x = $2;
my $spot = $1;
$x =~ s/\s+$//;
$aliases{$current_alias}{'prompts'}[$spot] = "$x ";
return;
} elsif ($stmt =~ /^\s*\}\s*$/) {
$prompt = $oprompt;
$multi_alias = 0;
return;
}
push @{$aliases{$current_alias}{'definition'}},$stmt;
return;
}
$stmt =~ s/^alias\s+//;
if ($args eq "") {
foreach $i (sort keys(%aliases)) {
display_alias($i);
}
return;
}
($name, $args) = ($stmt =~ /^(\w+)\s*(.*)$/);
if ($args eq "") {
display_alias($name);
return;
}
# print "alias: $name $args\n";
if ($args eq "{") {
$oprompt = $prompt;
$prompt = "define $name> ";
$current_alias = $name;
$multi_alias = 1;
$aliases{$name}{'definition'} = [];
return;
}
$aliases{$name}{'definition'} = $args;
return;
}
#eval
if ($name eq "eval") {
eval $args;
return;
}
#eval just vars
if ($name eq "evalvars") {
# print "args1:",$args,"\n";
$args =~ s/\$(\w+)/$$1/eg;
# print "args2:",$args,"\n";
netsh($args);
return;
}
#eval aliases
while (exists $aliases{$name}) {
# print "modified: $stmt -> ";
my @ARGS = split(/\s+/,$args);
my $statements;
if (ref($aliases{$name}{'definition'}) eq "ARRAY") {
$statements = $aliases{$name}{'definition'};
# maybe prompt for values
if ($#{$aliases{$name}{'prompts'}} > -1) {
my $i;
for($i = 1; $i <= $#{$aliases{$name}{'prompts'}}; $i++) {
if (!$ARGS[$i-1] && $term) {
$ARGS[$i-1] =
$term->readline($aliases{$name}{'prompts'}[$i]);
}
}
}
} else {
$statements = [$aliases{$name}{'definition'}];
}
foreach my $stmt (@$statements) {
#print "$stmt -> ";
$stmt =~ s/\\(\d+)/$ARGS[$1-1]/g;
# print "running $stmt\n";
($name, $args) = ($stmt =~ /^(\w+)\s*(.*)$/);
netsh($stmt);
}
return;
}
if ($stmt =~ /^rehash$/) {
load_rcs();
return;
}
my $subfn;
if ($stmt =~ /^eval (.*)/) {
eval $1;
}
if ($stmt =~ s/^printf\s+(\".*\")\s*(.*)/$2/) {
if ($2 eq "") {
print eval $1;
return;
}
$subfn = \&my_printf;
$stmt = $2;
$printfmt = $1;
}
# special show columns statement
if ($stmt =~ /^show columns from (\w+)$/) {
my $mibnode = $SNMP::MIB{$1};
my $entrynode = $mibnode->{children}[0];
if (!defined($mibnode) || !defined($entrynode)) {
print STDERR "no such table: $1\n";
return;
}
if ($opts{'t'}) {
map { print $_->{label},"\n"; } sort { $a->{subID} <=> $b->{subID}} @{$entrynode->{children}};
} else {
$table = Text::FormatTable->new('|r|');
$table->rule('-');
$table->head('Column');
$table->rule('-');
map { $table->row($_->{label}); } sort { $a->{subID} <=> $b->{subID}} @{$entrynode->{children}};
$table->rule('-');
print $table->render();
}
return;
}
if ($stmt =~ /^source\s+(.*)/) {
source_file($1);
return;
}
if ($stmt =~ s/^export\s+(\S+)\s+(.*)/$2/) {
$insh = undef;
unlink($1);
$exporth = DBI->connect('dbi:AnyData:');
$exporth->func('exporttable','CSV',$1,'ad_catalog');
$subfn = \&my_export;
}
if ($stmt =~ /^import\s+(\S+)/) {
my $exporth = DBI->connect('dbi:AnyData:');
$exporth->func('exporttable','CSV',$1,'ad_catalog');
my $selh = $exporth->prepare("select * from exporttable");
$selh->execute();
$old_data = [];
while(my $row = $selh->fetchrow_arrayref) {
push @$old_data, @$row;
}
$selh->finish();
$exporth->disconnect();
return;
}
if ($stmt =~ /^diff\s+(.*)/) {
$running_watch = 2;
netsh($1);
$running_watch = 0;
return;
}
if ($stmt =~ /^watch\s+(.*)/) {
$running_watch = 1;
my $cmd = $1;
my $delay = 1;
my $clear = `clear`;
if ($cmd =~ s/^(\d+)\s+(.*)/$2/) {
$delay = $1;
$cmd = $2;
}
$SIG{'TERM'} = sub { $running_watch = 0; };
$SIG{'INT'} = sub { $running_watch = 0; };
while($running_watch) {
print $clear;
netsh($cmd);
sleep($delay);
}
$SIG{'TERM'} = \&exit;
$SIG{'INT'} = \&exit;
return;
}
# we have an SQL statement. process it.
if ($stmt =~ /^(select|insert|update|delete)/) {
$sth = $dbh->prepare($stmt);
$sth->execute();
if ($stmt =~ /^select/) {
my $table;
my $older_data = $old_data;
if ($running_watch == 1) {
$old_data = [];
}
my $oldcount = 0;
while($row = $sth->fetchrow_arrayref) {
if ($running_watch) {
$newrow=[];
my $count;
for($count = 0; $count <= $#$row; $count++) {
if ($older_data &&
$row->[$count] ne
$older_data->[$oldcount][$count]) {
if ($ansicolor) {
push @$newrow, new color_string($row->[$count],'red');
} else {
push @$newrow,"$begin$row->[$count]$end";
}
} else {
push @$newrow,$row->[$count];
}
if ($running_watch == 1) {
$old_data->[$oldcount][$count] = $row->[$count];
}
}
$oldcount++;
$row = $newrow;
}
# self printing;
if (ref($subfn) eq "CODE") {
&$subfn($printfmt,@$row);
next;
}
if ($opts{'t'}) {
if ($opts{'d'} eq 'xml') {
print " <row>\n";
for(my $xx = 0; $xx < $#{$sth->{NAME}}; $xx++) {
print " <$sth->{NAME}[$xx]>$row->[$xx]</$sth->{NAME}[$xx]>\n";
}
print " </row>\n";
} elsif ($opts{'d'} eq 'xmlshort') {
print " <row ";
for(my $xx = 0; $xx < $#{$sth->{NAME}}; $xx++) {
print " $sth->{NAME}[$xx]=\"$row->[$xx]\"";
}
print "/>\n";
} else {
print join($opts{'d'},@$row),"\n";
}
} elsif (!$table) {
$table = Text::FormatTable->new('|r' x ($#$row+1) . "|");
$table->rule('-');
$table->head(@{$sth->{NAME}});
$table->rule('-');
$table->row(@$row);
} else {
$table->row(@$row);
}
}
if ($table) {
$table->rule('-');
print $table->render();
}
}
$sth->finish();
return;
}
# retrieve just one variable and display it
if ($stmt =~ /^(get|)\s*([^\s]+)\s*[^=]/) {
my $sess = make_session();
if ($sess) {
my @results = split(/[,\s]+/,$stmt);
my $resultsv = new SNMP::VarList();
# expression stolen from the main perl SNMP module
map { my ($tag, $iid) =
(/^((?:\.\d+)+|(?:\w+(?:\-*\w+)+))\.?(.*)$/);
push @$resultsv, [$tag, $iid] } @results;
$sess->get($resultsv) ||
print STDERR "Error: $sess->{ErrorNum} $sess->{ErrString}\n";
@results = ();
map { push @results, $_->[2] } @$resultsv;
if (ref($subfn) eq "CODE") {
&$subfn($printfmt,@results);
} else {
print join(" ", @results),"\n";
}
} else {
print STDERR "could not establish a SNMP session to $host\n";
}
return;
}
# set something
if ($stmt =~ /^(set|)\s*([^\s]+)\s=\s(.*)$/) {
my $sess = make_session();
if ($sess) {
$sess->set([$2,undef,$1]) ||
print STDERR "opps: $sess->{ErrorNum} $sess->{ErrString}\n";
} else {
print STDERR "could not establish a SNMP session to $host\n";
}
return;
}
}
sub auto_snmp {
my $node = $SNMP::MIB{$_[0]};
# print STDERR "netsh::fetch_snmp $_[0] $node->{label}\n";
my $indexes = $node->{parent}{indexes};
if ($#$indexes > -1) {
# print STDERR "column\n";
# table
} else {
# scalar
if (exists($_[1])) {
my $sess = make_session();
my $val = $sess->set([$_[0],0,$_[1]]) || return;
# print STDERR "scalar set: $val\n";
return $val;
} else {
my $sess = make_session();
my $val = $sess->get([$_[0],0]);
# print STDERR "scalar get: $val\n";
return $val;
}
}
}
sub AUTOLOAD {
my $nodename = $AUTOLOAD;
$nodename =~ s/.*:://;
print STDERR "netsh::AUTOLOAD $AUTOLOAD $nodename\n";
if ($SNMP::MIB{$nodename}) {
eval << "END";
sub $AUTOLOAD {
auto_snmp($nodename, \@_);
}
END
goto &$AUTOLOAD;
}
print STDERR join(",",@_),"\n";
}
sub my_printf {
# drop quotes
my $fmt = shift;
$fmt = eval $fmt;
map { if (ref($_) eq "color_string") { $_->colorize_next(); } } @_;
printf($fmt, @_);
}
sub display_alias {
my $name = shift;
if (exists $aliases{$name}{'definition'}) {
if (ref($aliases{$name}{'definition'}) eq "ARRAY") {
print "alias $name {\n";
map { print " $_\n"; } @{$aliases{$name}{'definition'}};
print "}\n";
} else {
print "alias $name $aliases{$name}{'definition'}\n";
}
} else {
print "no alias defined for \"$name\"\n";
}
}
sub make_session {
if (!$sess) {
$sess = new SNMP::Session(@sessparms);
}
return $sess;
}
sub usage {
print STDERR "
$0 [ARGUMENTS] HOSTNAME [SQL_COMMAND]
$0 implements a simple SQL shell which maps onto SNMP. All
statements issued within the shell are converted to SNMP requests and
sent to HOSTNAME and the results displayed in a nice table output
format if the Text::FormatTable module is available. If SQL_COMMAND
is given on the command line, then it's interpreted and control is
returned to the caller. If not, an interactive prompt is given where
multiple commands can be issued.
ARGUMENTS may include:
-t delimiter separated output, don't print pretty tables.
-d DELIM use DELIM as the delimiter. A tab is the default delimiter.
'xml' is a special delimiter to produce xml output.
ARGUMENTS also may include the following. See the net-snmp snmpcmd
manual page for details on what they mean:
-v VERSION (default: 1)
-t TIMEOUT
-r RETRIES
-p PORT
-c COMMUNITY
-a AUTHPROTOCOL (default: MD5)
-x PRIVPROTOCOL (default: DES)
-A AUTHPASS
-X PRIVPASS
-l SECURITY_LEVEL (default: authNoPriv)
";
exit;
}
__END__
=head1 NAME
netsh - A shell environment for interacting with networking devices
=head1 SYNOPSIS
netsh [(subset of) snmpcmd arguments] hostname[,hostname...] [command]
=head1 OPTIONAL PERL MODULES
There are some optional perl modules which make using the shell nicer
in general. These modules are:
Text::FormatTable
Term::ReadLine::Gnu or Term::ReadLine::Perl
Term::ANSIColor
You can install these by running [as root]:
perl -MCPAN -e shell
cpan> install Text::FormatTable
...
It is B<strongly> recommend you at least install the Text::FormatTable
module, and if you like command line editing one of the two extra
Term::ReadLine modules (Gnu being the better of the two).
=head1 DESCRIPTION
The netsh script provides an interactive, console-like environment
suitable for monitoring and manipulating data within networking
devices. The environment is highly extensible through command
aliases and easy-to-use SQL-like queries.
It is implemented on top of the SNMP protocol using the net-snmp
package and perl. See the snmpcmd and snmp.conf manual pages for
details on configuring net-snmp for authentication information for
the networking devices you wish to access.
=head1 ABOUT THE EXAMLPES IN THIS DOCUMENT
All the examples in this document are exact cut-n-pastes from the
inside of the netsh shell. This includes the "netsh> " prompt and
possibly other prompts as well.
=head1 COMMANDS
The following is a list of the basic core commands supported by
netsh. Many default aliases are also supplied, some of which are
listed in the next section. At the command prompt type "alias" for
a full list of all the aliases and their definitions.
=over
=item show columns from TABLE
=item select ...
=item update ...
=item insert ...
=item delete ...
netsh supports the standard sql-like language queries of snmp tables.
These are implemented via the SQL::Statement parser, so any form of
expression it accepts netsh will accept as well.
Examples:
netsh> show columns from ifTable
+-----------------+
| Column|
+-----------------+
| ifIndex|
...
netsh> select * from ifTable
... [output not shown]
netsh> select tcpConnState, tcpConnRemotelAddress from tcpConnTable where tcpConnState = established
... [output not shown]
netsh> update ifTable set ifAdminStatus = up where ifOperStatus = down
... [output not shown]
=item SNMPOBJECT
Simple lists of objects may be given which will directly request or
operate on those objects. See printf below for controlling the
formatting of results
Examples:
netsh> sysContact.0, sysLocation.0
hardaker@somewhere.net my location
netsh> sysContact.0 = my new contact information
=item alias my_command some other command
or
=back
alias my_many_commands {
command1
command2
prompt NUMBER question
}
=over
=item
You can create aliases of your frequently used commands by aliasing
them to an easy to remember name. \N parameters in the defined
command will be replaced by the positional argument of options passed
to the alias name.
For multi-line defined aliases, optional prompts may be given to
request information from the user when the NUMBERth argument is not
given to the alias. If it is not given, the prompt will be printed
and the user will be asked to input a value for it. This allows the
easy definition of interactive commands. The value will be inserted
in alias parts containing \N substitution requests.
netsh> alias interfaces select ifDescr from ifTable
netsh> interfaces
+-------+
|ifDescr|
+-------+
| lo|
| eth0|
+-------+
netsh> alias interface select ifDescr, ifSpeed from ifTable where ifDescr = '\1'
netsh> interface eth0
+-------+--------+
|ifDescr| ifSpeed|
+-------+--------+
| eth0|10000000|
+-------+--------+
=item printf FORMATSTRING COMMAND
Allows B<careful> formatting of results returned by the commands.
Example:
netsh> alias interface {
define interface> printf "interface %s is running at %d Mb/s\n" select ifDescr, ifSpeed from ifTable where ifDescr = '\1'
define interface> prompt 1 Enter the interface to describe:
define interface> }
netsh> interface
Enter the interface to describe: eth0
interface eth0 is running at 10000000 Mb/s
To list the definition of an already defined command, simply exclude
the definition and netsh will report the definition to you:
netsh> alias interface
alias interface {
printf "interface %s is running at %d Mb/s\n" select ifDescr, ifSpeed from ifTable where ifDescr = '\1'
prompt 1 Enter the interface to describe:
}
To list all the aliases defined in the system, just type "alias" by itself.
=item watch [TIME] COMMAND
Continually watches the results of the COMMAND being run, which is run
every TIME seconds. For select statements, it will attempt to mark
the changing values from one screen to the next by surrounding them
with "*"s or color (assuming you have the Term::ANSIColor perl module
installed) for easy picking out on the screen.
=item rehash
Re-load the alias definitions files in the common directory, as
well as those files found in $HOME/.snmp/netsh.
=item source FILE
loads definitons and commands from FILE into the running environment.
=back
=head1 FILES
By default, netsh will source all the definition files it can find.
It does this by first reading everything in
/usr/local/share/snmp/netsh/* and then reading everything in
$HOME/.snmp/netsh/*. Everything contained in these files are
commands, but most frequently they entirely consist of aliases
definitions.
=head1 AUTHOR
bugs, comments, questions to net-snmp-users@lists.sourceforge.net
=head1 Copyright
Copyright (c) 2002 Networks Associates Technology, Inc. All
rights reserved. This program is free software; you can
redistribute it and/or modify it under the same terms as Perl
itself.
=cut