Subversion Repositories openrisc

#!/usr/bin/perl

#!/usr/bin/perl -w

#

# Description:

#

# This program, given an OID reference as an argument, creates some

# template mib module files to be used with the ucd-snmp agent.  It is

# far from perfect and will not generate working modules, but it

# significantly shortens development time by outlining the basic

# structure.

#

# Its up to you to verify what it does and change the default values

# it returns.

#

use SNMP;

use FileHandle;

#use strict 'vars';

$SNMP::save_descriptions=1;

$SNMP::use_long_names=1;

$SNMP::use_enums=1;

SNMP::initMib();

$configfile="mib2c.conf";

$debug=0;

$nostats = 0;

sub usage {

    print "$0 [-h] [-c configfile] [-f prefix] mibNode\n\n";

    print "  -h\t\tThis message.\n\n";

    print "  -c configfile\tSpecifies the configuration file to use\n\t\tthat dictates what the output of mib2c will look like.\n\n";

    print "  -f prefix\tSpecifies the output prefix to use.  All code\n\t\twill be put into prefix.c and prefix.h\n\n";

    print "  mibNode\tThe name of the top level mib node you want to\n\t\tgenerate code for.  By default, the code will be stored in\n\t\tmibNode.c and mibNode.h (use the -f flag to change this)\n\n";

    print "  -d\t\tdebugging output (dont do it.  trust me.)\n\n";

    print "  -s\t\tDon't display statistics at the end\n\n";

    1;

}

while($#ARGV >= 0) {

    $_ = shift;

    $configfile = shift if (/-c/);

    $debug = 1 if (/-d/);

    $nostats = 1 if (/-s/);

    usage && exit(1) if (/-h/);

    $outputName = shift if (/-f/);

    $oid = $_ if (/^[^-]/);

}

read_config($configfile);

#

# internal conversion tables

#

%accessToUCD = qw(ReadOnly RONLY ReadWrite RWRITE

                  WriteOnly RWRITE Create RWRITE);

#  The lengths of the defined 'variableN' structures

@varLengths = (2,4,7,8,13);

if (!defined($oid)) {

    print STDERR "You didn\'t specify a mib oid to convert!\n";

    usage();

    exit(1);

}

$mib = $SNMP::MIB{$oid};

$_ = $commaoid = $fulloid = $mib->{'objectID'};

if (!defined ($fulloid)) {

    print STDERR "Couldn\'t find mib reference: $oid\n";

    exit(1);

}

s/[^.]//g;

$commaoid =~ s/\./,/g;

$commaoid =~ s/^,//g;

$outputName = $mib->{'label'} if (!defined($outputName));

$OUTPUTNAME = uc($outputName);

$vroutine="$outputName";

print "outputting to $outputName.c and $outputName.h ...\n";

#============================================

#

#   Walk the MIB tree, and construct strings

#     holding the various fragments of code needed.

#

#   'loadMib' returns the length of the longest OID suffix

#     encountered.

#

#   The variables constructed and used are:

#

#   (in the header file)

#       functionInfo :  A list of definitions for the table-handling functions,

#                       and routines for SETtable variables.

#                       (The main scalar handling routine is handled implicitly)

#

#   (in the code file)

#       structinfo :    The contents of the variableN structure listing

#                       the variables handled, including type, access level,

#                       OID suffix and 'magic number'

#

#       caseStatements: A hash array (indexed by variable routine name)

#                       containing the body of the switch statement

#                       used for returning the appropriate values.

#                       At a minimum, this consists of the various 'case' labels

#                       If full type information is available (from mib2c.conf)

#                       then this will also include a default initialiser,

#                       and setting of a 'write_method' (if appropriate).

#

#       writeFuncs:     A list of function skeletons for setting variables

#                       (for variables with suitable access levels).

#                       Note that this list will not include functions

#                       for variables which don't provide type information

#                       in the mib2c.conf file (even if such variables are

#                       defined as writeable in the variableN structure).

#

#============================================

$count = 0;

$depth = loadMib($mib,0)-1;

#  Determine which 'variableN' structure is needed

for($varlen = 0; $varlen <= $#varLengths; $varlen++) {

  last if ($depth <= $varLengths[$varlen]);

}

$varlen = $varLengths[$varlen];

#============================================

#

#       Table-handling routines.

#

#============================================

foreach $vtable (@table_list) {

    foreach $ptable (@processtable) {

        $variables{$ptable}{'processed'} .=

            (eval "\"$variables{$ptable}{'code'}\"") . "\n\n";

    }

    $var_routines .=

        (eval "\"$variables{'code-var_table'}{'code'}\"") . "\n\n";

}

#============================================

#

#   Output the header file

#

#============================================

open(DOTH,">$outputName.h");

print DOTH (eval "\"$variables{'code-dot-h'}{'code'}\"") . "\n";

close(DOTH);

#============================================

#

#   Output the code file:

#       Initialisation and main variable routine.

#

#============================================

open(DOTC,">$outputName.c");

print DOTC (eval "\"$variables{'code-main-part'}{'code'}\"") . "\n\n";;

