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

			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