perl/AnyData_SNMP/Storage.pm - vendor/opensource/netsnmp - Git at Google

 #########################################################################
 package AnyData::Storage::SNMP;
 #########################################################################

 ## XXX: TODO:
 ##   scalar sets?
 ##   multi-hosts

 $AnyData::Storage::VERSION = '5.0502';
 use strict;
 use warnings;

 use vars qw(@basecols);

 @AnyData::Storage::SNMP::basecols = qw(hostname iid);
 $AnyData::Storage::SNMP::iidptr = 1; # must match array column of above
 @AnyData::Storage::SNMP::basetypes = qw(OCTETSTR OBJECTID);
 $AnyData::Storage::SNMP::debug = 0;
 $AnyData::Storage::SNMP::debugre = undef;

 use Data::Dumper;
 use AnyData::Storage::File;
 use SNMP;
 SNMP::init_snmp("AnyData::SNMP");

 sub new {
 #    DEBUG("calling AnyData::Storage::SNMP new\n");
 #    DEBUG("new storage: ",Dumper(\@_),"\n");
     my $class = shift;
     my $self  = shift || {};
     $self->{open_mode} = 'c';
     return bless $self, $class;
 }

 sub open_table {
     DEBUG("calling AnyData::Storage::SNMP open_table\n");
     my ($self, $parser, $table, $mode, $tname) = @_;
     $self->{'process_table'} = $tname;
     DEBUG("open_table: ",Dumper(\@_),"\n");
 }

 sub get_col_names {
     DEBUG("calling AnyData::Storage::SNMP get_col_names\n");
     my ($self, $parser, $tname) = @_;
     DEBUG("get_col_names\n",Dumper(\@_),"\n");
     $tname = $self->{'process_table'} if (!$tname);

     # get cached previous results
     return $self->{col_names}{$tname} if (defined($self->{col_names}{$tname}));

     # table name
     $tname = $self->{'process_table'} if (!$tname);

     # mib node setup
     my $mib = $SNMP::MIB{$tname} || return warn "no such table $tname";
     my $entry = $mib->{'children'}[0];

     # base columns and types
     my @cols = @AnyData::Storage::SNMP::basecols;
     my @types = @AnyData::Storage::SNMP::basetypes;
     my %donecol;
     my $count = $#cols;

     foreach my $index (@{$entry->{'indexes'}}) {
 	push @cols, $index;
 	push @types, $SNMP::MIB{$index}{type};
 	$donecol{$index} = 1;
 	$count++;
 	if ($SNMP::MIB{$index}{parent}{label} eq $entry->{label}) {
 	    # this index is a member of this table
 	    $self->{columnmap}[$count] = $index;
 	    $self->{coloffset} += 1;
 	}
     }

     # search children list
     foreach my $child  ( sort { $a->{'subID'} <=> $b->{'subID'} } @{$entry->{'children'}}) {
 	push @{$self->{real_cols}}, $child->{'label'};
 	next if ($donecol{$child->{label}});
 	push @cols, $child->{'label'};
 	push @types, $child->{'type'};
 	$count++;
 	$self->{columnmap}[$count] = $child->{'label'};
     }

     # save for later.
     $parser->{col_names} = \@cols;
     $self->{col_types} = \@types;
     $self->{col_names} = \@cols;
     map { $self->{col_uc_map}{uc($_)} = $_ } @cols;
     return \@cols;
 }

 sub set_col_nums {
     DEBUG("calling AnyData::Storage::SNMP set_col_nums\n");
     DEBUG("set_col_nums\n",Dumper(\@_),"\n");
     my ($self, $tname) = @_;
     return $self->{col_nums} if (defined($self->{col_nums}));
     my $mib = $SNMP::MIB{$tname};
     my $entry = $mib->{'children'}[0];
     my (%cols, %mibnodes);
     my $cnt = -1;

     foreach my $i (@{$self->{col_names}}) {
 	$cols{$i} = ++$cnt;
     }

     $self->{col_nums} = \%cols;
     return \%cols;
 }

 # not needed?
 sub get_file_handle {
     DEBUG("calling AnyData::Storage::SNMP get_file_handle\n");
     DEBUG("get_file_handle\n",Dumper(\@_),"\n");
     return shift;
 }

 # not needed?
 sub get_file_name {
     DEBUG("calling AnyData::Storage::SNMP get_file_name\n");
     DEBUG("get_file_name\n",Dumper(\@_),"\n");
     my $self = shift;
     return $self->{process_table} || $self->{table_name};
 }

 sub truncate {
     DEBUG("calling AnyData::Storage::SNMP truncate\n");
     my ($self) = @_;
     DEBUG("trunacte, ", Dumper(@_));

     # We must know how to delete rows or else this is all pointless.
 #     return $self->{col_nums}{$tname} if (defined($self->{col_nums}{$tname}));
     my $tablemib = $SNMP::MIB{$self->{process_table}};
     my $entrymib = $tablemib->{'children'}[0];
     my ($delcolumn, $delcolumnname, $delcolumnvalue);

     foreach my $child  (@{$entrymib->{'children'}}) {
 	if ($child->{'textualConvention'} eq 'RowStatus') {
 	    $delcolumn = $child->{subID};
 	    $delcolumnname = $child->{label};
 	    $delcolumnvalue = 6; # destroy
 	    last;
 	}
     }
     if (!$delcolumn) {
 	return warn "Can't (or don't know how to) delete from table $self->{process_table}.  Failing.\n";
     }

     # we should have a session, or else something is really wierd but...
     $self->{'sess'} = $self->make_session() if (!$self->{'sess'});

     # for each key left in our cache, delete it
     foreach my $key (keys(%{$self->{'existtest'}})) {
 	# xxx: fullyqualified oid better
 	my $vblist = new SNMP::VarList([$delcolumnname, $key,
 					$delcolumnvalue]);
 	DEBUG("truncate $key: \n", Dumper($vblist));
 	$self->{'sess'}->set($vblist) || warn $self->{'sess'}->{ErrorStr};
     }
     return;
 }

 sub make_session {
     DEBUG("calling AnyData::Storage::SNMP make_session\n");
     my $self = shift;
     my @args = @_;
     my @sessions;
     foreach my $key (qw(SecName Version SecLevel AuthPass Community RemotePort Timeout Retries RetryNoSuch SecEngineId ContextEngineId Context AuthProto PrivProto PrivPass)) {
 	push @args, $key, $self->{$key} if ($self->{$key});
     }
     foreach my $host (split(/,\s*/,$self->{DestHost})) {
 	push @sessions, new SNMP::Session(@args, 'DestHost' => $host);
     }
     return \@sessions;
 }

 sub file2str {
     DEBUG("calling AnyData::Storage::SNMP file2str\n");
     my ($self, $parser, $uccols) = @_;
     my ($cols, @retcols);
     DEBUG("file2str\n",Dumper(\@_),"\n");
   restart:
     if (!$self->{lastnode}) {
 #	my @vbstuff = @{$parser->{'col_names'}};
 #	splice (@vbstuff,0,1+$#AnyData::Storage::SNMP::basecols);
 #	map { $_ = [ $_ ] } @vbstuff;
 #	$self->{lastnode} = new SNMP::VarList(@vbstuff);
 #	splice (@$cols,0,1+$#AnyData::Storage::SNMP::basecols);
 	map { push @$cols,$self->{col_uc_map}{$_} } @$uccols;
 	if ($#$cols == -1) {
 	    $cols = $self->{'col_names'};
 	    # remove base columns
 	    splice (@$cols,0,1+$#AnyData::Storage::SNMP::basecols);
 	    # remove not accessible columns
 	    foreach my $col (@$cols) {
 		my $mib = $SNMP::MIB{$col};
 		push @retcols, $col if ($mib->{'access'} =~ /Read|Create/);
 	    }
 	} else {
 	    @retcols = @$cols;
 	    # remove base columns
 	    foreach my $c (@AnyData::Storage::SNMP::basecols) {
 		@retcols = grep(!/^$c$/, @retcols);
 	    }
 	    # remove non-accessible columns
 	    @retcols = grep {$SNMP::MIB{$_}{'access'} =~ /Read|Create/} @retcols;
 	}
 	map { $_ = [ $_ ] } @retcols;
 	$self->{lastnode} = new SNMP::VarList(@retcols);
     }

     if (!$self->{'sess'}) {
 	$self->{'sess'} = $self->make_session();
 	if ($#{$self->{'sess'}} == 0 && $self->{'silence_single_host'}) {
 	    $self->{'hostname'} = '';
 	} else {
 	    $self->{'hostname'} = $self->{'sess'}[0]{'DestHost'};
 	}
     }

     # perform SNMP operation
     my $lastnode = $self->{'lastnode'}[0][0];
     my $result;
     $result = $self->{'sess'}[0]->getnext($self->{lastnode});
     if (!defined($result)) {
 	warn " getnext of $self->{lastnode}[0][0] returned undef\n";
     }
     DEBUG(" result: ",Dumper($self->{lastnode}),"\n");

     # XXX: check for holes!

     # need proper oid compare here for all nodes
     if ($self->{'lastnode'}[0][0] ne $lastnode) {
 	if ($#{$self->{'sess'}} > 0) {
 	    shift @{$self->{'sess'}};
 	    delete($self->{'lastnode'});
 	    @$cols = ();
 	    $self->{'hostname'} = $self->{'sess'}[0]{'DestHost'} if($self->{'hostname'});
 	    goto restart;
 	}
 	return undef;
     }

     # add in basecols information:
     my @ret = ($self->{'hostname'}, $self->{'lastnode'}[0][1]);
     DEBUG("Dump row results: ",Dumper($self->{'lastnode'}),"\n");

     # build result array from result varbind contents
     map { $ret[$self->{'col_nums'}{$_->[0]}] = map_data($_); } @{$self->{'lastnode'}};

     # store instance ID for later use if deletion is needed later.
     $self->{'existtest'}{$self->{'lastnode'}[0][1]} = 1;

     DEBUG("Dump row results2: ",Dumper(\@ret),"\n");
     return \@ret;
 }

 sub map_data {
     if ($_->[3] eq "OBJECTID") {
 	$_->[2] = pretty_print_oid(@_);
     }
     return $_->[2];
 }

 sub pretty_print_oid {
     use NetSNMP::default_store qw(:all);
     netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
 			   NETSNMP_DS_LIB_DONT_BREAKDOWN_OIDS,0);
     my $new = SNMP::translateObj($_->[2], 0);
     netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
 			   NETSNMP_DS_LIB_DONT_BREAKDOWN_OIDS,1);
     my $new2 = SNMP::translateObj($_->[2], 0);
     if ($new) {
 	$_->[2] = $new2 . "$new";
     } else {
 	$_->[2] = $_->[0] . $_->[1];
     }
     return $_->[2];
 }

 sub push_row {
     DEBUG("calling AnyData::Storage::SNMP push_row\n");
     DEBUG("push_row: ",Dumper(\@_),"\n");
     DEBUG("push_row\n");
     my ($self, $values, $parser, $cols) = @_;
     my @callers = caller(3);
     my $mode = $callers[3];
     if ($mode =~ /DELETE/) {
 	DEBUG("not deleting $values->[$AnyData::Storage::SNMP::iidptr]\n");
 	delete $self->{'existtest'}{$values->[$AnyData::Storage::SNMP::iidptr]};
 	return;
     }

     my @origvars;
     if ($#$cols == -1) {
 	# no column info passed in.  Update everything (mode probably INSERTS).
 #	@origvars = @{$self->{'col_names'}}};
 #	splice (@origvars,0,1+$#AnyData::Storage::SNMP::basecols);

 	map { push @origvars, $_ if $SNMP::MIB{$_}{'access'} =~ /Write|Create/; } @{$self->{'real_cols'}} ;

 	DEBUG("set cols: ", Dumper(\@origvars));
     } else {
 	# only update the columns in question.  (mode probably UPDATE)
 	map { push @origvars, $self->{col_uc_map}{$_} } @$cols;
     }

     my @vars;
     foreach my $var (@origvars) {
 	my $access = $SNMP::MIB{$var}{'access'};
 	# not in this table, probably (hopefully) an index from another:
 	next if ($SNMP::MIB{$var}{'parent'}{'parent'}{'label'} ne
 		 $self->{process_table});
 	DEBUG("$var -> $access\n");
 	if ($access =~ /(Write|Create)/) {
 	    push @vars, $var;
 	} elsif ($mode eq 'insert') {
 	    DEBUG("XXX: error if not index\n");
 	} elsif ($mode eq 'update') {
 	    DEBUG("update to non-writable column attempted (SNMP error coming)\n");
 	}
     }

     # generate index OID component if we don't have it.
     if ($values->[$AnyData::Storage::SNMP::iidptr] eq '') {
 	$values->[$AnyData::Storage::SNMP::iidptr] =
 	    $self->make_iid($self->{process_table}, $values);
     }

     # add in values to varbind columns passed in from incoming parameters
     my @newvars;
     foreach my $v (@vars) {
 	my $num = $self->{'col_nums'}{$v};
 	DEBUG("types: $v -> $num -> ", $self->{'col_types'}[$num],
 	      " -> val=", $values->[$num], "\n");
 	next if (!defined($values->[$num]));
 	# build varbind: column-oid, instance-id, value type, value
 	push @newvars, [$v, $values->[1], $values->[$num],
 			$self->{'col_types'}[$num]];
     };

     # create the varbindlist
 #    print STDERR Dumper(\@newvars);
     my $vblist = new SNMP::VarList(@newvars);

 #    print STDERR Dumper($vblist);
     DEBUG("set: ", Dumper($vblist));
     $self->{'sess'} = $self->make_session() if (!$self->{'sess'});
     if (!$self->{'sess'}[0]) {
 	warn "couldn't create SNMP session";
     } elsif (!$self->{'sess'}[0]->set($vblist)) {
 	my $err = "$self->{process_table}: " . $self->{'sess'}[0]->{ErrorStr};
 	if ($self->{'sess'}[0]->{ErrorInd}) {
 	    $err = $err . " (at varbind #"
 		. $self->{'sess'}[0]->{ErrorInd}  . " = " ;
 	    my $dump = Data::Dumper->new([$vblist->[$self->{'sess'}[0]->{ErrorInd} -1]]);
 	    $err .= $dump->Indent(0)->Terse(1)->Dump;
 	}
 	warn $err;
     }
 }

 sub seek {
     DEBUG("calling AnyData::Storage::SNMP seek\n");
     my ($self, $parser) = @_;
     DEBUG("seek\n",Dumper(\@_),"\n");
 }

 sub make_iid {
     DEBUG("calling AnyData::Storage::SNMP make_iid\n");
     my ($self, $tname, $vals) = @_;

     # Get indexes
     my $mib = $SNMP::MIB{$tname};
     my $entry = $mib->{'children'}[0];
     my $indexes = $entry->{'indexes'};
     my $iid;

     # XXX: implied

 #    print STDERR "INDEXES: ", Dumper($vals),"\n";
     foreach my $index (@$indexes) {
 	warn "A null index value was found, which I doubt is correct." if (!defined($vals->[$self->{col_nums}{$index}]));
 	my $val = $vals->[$self->{col_nums}{$index}];
 	my $type = $SNMP::MIB{$index}->{'type'};
 	DEBUG("index type: $index -> $type -> $val -> " . length($val) . "\n");
 	if ($type eq "OCTETSTR") {
 	    $iid .= "." . length($val) . "." . join(".", unpack("c*", $val));
 	} elsif ($type eq "OBJID") {
 	    $iid .= "." . (scalar grep(/\./,$val) + 1) . "." . $val;
 	} else {
 	    # should be only an INTEGER?
 	    $iid .= "." . $val;
 	}
     }
     DEBUG("made iid: $iid\n");
     return $iid;
 }

 sub DEBUG {
     my @info = caller(1);
     if ($AnyData::Storage::SNMP::debug
 	|| ($AnyData::Storage::SNMP::debugre &&
 	    $_[0] =~ /$AnyData::Storage::SNMP::debugre/)) {
 	DEBUGIT(\@info, @_);
     }
 }

 sub DEBUGIT {
     my $info;
     if (ref($_[0]) eq 'ARRAY') {
 	$info = shift @_;
     } else {
 	my @y;
 	my $c=0;
 	print STDERR "debug chain: ";
 	for(@y = caller($c); $#y > -1; $c++, @y = caller($c)) {
 	    print STDERR "  $c: $y[3]\n";
 	}
 	my @x = caller(1);
 	$info = \@x;
     }
     print STDERR "$info->[3]: ";
     print STDERR @_;
 }

 1;
	#########################################################################
	package AnyData::Storage::SNMP;
	#########################################################################

	## XXX: TODO:
	## scalar sets?
	## multi-hosts

	$AnyData::Storage::VERSION = '5.0502';
	use strict;
	use warnings;

	use vars qw(@basecols);

	@AnyData::Storage::SNMP::basecols = qw(hostname iid);
	$AnyData::Storage::SNMP::iidptr = 1; # must match array column of above
	@AnyData::Storage::SNMP::basetypes = qw(OCTETSTR OBJECTID);
	$AnyData::Storage::SNMP::debug = 0;
	$AnyData::Storage::SNMP::debugre = undef;

	use Data::Dumper;
	use AnyData::Storage::File;
	use SNMP;
	SNMP::init_snmp("AnyData::SNMP");

	sub new {
	# DEBUG("calling AnyData::Storage::SNMP new\n");
	# DEBUG("new storage: ",Dumper(\@_),"\n");
	my $class = shift;
	my $self = shift \|\| {};
	$self->{open_mode} = 'c';
	return bless $self, $class;
	}

	sub open_table {
	DEBUG("calling AnyData::Storage::SNMP open_table\n");
	my ($self, $parser, $table, $mode, $tname) = @_;
	$self->{'process_table'} = $tname;
	DEBUG("open_table: ",Dumper(\@_),"\n");
	}

	sub get_col_names {
	DEBUG("calling AnyData::Storage::SNMP get_col_names\n");
	my ($self, $parser, $tname) = @_;
	DEBUG("get_col_names\n",Dumper(\@_),"\n");
	$tname = $self->{'process_table'} if (!$tname);

	# get cached previous results
	return $self->{col_names}{$tname} if (defined($self->{col_names}{$tname}));

	# table name
	$tname = $self->{'process_table'} if (!$tname);

	# mib node setup
	my $mib = $SNMP::MIB{$tname} \|\| return warn "no such table $tname";
	my $entry = $mib->{'children'}[0];

	# base columns and types
	my @cols = @AnyData::Storage::SNMP::basecols;
	my @types = @AnyData::Storage::SNMP::basetypes;
	my %donecol;
	my $count = $#cols;

	foreach my $index (@{$entry->{'indexes'}}) {
	push @cols, $index;
	push @types, $SNMP::MIB{$index}{type};
	$donecol{$index} = 1;
	$count++;
	if ($SNMP::MIB{$index}{parent}{label} eq $entry->{label}) {
	# this index is a member of this table
	$self->{columnmap}[$count] = $index;
	$self->{coloffset} += 1;
	}
	}

	# search children list
	foreach my $child ( sort { $a->{'subID'} <=> $b->{'subID'} } @{$entry->{'children'}}) {
	push @{$self->{real_cols}}, $child->{'label'};
	next if ($donecol{$child->{label}});
	push @cols, $child->{'label'};
	push @types, $child->{'type'};
	$count++;
	$self->{columnmap}[$count] = $child->{'label'};
	}

	# save for later.
	$parser->{col_names} = \@cols;
	$self->{col_types} = \@types;
	$self->{col_names} = \@cols;
	map { $self->{col_uc_map}{uc($_)} = $_ } @cols;
	return \@cols;
	}

	sub set_col_nums {
	DEBUG("calling AnyData::Storage::SNMP set_col_nums\n");
	DEBUG("set_col_nums\n",Dumper(\@_),"\n");
	my ($self, $tname) = @_;
	return $self->{col_nums} if (defined($self->{col_nums}));
	my $mib = $SNMP::MIB{$tname};
	my $entry = $mib->{'children'}[0];
	my (%cols, %mibnodes);
	my $cnt = -1;

	foreach my $i (@{$self->{col_names}}) {
	$cols{$i} = ++$cnt;
	}

	$self->{col_nums} = \%cols;
	return \%cols;
	}

	# not needed?
	sub get_file_handle {
	DEBUG("calling AnyData::Storage::SNMP get_file_handle\n");
	DEBUG("get_file_handle\n",Dumper(\@_),"\n");
	return shift;
	}

	# not needed?
	sub get_file_name {
	DEBUG("calling AnyData::Storage::SNMP get_file_name\n");
	DEBUG("get_file_name\n",Dumper(\@_),"\n");
	my $self = shift;
	return $self->{process_table} \|\| $self->{table_name};
	}

	sub truncate {
	DEBUG("calling AnyData::Storage::SNMP truncate\n");
	my ($self) = @_;
	DEBUG("trunacte, ", Dumper(@_));

	# We must know how to delete rows or else this is all pointless.
	# return $self->{col_nums}{$tname} if (defined($self->{col_nums}{$tname}));
	my $tablemib = $SNMP::MIB{$self->{process_table}};
	my $entrymib = $tablemib->{'children'}[0];
	my ($delcolumn, $delcolumnname, $delcolumnvalue);

	foreach my $child (@{$entrymib->{'children'}}) {
	if ($child->{'textualConvention'} eq 'RowStatus') {
	$delcolumn = $child->{subID};
	$delcolumnname = $child->{label};
	$delcolumnvalue = 6; # destroy
	last;
	}
	}
	if (!$delcolumn) {
	return warn "Can't (or don't know how to) delete from table $self->{process_table}. Failing.\n";
	}

	# we should have a session, or else something is really wierd but...
	$self->{'sess'} = $self->make_session() if (!$self->{'sess'});

	# for each key left in our cache, delete it
	foreach my $key (keys(%{$self->{'existtest'}})) {
	# xxx: fullyqualified oid better
	my $vblist = new SNMP::VarList([$delcolumnname, $key,
	$delcolumnvalue]);
	DEBUG("truncate $key: \n", Dumper($vblist));
	$self->{'sess'}->set($vblist) \|\| warn $self->{'sess'}->{ErrorStr};
	}
	return;
	}

	sub make_session {
	DEBUG("calling AnyData::Storage::SNMP make_session\n");
	my $self = shift;
	my @args = @_;
	my @sessions;
	foreach my $key (qw(SecName Version SecLevel AuthPass Community RemotePort Timeout Retries RetryNoSuch SecEngineId ContextEngineId Context AuthProto PrivProto PrivPass)) {
	push @args, $key, $self->{$key} if ($self->{$key});
	}
	foreach my $host (split(/,\s*/,$self->{DestHost})) {
	push @sessions, new SNMP::Session(@args, 'DestHost' => $host);
	}
	return \@sessions;
	}

	sub file2str {
	DEBUG("calling AnyData::Storage::SNMP file2str\n");
	my ($self, $parser, $uccols) = @_;
	my ($cols, @retcols);
	DEBUG("file2str\n",Dumper(\@_),"\n");
	restart:
	if (!$self->{lastnode}) {
	# my @vbstuff = @{$parser->{'col_names'}};
	# splice (@vbstuff,0,1+$#AnyData::Storage::SNMP::basecols);
	# map { $_ = [ $_ ] } @vbstuff;
	# $self->{lastnode} = new SNMP::VarList(@vbstuff);
	# splice (@$cols,0,1+$#AnyData::Storage::SNMP::basecols);
	map { push @$cols,$self->{col_uc_map}{$_} } @$uccols;
	if ($#$cols == -1) {
	$cols = $self->{'col_names'};
	# remove base columns
	splice (@$cols,0,1+$#AnyData::Storage::SNMP::basecols);
	# remove not accessible columns
	foreach my $col (@$cols) {
	my $mib = $SNMP::MIB{$col};
	push @retcols, $col if ($mib->{'access'} =~ /Read\|Create/);
	}
	} else {
	@retcols = @$cols;
	# remove base columns
	foreach my $c (@AnyData::Storage::SNMP::basecols) {
	@retcols = grep(!/^$c$/, @retcols);
	}
	# remove non-accessible columns
	@retcols = grep {$SNMP::MIB{$_}{'access'} =~ /Read\|Create/} @retcols;
	}
	map { $_ = [ $_ ] } @retcols;
	$self->{lastnode} = new SNMP::VarList(@retcols);
	}

	if (!$self->{'sess'}) {
	$self->{'sess'} = $self->make_session();
	if ($#{$self->{'sess'}} == 0 && $self->{'silence_single_host'}) {
	$self->{'hostname'} = '';
	} else {
	$self->{'hostname'} = $self->{'sess'}[0]{'DestHost'};
	}
	}

	# perform SNMP operation
	my $lastnode = $self->{'lastnode'}[0][0];
	my $result;
	$result = $self->{'sess'}[0]->getnext($self->{lastnode});
	if (!defined($result)) {
	warn " getnext of $self->{lastnode}[0][0] returned undef\n";
	}
	DEBUG(" result: ",Dumper($self->{lastnode}),"\n");

	# XXX: check for holes!

	# need proper oid compare here for all nodes
	if ($self->{'lastnode'}[0][0] ne $lastnode) {
	if ($#{$self->{'sess'}} > 0) {
	shift @{$self->{'sess'}};
	delete($self->{'lastnode'});
	@$cols = ();
	$self->{'hostname'} = $self->{'sess'}[0]{'DestHost'} if($self->{'hostname'});
	goto restart;
	}
	return undef;
	}

	# add in basecols information:
	my @ret = ($self->{'hostname'}, $self->{'lastnode'}[0][1]);
	DEBUG("Dump row results: ",Dumper($self->{'lastnode'}),"\n");

	# build result array from result varbind contents
	map { $ret[$self->{'col_nums'}{$_->[0]}] = map_data($_); } @{$self->{'lastnode'}};

	# store instance ID for later use if deletion is needed later.
	$self->{'existtest'}{$self->{'lastnode'}[0][1]} = 1;

	DEBUG("Dump row results2: ",Dumper(\@ret),"\n");
	return \@ret;
	}

	sub map_data {
	if ($_->[3] eq "OBJECTID") {
	$_->[2] = pretty_print_oid(@_);
	}
	return $_->[2];
	}

	sub pretty_print_oid {
	use NetSNMP::default_store qw(:all);
	netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
	NETSNMP_DS_LIB_DONT_BREAKDOWN_OIDS,0);
	my $new = SNMP::translateObj($_->[2], 0);
	netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
	NETSNMP_DS_LIB_DONT_BREAKDOWN_OIDS,1);
	my $new2 = SNMP::translateObj($_->[2], 0);
	if ($new) {
	$_->[2] = $new2 . "$new";
	} else {
	$_->[2] = $_->[0] . $_->[1];
	}
	return $_->[2];
	}

	sub push_row {
	DEBUG("calling AnyData::Storage::SNMP push_row\n");
	DEBUG("push_row: ",Dumper(\@_),"\n");
	DEBUG("push_row\n");
	my ($self, $values, $parser, $cols) = @_;
	my @callers = caller(3);
	my $mode = $callers[3];
	if ($mode =~ /DELETE/) {
	DEBUG("not deleting $values->[$AnyData::Storage::SNMP::iidptr]\n");
	delete $self->{'existtest'}{$values->[$AnyData::Storage::SNMP::iidptr]};
	return;
	}

	my @origvars;
	if ($#$cols == -1) {
	# no column info passed in. Update everything (mode probably INSERTS).
	# @origvars = @{$self->{'col_names'}}};
	# splice (@origvars,0,1+$#AnyData::Storage::SNMP::basecols);

	map { push @origvars, $_ if $SNMP::MIB{$_}{'access'} =~ /Write\|Create/; } @{$self->{'real_cols'}} ;

	DEBUG("set cols: ", Dumper(\@origvars));
	} else {
	# only update the columns in question. (mode probably UPDATE)
	map { push @origvars, $self->{col_uc_map}{$_} } @$cols;
	}

	my @vars;
	foreach my $var (@origvars) {
	my $access = $SNMP::MIB{$var}{'access'};
	# not in this table, probably (hopefully) an index from another:
	next if ($SNMP::MIB{$var}{'parent'}{'parent'}{'label'} ne
	$self->{process_table});
	DEBUG("$var -> $access\n");
	if ($access =~ /(Write\|Create)/) {
	push @vars, $var;
	} elsif ($mode eq 'insert') {
	DEBUG("XXX: error if not index\n");
	} elsif ($mode eq 'update') {
	DEBUG("update to non-writable column attempted (SNMP error coming)\n");
	}
	}

	# generate index OID component if we don't have it.
	if ($values->[$AnyData::Storage::SNMP::iidptr] eq '') {
	$values->[$AnyData::Storage::SNMP::iidptr] =
	$self->make_iid($self->{process_table}, $values);
	}

	# add in values to varbind columns passed in from incoming parameters
	my @newvars;
	foreach my $v (@vars) {
	my $num = $self->{'col_nums'}{$v};
	DEBUG("types: $v -> $num -> ", $self->{'col_types'}[$num],
	" -> val=", $values->[$num], "\n");
	next if (!defined($values->[$num]));
	# build varbind: column-oid, instance-id, value type, value
	push @newvars, [$v, $values->[1], $values->[$num],
	$self->{'col_types'}[$num]];
	};

	# create the varbindlist
	# print STDERR Dumper(\@newvars);
	my $vblist = new SNMP::VarList(@newvars);

	# print STDERR Dumper($vblist);
	DEBUG("set: ", Dumper($vblist));
	$self->{'sess'} = $self->make_session() if (!$self->{'sess'});
	if (!$self->{'sess'}[0]) {
	warn "couldn't create SNMP session";
	} elsif (!$self->{'sess'}[0]->set($vblist)) {
	my $err = "$self->{process_table}: " . $self->{'sess'}[0]->{ErrorStr};
	if ($self->{'sess'}[0]->{ErrorInd}) {
	$err = $err . " (at varbind #"
	. $self->{'sess'}[0]->{ErrorInd} . " = " ;
	my $dump = Data::Dumper->new([$vblist->[$self->{'sess'}[0]->{ErrorInd} -1]]);
	$err .= $dump->Indent(0)->Terse(1)->Dump;
	}
	warn $err;
	}
	}

	sub seek {
	DEBUG("calling AnyData::Storage::SNMP seek\n");
	my ($self, $parser) = @_;
	DEBUG("seek\n",Dumper(\@_),"\n");
	}

	sub make_iid {
	DEBUG("calling AnyData::Storage::SNMP make_iid\n");
	my ($self, $tname, $vals) = @_;

	# Get indexes
	my $mib = $SNMP::MIB{$tname};
	my $entry = $mib->{'children'}[0];
	my $indexes = $entry->{'indexes'};
	my $iid;

	# XXX: implied

	# print STDERR "INDEXES: ", Dumper($vals),"\n";
	foreach my $index (@$indexes) {
	warn "A null index value was found, which I doubt is correct." if (!defined($vals->[$self->{col_nums}{$index}]));
	my $val = $vals->[$self->{col_nums}{$index}];
	my $type = $SNMP::MIB{$index}->{'type'};
	DEBUG("index type: $index -> $type -> $val -> " . length($val) . "\n");
	if ($type eq "OCTETSTR") {
	$iid .= "." . length($val) . "." . join(".", unpack("c*", $val));
	} elsif ($type eq "OBJID") {
	$iid .= "." . (scalar grep(/\./,$val) + 1) . "." . $val;
	} else {
	# should be only an INTEGER?
	$iid .= "." . $val;
	}
	}
	DEBUG("made iid: $iid\n");
	return $iid;
	}

	sub DEBUG {
	my @info = caller(1);
	if ($AnyData::Storage::SNMP::debug
	\|\| ($AnyData::Storage::SNMP::debugre &&
	$_[0] =~ /$AnyData::Storage::SNMP::debugre/)) {
	DEBUGIT(\@info, @_);
	}
	}

	sub DEBUGIT {
	my $info;
	if (ref($_[0]) eq 'ARRAY') {
	$info = shift @_;
	} else {
	my @y;
	my $c=0;
	print STDERR "debug chain: ";
	for(@y = caller($c); $#y > -1; $c++, @y = caller($c)) {
	print STDERR " $c: $y[3]\n";
	}
	my @x = caller(1);
	$info = \@x;
	}
	print STDERR "$info->[3]: ";
	print STDERR @_;
	}

	1;