close(DOTC);

#============================================

#

# Everyone loves statistics.

#

#============================================

print "  depth: $depth\n";

print "  Number of Lines Created:\n";

system("wc -l $outputName.c $outputName.h");

print "Done.\n";

#============================================

#

#  loadMib:

#       Recursive routine to walk the mib,

#       and construct the various code fragment strings.

#

#============================================

sub loadMib {

    my $mib = shift;

    my $i;

    my $depth = shift;

    $depth = $depth + 1;

    my $name = $mib->{'label'};

    my $NAME = uc($name);

    print "doing $mib->{label} : $mib->{objectID}\n" if $debug;

    if (defined($mib->{'access'}) &&

        $mib->{'access'} =~ /ReadOnly|ReadWrite|WriteOnly|Create|NoAccess/) {

        $count = $count + 1;

        $subid = $mib->{'objectID'};

        $subid =~ s/$fulloid\.//;

        $subid =~ s/\./,/g;

        if (!defined($variables{$mib->{'type'}})  && !defined($mib->{'indexes'})) {

            print STDERR "unknown type:  $mib->{type} for $mib->{label} $mib->{'access'}\n";

            print STDERR "unknown type:  no information generated for $mib->{label}\n";

        } else {

            foreach $i (@process) {

                next if (defined($variables{$i}{'skipif'}) &&

                         eval $variables{$i}{'skipif'});

                my $result = (eval "\"$variables{$i}{'code'}\"");

                $variables{$i}{'processed'} .= "$result\n";

                $variables{$vroutine}{$i}{'processed'} .= "$result\n";

            }

        }

        if (defined($mib->{'indexes'})) {

            print "indexes: ", join(", ",@{$mib->{'indexes'}}),"\n" if ($debug);

            $variables{$vroutine}{'indexes'} = $mib->{'indexes'};

            foreach $i (@{$mib->{'indexes'}}) {

                $variables{$vroutine}{$i}{'isanindex'} = 1;

            }

        }

    }

    my $children = $$mib{'children'};

    my $i;

    my $newdepth = $depth;

    foreach $i (@{$children}) {

        if ( $name =~ /Table$/ ) {

            $vroutine="$name";

            push @table_list, $name;

            $newdepth = max(loadMib($i, $depth), $newdepth);

            $vroutine="$outputName";

        }

        else {

            $newdepth = max(loadMib($i, $depth), $newdepth);

        }

    }

    return $newdepth;

}

sub max {

    my $x = shift;

    my $y = shift;

    return ($x > $y) ? $x : $y;

}

sub read_config() {

    my $configfile = shift;

    my ($type, $lasttoken);

    my $fh = new FileHandle;

    if ( $fh->open("<$configfile") ) {

        while(<$fh>) {

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

            if (/^\s*type:\s*(.*)/) {

                if (defined($type) && defined($lasttoken) &&

                    defined ($variables{$type}{$lasttoken})) {

                    chomp($variables{$type}{$lasttoken});

                }

                $type = $1;

                chomp($type);

            } elsif (/include:\s*(.*)/) {

                read_config($1);

            } elsif (/process:\s*(.*)/) {

                push (@process, $1);

            } elsif (/processtable:\s*(.*)/) {

                push (@processtable, $1);

            } elsif (/delete:\s*(.*)/) {

                delete($variables{$type}{$1});

            } elsif (/copy:\s*(.*)/) {

                my $item;

                chomp($1);

                foreach $item (keys(%{$variables{$1}})) {

                    $variables{$type}{$item} = $variables{$1}{$item};

                }

            } else {

                if (/\s*([^:]*):(\s*.*)/) {

                    if (!defined($variables{$type}{$1})) {

                        if (defined($type) && defined($lasttoken) &&

                            defined ($variables{$type}{$lasttoken})) {

                            chomp($variables{$type}{$lasttoken});

                        }

                        $variables{$type}{$1} = $2;

                        $lasttoken = $1;

                        $variables{$type}{$1} =~ s/^\t+//;

                    } else {

                        # duplicate entry:  tack it on.

                        my ($x, $y) = ($1, $2);

                        $y =~ s/^\t+//;

                        $variables{$type}{$x} .= "\n" . $y;

                    }

                } else {

                    # continuation line, it started with spaces or a +

                    s/^\s*//;

                    s/^\+//;

                    $variables{$type}{$lasttoken} .= "\n" . $_;

                    chomp($variables{$type}{$lasttoken});

                }

            }

        }

        $fh->close();

    } else {

        warn "Config file ($configfile) not found.\n";

    }

}

sub evalstr {

    my $str = shift;

#    if ($str !~ /^\"/) {

        $str = "\"$str\"";  # surround by quotes.

#    }

    eval ($str);            # should return a string, with variables expanded

}

sub evalrstr {

    my $rstr = shift;

#    if ($str !~ /^\"/) {

#       $$rstr = "\"" . $$rstr . "\"";  # surround by quotes.

#    }

    eval ("\"$$rstr\"");            # should return a string, with variables expanded

}