开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
mib2c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：39k
源码类别：

SNMP编程

开发平台：

Unix_Linux

mib2c：源码内容
  1. #!/usr/bin/perl
  2. #!/usr/bin/perl -w
  4. #
  5. # $Id: mib2c,v 5.57 2004/09/10 12:30:15 dts12 Exp $
  6. #
  7. # Description: 
  8. #
  9. # This program, given an OID reference as an argument, creates some
  10. # template mib module files to be used with the net-snmp agent.  It is
  11. # far from perfect and will not generate working modules, but it
  12. # significantly shortens development time by outlining the basic
  13. # structure.
  14. #
  15. # Its up to you to verify what it does and change the default values
  16. # it returns.
  17. #
  19. # SNMP
  20. my $havesnmp = eval {require SNMP;};
  21. my $havenetsnmpoid = eval {require NetSNMP::OID;};
  23. if (!$havesnmp) {
  24.     print "
  25. ERROR: You don't have the SNMP perl module installed.  Please obtain
  26. this by getting the latest source release of the net-snmp toolkit from
  27. http://www.net-snmp.org/download/ .  Once you download the source and
  28. unpack it, the perl module is contained in the perl/SNMP directory.
  29. See the README file there for instructions.
  31. ";
  32.     exit;
  33. }
  35. if ($havesnmp) {
  36.     eval { import SNMP; }
  37. }
  38. if ($havenetsnmp) {
  39.     eval { import NetSNMP::OID; }
  40. }
  41. use FileHandle;
  43. #use strict 'vars';
  44. $SNMP::save_descriptions=1;
  45. $SNMP::use_long_names=1;
  46. $SNMP::use_enums=1;
  47. SNMP::initMib();
  49. $configfile="mib2c.conf";
  50. $debug=0;
  51. $quiet=0;
  52. $strict_unk_token = 0;
  53. $noindent = 0;
  54. $currentline = 0;
  55. $currentlevel = -1;
  56. %assignments;
  57. %outputs;
  58. @def_search_dirs = (".");
  59. @search_dirs = ();
  60. if($ENV{MIB2C_DIR}) {
  61.    push @def_search_dirs, split(/:/, $ENV{MIB2C_DIR});
  62. }
  63. push @def_search_dirs, "/usr/local/share/snmp/";
  64. push @def_search_dirs, "/usr/local/share/snmp/mib2c-data";
  65. push @def_search_dirs, "./mib2c-conf.d";
  67. sub usage {
  68.     print "$0 [-h] [-c configfile] [-f prefix] mibNodenn";
  69.     print "  -httThis message.nn";
  70.     print "  -c configfiletSpecifies the configuration file to usenttthat dictates what the output of mib2c will look like.nn";
  71.     print "  -I PATHtSpecifies a path to look for configuration files innn";
  72.     print "  -f prefixtSpecifies the output prefix to use.  All codenttwill be put into prefix.c and prefix.hnn";
  73.     print "  -dttdebugging output (don't do it.  trust me.)nn";
  74.     print "  -S VAR=VALtSet $VAR variable to $VALnn";
  75.     print "  -ittDon't run indent on the resulting codenn";
  76.     print "  mibNodetThe name of the top level mib node you want tonttgenerate code for.  By default, the code will be stored innttmibNode.c and mibNode.h (use the -f flag to change this)nn";
  77.     1;
  78. }
  80. my @origargs = @ARGV;
  81. my $args_done = 0;
  82. while($#ARGV >= 0) {
  83.     $_ = shift;
  84.     if (/^-/) {
  85.       if ($args_done != 0) {
  86.         warn "all argument must be specified before the mibNode!n";
  87.         usage;
  88.         exit 1;
  89.       } elsif (/^-c/) {
  90.         $configfile = shift;
  91.       } elsif (/^-d/) {
  92.         $debug = 1;
  93.       } elsif (/^-S/) {
  94.         my $expr = shift;
  95.         my ($var, $val) = ($expr =~ /([^=]*)=(.*)/);
  96.         die "no variable specified for -S flag." if (!$var);
  97.         $assignments{$var} = $val;
  98.       } elsif (/^-q/) {
  99.         $quiet = 1;
  100.       } elsif (/^-i/) {
  101.         $noindent = 1;
  102.       } elsif (/^-h/) {
  103.         usage && exit(1);
  104.       } elsif (/^-f/) {
  105.         $outputName = shift;
  106.       } elsif (/^-I/) {
  107. my $dirs = shift;
  108. push @search_dirs, split(/,/,$dirs);
  109.       } else {
  110.         warn "Unknown option '$_'n";
  111.         usage;
  112.         exit 1;
  113.       }
  114.     } else {
  115.       $args_done = 1;
  116.       warn "Replacing previous mibNode $oid with $_n" if ($oid);
  117.       $oid = $_ ;
  118.     }
  119. }
  120.  
  121. #
  122. # internal conversion tables
  123. #
  125. %accessToIsWritable = qw(ReadOnly 0 ReadWrite 1 
  126.  WriteOnly 1 Create 1);
  127. %perltoctypes = qw(OCTETSTR   ASN_OCTET_STR
  128.    INTEGER    ASN_INTEGER
  129.    INTEGER32  ASN_INTEGER
  130.    UNSIGNED32 ASN_UNSIGNED
  131.    OBJECTID   ASN_OBJECT_ID
  132.    COUNTER64  ASN_COUNTER64
  133.    COUNTER    ASN_COUNTER
  134.    NETADDR    ASN_COUNTER
  135.    UINTEGER   ASN_UINTEGER
  136.    IPADDR     ASN_IPADDRESS
  137.    BITS       ASN_OCTET_STR
  138.    TICKS      ASN_TIMETICKS
  139.    GAUGE      ASN_GAUGE
  140.    OPAQUE     ASN_OPAQUE);
  141. %perltodecl = ("OCTETSTR",  "char",
  142.        "INTEGER",  "long",
  143.        "INTEGER32",  "long",
  144.        "UNSIGNED32", "u_long",
  145.        "UINTEGER", "u_long",
  146.        "OBJECTID", "oid",
  147.        "COUNTER64", "U64",
  148.        "COUNTER", "u_long",
  149.        "IPADDR", "u_long",
  150.        "BITS", "char",
  151.        "TICKS", "u_long",
  152.        "GAUGE", "u_long",
  153.        "OPAQUE", "u_char");
  154. %perltolen = ("OCTETSTR",  "1",
  155.        "INTEGER",  "0",
  156.        "INTEGER32",  "0",
  157.        "UNSIGNED32", "0",
  158.        "UINTEGER", "0",
  159.        "OBJECTID", "1",
  160.        "COUNTER64", "0",
  161.        "COUNTER", "0",
  162.        "IPADDR", "0",
  163.        "BITS", "1",
  164.        "TICKS", "0",
  165.        "GAUGE", "0",
  166.        "OPAQUE", "1");
  168. my $mibnode = $SNMP::MIB{$oid};
  170. if (!$mibnode) { 
  172. print STDERR "
  173. You didn't give mib2c a valid OID to start with.  IE, I could not find
  174. any information about the mib node "$oid".  This could be caused
  175. because you supplied an incorrectly node, or by the MIB that you're
  176. trying to generate code from isn't loaded.  To make sure your mib is
  177. loaded, run mib2c using this as an example:
  179.    env MIBS="+MY-PERSONAL-MIB" mib2c " . join(" ",@origargs) . "
  181. You might wish to start by reading the MIB loading tutorial at:
  183.    http://www.net-snmp.org/tutorial-5/commands/mib-options.html
  185. And making sure you can get snmptranslate to display information about
  186. your MIB node.  Once snmptranslate works, then come back and try mib2c
  187. again.
  189. ";
  190. exit 1;
  191. }
  193. # setup
  194. $outputName = $mibnode->{'label'} if (!defined($outputName));
  195. $vars{'name'} = $outputName;
  196. $vars{'oid'} = $oid;
  197. $vars{'example_start'} = "    /*n" .
  198. "    ***************************************************n" .
  199. "    ***             START EXAMPLE CODE              ***n" .
  200. "    ***---------------------------------------------***/";
  201. $vars{'example_end'} = "    /*n" .
  202. "    ***---------------------------------------------***n" .
  203. "    ***              END  EXAMPLE CODE              ***n" .
  204. "    ***************************************************/";
  206. # loop through mib nodes, remembering stuff.
  207. setup_data($mibnode);
  209. if(($ENV{HOME}) && (-f "$ENV{HOME}/.snmp/mib2c.conf")) {
  210.   $fh = open_conf("$ENV{HOME}/.snmp/mib2c.conf");
  211.   process("-balanced");
  212.   $fh->close;
  213. }
  215. my $defaults = find_conf("default-$configfile",1);
  216. if (-f "$defaults" ) {
  217.   $fh = open_conf($defaults);
  218.   process("-balanced");
  219.   $fh->close;
  220. }
  222. my @theassignments = keys(%assignments);
  223. if ($#theassignments != -1) {
  224.   foreach $var (@theassignments) {
  225.     $vars{$var} = $assignments{$var};
  226.   }
  227. }
  228. $configfile = find_conf($configfile,0);
  229. $fh = open_conf($configfile);
  230. process("-balanced");
  231. $fh->close;
  233. if (!$noindent) {
  234.   foreach $i (keys(%written)) {
  235.     next if ($i eq "-");
  236.     next if (!($i =~ /.[ch]$/));
  237.     print STDERR "running indent on $in" if (!$quiet);
  238.     system("indent -orig -nbc -bap -nut -nfca -T size_t -T netsnmp_mib_handler -T netsnmp_handler_registration -T netsnmp_delegated_cache -T netsnmp_mib_handler_methods -T netsnmp_old_api_info -T netsnmp_old_api_cache -T netsnmp_set_info -T netsnmp_request_info -T netsnmp_set_info -T netsnmp_tree_cache -T netsnmp_agent_request_info -T netsnmp_cachemap -T netsnmp_agent_session -T netsnmp_array_group_item -T netsnmp_array_group -T netsnmp_table_array_callbacks -T netsnmp_table_row -T netsnmp_table_data -T netsnmp_table_data_set_storage -T netsnmp_table_data_set -T netsnmp_column_info -T netsnmp_table_registration_info -T netsnmp_table_request_info -T netsnmp_iterator_info -T netsnmp_data_list -T netsnmp_oid_array_header -T netsnmp_oid_array_header_wrapper -T netsnmp_oid_stash_node -T netsnmp_pdu -T netsnmp_request_list -T netsnmp_callback_pass -T netsnmp_callback_info -T netsnmp_transport -T netsnmp_transport_list -T netsnmp_tdomain $i");
  239.   }
  240. }
  242. sub m2c_die {
  243.   warn "ERROR: ". $_[0] . "n";
  244.   die "  at $currentfile:$currentlinen";
  245. }
  247. sub tocommas {
  248.     my $oid = $_[0];
  249.     $oid =~ s/./,/g;
  250.     $oid =~ s/^s*,//;
  251.     return $oid;
  252. }
  254. sub oidlength {
  255.     return (scalar split(/./, $_[0])) - 1;
  256. }
  258. # replaces $VAR type expressions and $VAR.subcomponent expressions
  259. # with data from the mib tree and loop variables.
  260. # possible uses:
  261. #
  262. #   $var               -- as defined by loops, etc.
  263. #   ${var}otherstuff   -- appending text to variable contents
  264. #   $var.uc            -- all upper case version of $var
  265. #
  266. # NOTE: THESE ARE AUTO-EXTRACTED/PROCESSED BY ../mib2c.extract.pl for man pages
  267. #
  268. # Mib components, $var must first expand to a mib node name:
  269. #
  270. #   $var.uc            -- all upper case version of $var
  271. #
  272. #   $var.objectID      -- dotted, fully-qualified, and numeric OID
  273. #   $var.commaoid      -- comma separated numeric OID for array initialization
  274. #   $var.oidlength     -- length of the oid
  275. #   $var.subid         -- last number component of oid
  276. #   $var.module        -- MIB name that the object comes from
  277. #   $var.parent        -- contains the label of the parent node of $var.
  278. #
  279. #   $var.isscalar      -- returns 1 if var contains the name of a scalar
  280. #   $var.iscolumn      -- returns 1 if var contains the name of a column
  281. #   $var.children      -- returns 1 if var has children
  282. #
  283. #   $var.perltype      -- node's perl SYNTAX ($SNMP::MIB{node}{'syntax'})
  284. #   $var.type          -- node's ASN_XXX type (Net-SNMP specific #define)
  285. #   $var.decl          -- C data type (char, u_long, ...)
  286. #
  287. #   $var.readable      -- 1 if an object is readable, 0 if not
  288. #   $var.settable      -- 1 if an object is writable, 0 if not
  289. #   $var.creatable     -- 1 if a column object can be created as part of a new row, 0 if not
  290. #   $var.noaccess      -- 1 if not-accessible, 0 if not
  291. #   $var.accessible    -- 1 if accessible, 0 if not
  292. #   $var.rowstatus     -- 1 if an object is a RowStatus object, 0 if not
  293. #     'settable', 'creatable' and 'rowstatus' can also be used with table variables
  294. #     to indicate whether it contains writable, creatable or RowStatus column objects
  295. #
  296. #   $var.hasdefval     -- returns 1 if var has a DEFVAL clause
  297. #   $var.defval        -- node's DEFVAL
  298. #   $var.hashint       -- returns 1 if var has a HINT clause
  299. #   $var.hint          -- node's HINT
  300. #   $var.ranges        -- returns 1 if var has a value range defined
  301. #   $var.enums         -- returns 1 if var has enums defined for it.
  302. #   $var.access        -- node's access type
  303. #   $var.status        -- node's status
  304. #   $var.syntax        -- node's syntax
  305. #   $var.reference     -- node's reference
  306. #   $var.description   -- node's description
  308. sub process_vars {
  309.     my $it = shift;
  311.     # mib substitutions ($var.type -> $mibnode->{'type'})
  312.    if ( $it =~ /$(w+).(w+)/ ) {
  313.     if ($SNMP::MIB{$vars{$1}} && $SNMP::MIB{$vars{$1}}{'label'} =~ /Table$/) {
  314.       $it =~ s/$(w+).(settable)/(table_is_writable($SNMP::MIB{$vars{$1}}{label}))/eg;
  315.       $it =~ s/$(w+).(creatable)/(table_has_create($SNMP::MIB{$vars{$1}}{label}))/eg;
  316.       $it =~ s/$(w+).(rowstatus)/(table_has_rowstatus($SNMP::MIB{$vars{$1}}{label}))/eg;
  317.     }
  318.     $it =~ s/$(w+).(uc)/uc($vars{$1})/eg; # make something uppercase
  319.     $it =~ s/$(w+).(commaoid)/tocommas($SNMP::MIB{$vars{$1}}{objectID})/eg;
  320.     $it =~ s/$(w+).(oidlength)/oidlength($SNMP::MIB{$vars{$1}}{objectID})/eg;
  321.     $it =~ s/$(w+).(description)/$SNMP::MIB{$vars{$1}}{description}/g;
  322.     $it =~ s/$(w+).(perltype)/$SNMP::MIB{$vars{$1}}{type}/g;
  323.     $it =~ s/$(w+).(type)/$perltoctypes{$SNMP::MIB{$vars{$1}}{$2}}/g;
  324.     $it =~ s/$(w+).(subid)/$SNMP::MIB{$vars{$1}}{subID}/g;
  325.     $it =~ s/$(w+).(module)/$SNMP::MIB{$vars{$1}}{moduleID}/g;
  326.     $it =~ s/$(w+).(settable)/(($SNMP::MIB{$vars{$1}}{access} =~ /(ReadWrite|Create|WriteOnly)/)?1:0)/eg;
  327.     $it =~ s/$(w+).(creatable)/(($SNMP::MIB{$vars{$1}}{access} =~ /(Create)/)?1:0)/eg;
  328.     $it =~ s/$(w+).(readable)/(($SNMP::MIB{$vars{$1}}{access} =~ /(Read|Create)/)?1:0)/eg;
  329.     $it =~ s/$(w+).(noaccess)/(($SNMP::MIB{$vars{$1}}{access} =~ /(NoAccess)/)?1:0)/eg;
  330.     $it =~ s/$(w+).(accessible)/(($SNMP::MIB{$vars{$1}}{access} !~ /(NoAccess)/)?1:0)/eg;
  331.     $it =~ s/$(w+).(objectID|label|subID|access|status|syntax|reference)/$SNMP::MIB{$vars{$1}}{$2}/g;
  332.     $it =~ s/$(w+).(decl)/$perltodecl{$SNMP::MIB{$vars{$1}}{type}}/g;
  333.     $it =~ s/$(w+).(needlength)/$perltolen{$SNMP::MIB{$vars{$1}}{type}}/g;
  334.     $it =~ s/$(w+).(iscolumn)/($SNMP::MIB{$vars{$1}}{'parent'}{'label'} =~ /Entry$/) ? 1 : 0/eg;
  335.     $it =~ s/$(w+).(isscalar)/($SNMP::MIB{$vars{$1}}{'parent'}{'label'} !~ /Entry$/ && $SNMP::MIB{$vars{$1}}{access}) ? 1 : 0/eg;
  336.     $it =~ s/$(w+).(parent)/$SNMP::MIB{$vars{$1}}{'parent'}{'label'}/g;
  337.     $it =~ s/$(w+).(children)/($#{$SNMP::MIB{$vars{$1}}{'children'}} == 0) ? 0 : 1/eg;
  338.     $it =~ s/$(w+).(hasdefval)/(length($SNMP::MIB{$vars{$1}}{'defaultValue'}) == 0) ? 0 : 1/eg;
  339.     $it =~ s/$(w+).(defval)/$SNMP::MIB{$vars{$1}}{'defaultValue'}/g;
  340.     $it =~ s/$(w+).(hashint)/(length($SNMP::MIB{$vars{$1}}{'hint'}) == 0) ? 0 : 1/eg;
  341.     $it =~ s/$(w+).(hint)/$SNMP::MIB{$vars{$1}}{'hint'}/g;
  342.     $it =~ s/$(w+).(ranges)/($#{$SNMP::MIB{$vars{$1}}{'ranges'}} == -1) ? 0 : 1/eg;
  343.     # check for enums
  344.     $it =~ s/$(w+).(enums)/(%{$SNMP::MIB{$vars{$1}}{'enums'}} == 0) ? 0 : 1/eg;
  345.     $it =~ s/$(w+).(enumrange)/%{$SNMP::MIB{$vars{$1}}{'enums'}}/eg;
  346.     $it =~ s/$(w+).(rowstatus)/(($SNMP::MIB{$vars{$1}}{syntax} =~ /(RowStatus)/)?1:0)/eg;
  347.     if ( $it =~ /$(w+).(w+)/ ) {
  348.       warn "Possible unknown variable attribute $$1.$2 at $currentfile:$currentlinen";
  349.     }
  350.   }
  351.     # normal variable substitions
  352.     $it =~ s/${(w+)}/$vars{$1}/g;
  353.     $it =~ s/$(w+)/$vars{$1}/g;
  354.     # use $@var to put literal '$var'
  355.     $it =~ s/$@(w+)/$$1/g;
  356.     return $it;
  357. }
  359. # process various types of statements
  360. #
  361. # NOTE: THESE ARE AUTO-EXTRACTED/PROCESSED BY ../mib2c.extract.pl for man pages
  362. # which include:
  363. #   @open FILE@
  364. #     writes generated output to FILE
  365. #     note that for file specifications, opening '-' will print to stdout.
  366. #   @append FILE@
  367. #     appends the given FILE
  368. #   @close FILE@
  369. #     closes the given FILE
  370. #   @push@
  371. #     save the current outputs, then clear outputs. Use with @open@
  372. #     and @pop@ to write to a new file without interfering with current
  373. #     outputs.
  374. #   @pop@
  375. #     pop up the process() stack one level. Use after a @push@ to return to
  376. #     the previous set of open files.
  377. #   @foreach $VAR scalar@
  378. #     repeat iterate over code until @end@ setting $VAR to all known scalars
  379. #   @foreach $VAR table@
  380. #     repeat iterate over code until @end@ setting $VAR to all known tables
  381. #   @foreach $VAR column@
  382. #     repeat iterate over code until @end@ setting $VAR to all known
  383. #     columns within a given table.  Obviously this must be called
  384. #     within a foreach-table clause.
  385. #   @foreach $VAR nonindex@
  386. #     repeat iterate over code until @end@ setting $VAR to all known
  387. #     non-index columns within a given table.  Obviously this must be called
  388. #     within a foreach-table clause.
  389. #   @foreach $VAR internalindex@
  390. #     repeat iterate over code until @end@ setting $VAR to all known internal
  391. #     index columns within a given table.  Obviously this must be called
  392. #     within a foreach-table clause.
  393. #   @foreach $VAR externalindex@
  394. #     repeat iterate over code until @end@ setting $VAR to all known external
  395. #     index columns within a given table.  Obviously this must be called
  396. #     within a foreach-table clause.
  397. #   @foreach $VAR index@
  398. #     repeat iterate over code until @end@ setting $VAR to all known
  399. #     indexes within a given table.  Obviously this must be called
  400. #     within a foreach-table clause.
  401. #   @foreach $VAR notifications@
  402. #     repeat iterate over code until @end@ setting $VAR to all known notifications
  403. #   @foreach $VAR varbinds@
  404. #     repeat iterate over code until @end@ setting $VAR to all known varbinds
  405. #     Obviously this must be called within a foreach-notifications clause.
  406. #   @foreach $LABEL, $VALUE enum@
  407. #     repeat iterate over code until @end@ setting $LABEL and $VALUE
  408. #     to the label and values from the enum list.
  409. #   @foreach $RANGE_START, $RANGE_END range NODE@
  410. #     repeat iterate over code until @end@ setting $RANGE_START and $RANGE_END
  411. #     to the legal accepted range set for a given mib NODE.
  412. #   @foreach $var stuff a b c d@
  413. #     repeat iterate over values a, b, c, d as assigned generically
  414. #     (ie, the values are taken straight from the list with no
  415. #     mib-expansion, etc).
  416. #   @eval $VAR = expression@
  417. #     evaluates expression and assigns the results to $VAR.  This is
  418. #     not a full perl eval, but sort of a "psuedo" eval useful for
  419. #     simple expressions while keeping the same variable name space.
  420. #     See below for a full-blown export to perl.
  421. #   @perleval STUFF@
  422. #     evaluates STUFF directly in perl.  Note that all mib2c variables
  423. #     interpereted within .conf files are in $vars{NAME}.
  424. #   @startperl@
  425. #   @endperl@
  426. #     treats everything between these tags as perl code, and evaluates it.
  427. #   @next@
  428. #     restart foreach; should only be used inside a conditional.
  429. #     skips out of current conditional, then continues to skip to
  430. #     end for the current foreach clause.
  431. #   @if expression@
  432. #     evaluates expression, and if expression is true processes
  433. #     contained part until appropriate @end@ is reached.  If an @else@
  434. #     clause is found, it will be evaluated instead if expression
  435. #     isn't true.
  436. #   @define NAME@
  437. #   @enddefine@
  438. #     Memorizes "stuff" between the define and enddefine tags for
  439. #     later calling as NAME by @calldefine NAME@.
  440. #   @calldefine NAME@
  441. #     Executes stuff previously memorized as NAME.
  442. #   @printf "expression" stuff1, stuff2, ...@
  443. #     Like all the other printf's you know and love.
  444. #   @run FILE@
  445. #     Sources the contents of FILE as a mib2c file,
  446. #     but does not affect current files opened.
  447. #   @include FILE@
  448. #     Sources the contents of FILE as a mib2c file and appends its
  449. #     output to the current output.
  450. #   @prompt $var QUESTION@
  451. #     Presents the user with QUESTION, expects a response and puts it in $var
  452. #   @print STUFF@
  453. #     Prints stuff directly to the users screen (ie, not to where
  454. #     normal mib2c output goes)
  455. #   @exit@
  456. #     Bail out!
  457. #
  458. sub skippart {
  459.   my $endcount = 1;
  460.   my $arg = shift;
  461.   my $rtnelse = 0;
  462.   while ($arg =~ s/-(w+)s*//) {
  463.     $rtnelse = 1 if ($1 eq "else");
  464.   }
  465.   while(get_next_line()) {
  466.     $currentline++;
  467.     $_ = process_vars($_) if ($debug);
  468.     print "$currentfile.$currentline:P$currentlevel:S$endcount.$rtnelse:$_" if ($debug);
  469.         next if ( /^s*##/ ); #                          noop, it's a comment
  470.         next if (! /^s*@/ ); #                                        output
  471.         if (! /^s*@.*@/ ) {
  472.           warn "$currentfile:$currentline contained a line that started with a @ but did not match any mib2c configuration tokens.n";
  473.           warn "(maybe missing the trailing @?)n";
  474.           warn "$currentfile:$currentline [$_]n";
  475.         }
  476. elsif (/@s*end@/) {
  477.     return "end" if ($endcount == 1);
  478.     $endcount--;
  479. }
  480. elsif (/@s*elseif.*@/) {
  481.           m2c_die "use 'elsif' instead of 'elseif'n";
  482.         }
  483. elsif (/@s*else@/) {
  484.     return "else" if (($endcount == 1) && ($rtnelse == 1));
  485. }
  486. elsif (/@s*elsifs+([^@]+)@/) {
  487.     return "else" if (($endcount == 1) && ($rtnelse == 1) && (eval(process_vars($1))));
  488. }
  489. elsif (/@s*(foreach|if)/) {
  490.     $endcount++;
  491. }
  492.     }
  493.   print "skippart EOFn";
  494.   m2c_die "unbalanced code detected in skippart: EOF when $endcount levels deep" if($endcount != 1);
  495.   return "eof";
  496. }
  498. sub close_file {
  499.   my $name = shift;
  500.   if (!$name) {
  501.     print "close_file w/out name!n";
  502.     return;
  503.   }
  504.   if(!$outputs{$name}) {
  505.     print "no handle for $namen";
  506.     return;
  507.   }
  508.   $outputs{$name}->close();
  509.   delete $outputs{$name};
  510. #  print STDERR "closing $namen" if (!$quiet);
  511. }
  513. sub close_files {
  514.   foreach $name (keys(%outputs)) {
  515.     close_file($name);
  516.   }
  517. }
  519. sub open_file {
  520.   my $multiple = shift;
  521.   my $spec = shift;
  522.   my $name = $spec;
  523.   $name =~ s/>//;
  524.   if ($multiple == 0) {
  525.     close_files();
  526.   }
  527.   return if ($outputs{$name});
  528.   $outputs{$name} = new IO::File;
  529.   $outputs{$name}->open(">$spec") || m2c_die "failed to open $name";
  530.   print STDERR "writing to $namen" if (!$quiet && !$written{$name});
  531.   $written{$name} = '1';
  532. }
  534. sub process_file {
  535.   my ($file, $missingok, $keepvars) = (@_);
  536.   my $oldfh = $fh;
  537.   my $oldfile = $currentfile;
  538.   my $oldline = $currentline;
  539.   # keep old copy of @vars and just build on it.
  540.   my %oldvars;
  542.   %oldvars = %vars if ($keepvars != 1);
  544.   $file = find_conf($file,$missingok);
  545.   return if (! $file);
  547.   $fh = open_conf($file);
  548.   $currentline = 0;
  549.   process("-balanced");
  550.   $fh->close();
  552.   $fh = $oldfh;
  553.   $currentfile = $oldfile;
  554.   $currentline = $oldline;
  556.   # don't keep values in replaced vars.  Revert to ours.
  557.   %vars = %oldvars if ($keepvars != 1);
  558. }
  560. sub get_next_line {
  561.     if ($#process_lines > -1) {
  562. return $_ = shift @process_lines;
  563.     }
  564.     return $_ = <$fh>;
  565. }
  567. sub do_tell {
  568.     my $stash;
  569.     $stash->{'startpos'} = $fh->tell();
  570.     $stash->{'startline'} = $currentline;
  571.     @{$stash->{'lines'}} = @process_lines;
  572.     return $stash;
  573. }
  575. sub do_seek {
  576.     my $stash = shift;
  578.     # save current line number
  579.     $currentline = $stash->{'startline'};
  580.     $fh->seek($stash->{'startpos'}, 0); # go to top of section.
  582.     # save current process_lines state.
  583.     @process_lines = @{$stash->{'lines'}};
  585.     # save state of a number of variables (references), and new assignments
  586.     for (my $i = 0; $i <= $#_; $i += 2) {
  587. push @{$stash->{'vars'}}, $_[$i], ${$_[$i]};
  588. ${$_[$i]} = $_[$i+1];
  589.     }
  590. }
  592. sub do_unseek {
  593.     my $stash = shift;
  594.     for (my $i = 0; $i <= $#{$stash->{'vars'}}; $i += 2) {
  595. ${$stash->{'vars'}[$i]} = $stash->{'vars'}[$i+1];
  596.     }
  597. }
  599. sub do_a_loop {
  600.     my $stash = shift;
  601.     do_seek($stash, @_);
  602.     my $return = process();
  603.     do_unseek($stash);
  604.     return $return;
  605. }
  607. sub process {
  608.   my $arg = shift;
  609.   my $elseok = 0;
  610.   my $balanced = 0;
  611.   my $startlevel;
  612.   my $return = "eof";
  613.   while ($arg =~ s/-(w+)s*//) {
  614.     $elseok = 1 if ($1 eq "elseok");
  615.     $balanced = 1 if ($1 eq "balanced");
  616.   }
  618.   $currentlevel++;
  619.   $startlevel = $currentlevel;
  620.   if($balanced) {
  621.     $balanced = $currentlevel;
  622.   }
  623.     while(get_next_line()) {
  624.       $currentline++;
  625.       if ($debug) {
  626. #        my $line = process_vars($_);
  627. #        chop $line;
  628.         print "$currentfile.$currentline:P$currentlevel.$elseok:$return:$_";
  629.       }
  631.         next if (/^s*##/); #                            noop, it's a comment
  632.         if (! /^s*@/ ) { #                                          output
  633.           my $line = process_vars($_);
  634.           foreach $file (values(%outputs)) {
  635.             print $file "$line";
  636.           }
  637. } ####################################################################
  638.         elsif (/@s*exit@/) { #                                         EXIT
  639.             close_files;
  640.     die "exiting at conf file ($currentfile:$currentline) requestn";
  641. } elsif (/@s*debugs+([^@]+)@/) { #                          DEBUG
  642.           if ($1 eq "on") {
  643.             $debug = 1;
  644.           }
  645.           else {
  646.             $debug = 0;
  647.           }
  648. } elsif (/@s*strict tokens+([^@]+)@/) { #                  STRICT
  649.           if ($1 eq "on") {
  650.             $strict_unk_token = 1;
  651.           }
  652.           else {
  653.             $strict_unk_token = 0;
  654.           }
  655. } elsif (/@s*balanced@/) { #                               BALANCED
  656.           $balanced = $currentlevel;
  657. } elsif (/@s*opens+([^@]+)@/) { #                            OPEN
  658.     my $arg = $1;
  659.     my ($multiple) = (0);
  660.     while ($arg =~ s/-(w+)s+//) {
  661. $multiple = 1 if ($1 eq 'multiple');
  662.     }
  663.     my $spec = process_vars($arg);
  664.             open_file($multiple, $spec);
  665. } elsif (/@s*closes+([^@]+)@/) { #                          CLOSE
  666.     my $spec = process_vars($1);
  667.             close_file($spec);
  668. } elsif (/@s*appends+([^@]+)@/) { #                        APPEND
  669.     my $arg = $1;
  670.     my ($multiple) = (0);
  671.     while ($arg =~ s/-(w+)s+//) {
  672. $multiple = 1 if ($1 eq 'multiple');
  673.     }
  674.     my $spec = process_vars($arg);
  675.             $spec=">$spec";
  676.             open_file($multiple,$spec);
  677. } elsif (/@s*defines*(.*)@/) { #                              DEFINE
  678.     my $it = $1;
  679.     while (<$fh>) {
  680. last if (/@s*enddefines*@/);
  681. push @{$defines{$it}}, $_;
  682.     }
  683. } elsif (/@s*calldefines+(w+)@/) {
  684.     if ($#{$defines{$1}} == -1) {
  685. warn "called a define of $1 which didn't existn";
  686. warn "$currentfile:$currentline [$_]n";
  687.     } else {
  688. unshift @process_lines, @{$defines{$1}};
  689.     }
  690.        } elsif (/@s*run (.*)@/) { #                                    RUN
  691.     my $arg = $1;
  692.     my ($again) = (0);
  693.     while ($arg =~ s/-(w+)s+//) {
  694. $again = 1 if ($1 eq 'again');
  695. # if ($1 eq 'file') {
  696. #     my ($filearg) = ($arg =~ s/^(w+)//);
  697. # }
  698.     }
  699.     my $spec = process_vars($arg);
  700.     next if (!$again && $ranalready{$spec});
  701.     $ranalready{$spec} = 1;
  702.     my %oldout = %outputs;
  703.             my %emptyarray;
  704.             %outputs = %emptyoutputs;
  705.             process_file($spec,0,0);
  706.             close_files;
  707.     %outputs = %oldout;
  708. } elsif (/@s*push@/) { #                                      PUSH
  709.     my %oldout = %outputs;
  710.             my %emptyarray;
  711.             %outputs = %emptyoutputs;
  712.             process($arg);
  713.             close_files;
  714.     %outputs = %oldout;
  715. } elsif (/@s*pops*@/) { #                                     POP
  716.           $return = "pop";
  717.           last;
  718. } elsif (/@s*include (.*)@/) { #                            INCLUDE
  719.     my $arg = $1;
  720.     my ($missingok) = (0);
  721.     while ($arg =~ s/-(w+)s+//) {
  722. $missingok = 1 if ($1 eq 'ifexists');
  723.     }
  724.             my $spec = process_vars($arg);
  725.             process_file($spec,$missingok,1);
  726. } elsif (/@s*if([a-z]*)s+([^@]+)@/) { #                         IF
  727.           my ($type,$arg,$ok) = ($1,$2,0);
  728.           # check condition based on type
  729.           if (! $type) {
  730.             $ok = eval(process_vars($arg));
  731.           } elsif ($type eq conf) {
  732.             my $file = find_conf(process_vars($arg),1); # missingok
  733.             $ok = (-f $file);
  734.           } else {
  735.             m2c_die "unknown if modifier ($type)n";
  736.           }
  737.           # act on condition
  738.           if ($ok) {
  739.             $return = process("-elseok");
  740.           } else {
  741.             $return = skippart("-else");
  742.             $return = process("-elseok") if ($return eq "else");
  743.           }
  744.           if ($return eq "next") {
  745.             $return = skippart();
  746.             m2c_die("unbalanced code detected while exiting next/2 (returned $return)") if ($return ne "end");
  747. #            $return = "next";
  748.             last;
  749.           }
  750.           if (($return ne "end") && ($return ne "else")) {
  751.             m2c_die "unbalanced if / return $returnn";
  752.           }
  753.         } elsif (/@s*elseif.*@/) { #                           bogus elseif
  754.           m2c_die "error: use 'elsif' instead of 'elseif'n";
  755. } elsif (/@s*els(e|if).*@/) { #                          ELSE/ELSIF
  756.           if ($elseok != 1) {
  757.             chop $_;
  758.             m2c_die "unexpected els$1n";
  759.           }
  760.           $return = skippart();
  761.           if ($return ne "end") {
  762.             m2c_die "unbalanced els$1 / rtn $rtnn";
  763.           }
  764.           $return = "else";
  765.           last;
  766. } elsif (/@s*nexts*@/) { #                                  NEXT
  767.           $return = skippart();
  768.           m2c_die "unbalanced code detected while exiting next/1 (returned $return)" if ($return ne "end");
  769.           $return = "next";
  770.           last;
  771. } elsif (/@s*end@/) { #                                         END
  772.           $return = "end";
  773.           last;
  774. } elsif (/@s*evals+$(w+)s*=s*([^@]*)/) { #                EVAL
  775.     my ($v, $e) = ($1, $2);
  776. #     print STDERR "eval: $en";
  777.     my $e = process_vars($e);
  778.     $vars{$v} = eval($e);
  779.             if (!defined($vars{$v})) {
  780.               warn "$@";
  781.               warn "$currentfile:$currentline [$_]n";
  782.             }
  783. } elsif (/@s*perlevals*(.*)@/) { #                        PERLEVAL
  784. #     print STDERR "perleval: $1n";
  785.     my $res = eval($1);
  786.             if ($res) {
  787.               warn "$@";
  788.               warn "$currentfile:$currentline [$_]n";
  789.             }
  790. } elsif (/@s*startperls*@/) { #                          STARTPERL
  791.     my $text;
  792.     while (get_next_line()) {
  793. last if (/@s*endperls*@/);
  794. $text .= $_;
  795.     }
  796.     my $res = eval($text);
  797.             if ($res) {
  798.               warn "$@";
  799.               warn "$currentfile:$currentline [$_]n";
  800.             }
  801. #     print STDERR "perleval: $1n";
  802. } elsif (/@s*printfs+("[^"]+")s*,?(.*)@/) { #           PRINTF
  803.     my ($f, $rest) = ($1, $2);
  804.     $rest = process_vars($rest);
  805.     my @args = split(/s*,s*/,$rest);
  806.     $f = eval $f;
  807. #     print STDERR "printf: $f, ", join(", ",@args),"n";
  808.     foreach $file (values(%outputs)) {
  809. printf $file (eval {$f}, @args);
  810.     }
  811. } elsif (/@s*foreachs+$([^@]+)s+scalars*s*@/) { #      SCALARS
  812.     my $var = $1;
  813.     my $stash = do_tell();
  814.     my $scalar;
  815.     my @thekeys = keys(%scalars);
  816.     if ($#thekeys == -1) {
  817.       $return = skippart();
  818.     } else {
  819.       if ($havenetsnmpoid) {
  820.   @thekeys = sort {
  821.     new NetSNMP::OID($a) <=> 
  822.       new NetSNMP::OID($b) } @thekeys;
  823.       }
  824.       foreach $scalar (@thekeys) {
  825.   $return = do_a_loop($stash, $vars{$var}, $scalar,
  826.       $currentscalar, $scalar,
  827.       $currentvar, $scalar);
  828.       }
  829.     }
  830.             m2c_die("foreach did not end with @end@") if($return ne "end");
  831. } elsif (/@s*foreachs+$([^@]+)s+notifications*s*@/) {
  832.     my $var = $1;
  833.     my $stash = do_tell();
  834.     my $notify;
  835.     my @thekeys = keys(%notifications);
  836.     if ($#thekeys == -1) {
  837.       $return = skippart();
  838.     } else {
  839.       if ($havenetsnmpoid) {
  840.   @thekeys = sort {
  841.     new NetSNMP::OID($a) <=> 
  842.       new NetSNMP::OID($b) } @thekeys;
  843.       }
  844.       foreach $notify (@thekeys) {
  845.   $return = do_a_loop($stash, $vars{$var}, $notify,
  846.       $currentnotify, $notify);
  847.       }
  848.     }
  849.             m2c_die("foreach did not end with @end@") if($return ne "end");
  850.   } elsif (/@s*foreachs+$([^@]+)s+varbindss*@/) {
  851.     my $var = $1;
  852.     my $stash = do_tell();
  853.     my $varbind;
  854.     if ($#{$notifyvars{$currentnotify}} == -1) {
  855.       $return = skippart();
  856.     } else {
  857.       foreach $varbind (@{$notifyvars{$currentnotify}}) {
  858. # print "looping on $var for $varbindn";
  859.   $return = do_a_loop($stash, $vars{$var}, $varbind,
  860.       $currentvarbind, $varbind);
  861.       }
  862.     }
  863.             m2c_die("foreach did not end with @end@") if($return ne "end");
  864.   } elsif (/@s*foreachs+$([^@]+)s+tables*s*@/) {
  865.     my $var = $1;
  866.     my $stash = do_tell();
  867.     my $table;
  868.     my @thekeys = keys(%tables);
  869.     if ($#thekeys == -1) {
  870.       $return = skippart();
  871.     } else {
  872.       if ($havenetsnmpoid) {
  873.   @thekeys = sort {
  874.     new NetSNMP::OID($a) <=> 
  875.       new NetSNMP::OID($b) } @thekeys;
  876.       }
  877.       foreach $table (@thekeys) {
  878.   $return = do_a_loop($stash, $vars{$var}, $table, 
  879.       $currenttable, $table);
  880.       }
  881.     }
  882.             m2c_die("foreach did not end with @end@ ($return)") if($return ne "end");
  883.   } elsif (/@s*foreachs+$([^@]+)s+stuffs*(.*)@/) {
  884.     my $var = $1;
  885.     my $stuff = $2;
  886.     my @stuff = split(/[,s]+/, $stuff);
  887.     my $stash = do_tell();
  888.     if ($#stuff == -1) {
  889.       $return = skippart();
  890.     } else {
  891.       foreach $st (@stuff) {
  892.   $return = do_a_loop($stash, $vars{$var}, $st,
  893.       $currentstuff, $st);
  894.       }
  895.     }
  896.             m2c_die("foreach did not end with @end@ ($return)") if($return ne "end");
  897.   } elsif (/@s*foreachs+$([^@]+)s+(column|index|internalindex|externalindex|nonindex)s*@/) {
  898.     my ($var, $type) = ($1, $2);
  899.     my $stash = do_tell();
  900.     my $column;
  901.     if ($#{$tables{$currenttable}{$type}} == -1) {
  902.       $return = skippart();
  903.     } else {
  904.       foreach $column (@{$tables{$currenttable}{$type}}) {
  905. # print "looping on $var for $type -> $columnn";
  906.   $return = do_a_loop($stash, $vars{$var}, $column,
  907.       $currentcolumn, $column,
  908.       $currentvar, $column);
  909.       }
  910.     }
  911.             m2c_die("foreach did not end with @end@") if($return ne "end");
  912.   } elsif (/@s*foreachs+$([^@]+)s+$([^@]+)s+ranges+([^@]+)@/) {
  913.     my ($svar, $evar, $node) = ($1, $2, $3);
  914.     my $stash = do_tell();
  915.     my $range;
  916.     $node = $currentcolumn if (!$node);
  917.     my $mibn = $SNMP::MIB{process_vars($node)};
  918.     die "no such mib node: $node" if (!$mibn);
  919.     my @ranges = @{$mibn->{'ranges'}};
  920.     if ($#ranges > -1) {
  921. foreach $range (@ranges) {
  922.     $return = do_a_loop($stash, $vars{$svar}, $range->{'low'},
  923. $vars{$evar}, $range->{'high'});
  924. }
  925.     } else {
  926. $return = skippart();
  927.     }
  928.             m2c_die("foreach did not end with @end@") if($return ne "end");
  929. } elsif (/@s*foreachs+$([^@,]+)s*,*s+$([^@]+)s+(enums*)s*@/) {
  930.     my ($varvar, $varval, $type) = ($1, $2, $3);
  931.     my $stash = do_tell();
  932.     my $enum, $enum2;
  934.     my @keys = sort { $SNMP::MIB{$currentvar}{'enums'}{$a} <=>
  935.   $SNMP::MIB{$currentvar}{'enums'}{$b} } (keys(%{$SNMP::MIB{$currentvar}{'enums'}}));
  936.     if ($#keys > -1) {
  937. foreach $enum (@keys) {
  938.                   ($enum2 = $enum) =~ s/-/_/g;
  939.     $return = do_a_loop($stash, $vars{$varvar}, $enum2,
  940. $vars{$varval},
  941. $SNMP::MIB{$currentvar}{'enums'}{$enum});
  942. }
  943.     } else {
  944. $return = skippart();
  945.     }
  946.             m2c_die("foreach did not end with @end@") if($return ne "end");
  947. } elsif (/@s*prompts+$(S+)s*(.*)@/) { #                  PROMPT
  948.     my ($var, $prompt) = ($1, $2);
  949.     if (!$term) {
  950. my $haveit = eval { require Term::ReadLine };
  951. if ($haveit) {
  952.     $term = new Term::ReadLine 'mib2c';
  953. }
  954.     }
  955.     if ($term) {
  956. $vars{$var} = $term->readline(process_vars($prompt));
  957.     }
  958. } elsif (/@s*prints+([^@]*)@/) { #                           PRINT
  959.           my $line = process_vars($1);
  960.           print "$linen";
  961. } else {
  962.           my $line = process_vars($_);
  963.   mib2c_output($line);
  964.           chop $_;
  965.           warn "$currentfile:$currentline contained a line that started with a @ but did not match any mib2c configuration tokens.n";
  966.           warn "(maybe missing the trailing @?)n";
  967.           m2c_die if ($strict_unk_token == 1);
  968. }
  969. #      $return = "eof";
  970.     }
  971.     print "< Balanced $balanced / level $currentlevel / rtn $return / $_n" if($debug);
  972.     if((!$_) && ($return ne "eof")) {
  973. #      warn "switching return of '$return' to EOFn" if($debug);
  974.       $return = "eof";
  975.     }
  976.   if ($balanced) {
  977.     if(($balanced != $currentlevel) || ($return ne "eof")) {
  978.       m2c_die "@balanced@ specified, but processing terminated with '$return' before EOF!";
  979.     }
  980.   }
  981.   $currentlevel--;
  982.   return $return;
  983. }
  985. sub mib2c_output {
  986.     my $line = shift;
  987.     foreach $file (values(%outputs)) {
  988. print $file "$line";
  989.     }
  990. }
  993. sub setup_data {
  994.     my $mib = shift;
  995.     if ($mib->{label} =~ /Table$/) {
  996. my $tablename = $mib->{label};
  997. my $entry = $mib->{children};
  998. my $columns = $entry->[0]{children};
  999.         my $augments = $entry->[0]{'augments'};
  1000. foreach my $col (sort { $a->{'subID'} <=> $b->{'subID'} } @$columns) {
  1001.     # store by numeric key so we can sort them later
  1002.     push @{$tables{$tablename}{'column'}}, $col->{'label'};
  1003. }
  1004.         if ($augments) {
  1005.            my $mib = $SNMP::MIB{$augments} || 
  1006. die "can't find info about augmented table $augments in table $tablenamen";
  1007.            $mib = $mib->{parent} || 
  1008. die "can't find info about augmented table $augments in table $tablenamen";
  1009.    my $entry = $mib->{children};
  1010.    foreach my $index (@{$entry->[0]{'indexes'}}) {
  1011.        my $node = $SNMP::MIB{$index} || 
  1012.    die "can't find info about index $index in table $tablenamen";
  1013.        push @{$tables{$tablename}{'index'}}, $index;
  1014.        push @{$tables{$tablename}{'externalindex'}}, $index;
  1015.    }
  1016.            my $columns = $entry->[0]{children};
  1017.         }
  1018.         else {
  1019.           foreach my $index (@{$entry->[0]{'indexes'}}) {
  1020.     my $node = $SNMP::MIB{$index} || 
  1021.               die "can't find info about index $index in table $tablenamen";
  1022.             push @{$tables{$tablename}{'index'}}, $index;
  1023.             if("@{$tables{$tablename}{'column'}}" =~ /$indexb/ ) {
  1024. #              print "idx INT $indexn";
  1025.               push @{$tables{$tablename}{'internalindex'}}, $index;
  1026.             } else {
  1027. #              print "idx EXT $indexn";
  1028.               push @{$tables{$tablename}{'externalindex'}}, $index;
  1029.             }
  1030.           }
  1031.         }
  1032. foreach my $col (sort { $a->{'subID'} <=> $b->{'subID'} } @$columns) {
  1033.             next if ( "@{$tables{$tablename}{'index'}}" =~ /$col->{'label'}b/ );
  1034.             push @{$tables{$tablename}{'nonindex'}}, $col->{'label'};
  1035. }
  1036. #        print "indexes: @{$tables{$tablename}{'index'}}n";
  1037. #        print "internal indexes: @{$tables{$tablename}{'internalindex'}}n";
  1038. #        print "external indexes: @{$tables{$tablename}{'externalindex'}}n";
  1039. #        print "non-indexes: @{$tables{$tablename}{'nonindex'}}n";
  1040.     } else {
  1041. my $children = $mib->{children};
  1042. if ($#children == -1 && $mib->{type}) {
  1043.     # scalar
  1044.     if ($mib->{type} eq "NOTIF" ||
  1045.         $mib->{type} eq "TRAP") {
  1046.         my $notifyname = $mib->{label};
  1047.                 my @varlist = ();
  1048.         $notifications{$notifyname} = 1;
  1049.                 $notifyvars{$notifyname} = $mib->{varbinds};
  1050.     } else {
  1051.         $scalars{$mib->{label}} = 1;
  1052.     }
  1053. } else {
  1054.     my $i;
  1055.     for($i = 0; $i <= $#$children; $i++) {
  1056. setup_data($children->[$i]);
  1057.     }
  1058. }
  1059.     }
  1060. }
  1062. sub min {
  1063.     return $_[0] if ($_[0] < $_[1]);
  1064.     return $_[1];
  1065. }
  1067. sub max {
  1068.     return $_[0] if ($_[0] > $_[1]);
  1069.     return $_[1];
  1070. }
  1072. sub find_conf {
  1073.   my ($configfile, $missingok) = (@_);
  1075.   foreach my $d (@search_dirs, @def_search_dirs) {
  1076.       return "$d/$configfile" if (-f "$d/$configfile");
  1077.   }
  1078.   return $configfile if (-f "$configfile");
  1079.   return if ($missingok);
  1081.   print STDERR "Can't find a configuration file called $configfilen";
  1082.   print STDERR "(referenced at $currentfile:$currentline)n" if ($currentfile);
  1083.   print STDERR "I looked in:n";
  1084.   print "  " . join("n  ", @search_dirs, @def_search_dirs), "n";
  1085.   exit 1;
  1086. }
  1088. sub open_conf {
  1089.     my $configfile = shift;
  1090. # process .conf file
  1091.     if (! -f "$configfile") {
  1092. print STDERR "Can't find a configuration file called $configfilen";
  1093. exit 1;
  1094.     }
  1095.     $currentfile = $configfile;
  1096.     my $fh = new IO::File;
  1097.     $fh->open("$configfile");
  1098.     return $fh;
  1099. }
  1101. sub count_scalars {
  1102.     my @k = keys(%scalars);
  1103.     return $#k + 1;
  1104. }
  1106. sub count_tables {
  1107.     my @k = keys(%tables);
  1108.     return $#k + 1;
  1109. }
  1111. sub count_columns {
  1112.     my $table = shift;
  1113.     return $#{$tables{$table}{'column'}} + 1;
  1114. }
  1116. sub table_is_writable {
  1117.     my $table = shift;
  1118.     my $column;
  1119.     my $result = 0;
  1120.     foreach $column (@{$tables{$table}{'column'}}) {
  1121.       if($SNMP::MIB{$column}{access} =~ /(ReadWrite|Create|WriteOnly)/) {
  1122.         $result = 1;
  1123.         last;
  1124.       }
  1125.     }
  1126.     return $result;
  1127. }
  1129. sub table_has_create {
  1130.     my $table = shift;
  1131.     my $column;
  1132.     my $result = 0;
  1133.     foreach $column (@{$tables{$table}{'column'}}) {
  1134.       if($SNMP::MIB{$column}{access} =~ /(Create)/) {
  1135.         $result = 1;
  1136.         last;
  1137.       }
  1138.     }
  1139.     return $result;
  1140. }
  1142. sub table_has_rowstatus {
  1143.     my $table = shift;
  1144.     my $column;
  1145.     my $result = 0;
  1146.     foreach $column (@{$tables{$table}{'column'}}) {
  1147.       if($SNMP::MIB{$column}{syntax} =~ /(RowStatus)/) {
  1148.         $result = 1;
  1149.         last;
  1150.       }
  1151.     }
  1152.     return $result;
  1153. }
  1155. sub count_indexes {
  1156.     my $table = shift;
  1157.     return $#{$tables{$table}{'index'}} + 1;
  1158. }
  1160. sub count_external_indexes {
  1161.     my $table = shift;
  1162.     return $#{$tables{$table}{'externalindex'}} + 1;
  1163. }
  1165. sub count_notifications {
  1166.     my @k = keys(%notifications);
  1167.     return $#k + 1;
  1168. }
  1170. sub count_varbinds {
  1171.     my $notify = shift;
  1172.     return $#{$notifyvars{$notify}} + 1;
  1173. }