Subversion Repositories openrisc

# mib2c.storage.conf:
#
#  This is a special mib2c.conf file that assumes that you want to do
#  all storage of information locally rather than pulling the
#  information from another source outside the agent (EG, the
#  kernel).  To accomplish this, it defines a structure for the
#  storage of tables and assumes you want to use the header_complex
#  functions for retrieving and storing that data in a local data
#  store.  It even writes a .conf file parser for you and sets you up
#  for being able to do persistant storage fairly simply.
#
#  In short:  it trys to do almost all of the work for you...  Almost...

# 
# Define types of data by mib type, and translate into needed C code.
#

# We need to get some extra stuff into the variable declarations
# before sourcing the main mib2c.vartypes.conf file below.
type:           OCTETSTR
storage:            char   *${name};
storage:            size_t  ${name}Len;
varlenname:     StorageTmp->${name}Len
vartest:          if (StorageTmp->${name} == NULL) {
vartest:            config_perror(\"invalid specification for ${name}\");
vartest:            return;
vartest:          }
vartest:
action:              tmpvar = StorageTmp->$name;
action:              tmplen = StorageTmp->${name}Len;
action:              memdup((u_char **) &StorageTmp->$name, var_val, var_val_len);
action:              StorageTmp->${name}Len = var_val_len;
undo:                SNMP_FREE(StorageTmp->${name});
undo:                StorageTmp->${name} = tmpvar;
undo:                StorageTmp->${name}Len = tmplen;
commit:              SNMP_FREE(tmpvar);
sizeofstart:    
sizeofend:      Len
tmpvar:         char *
casttmp:        strdup((char *) tmpvar);
#
type:           INTEGER
storage:            long    $name;
storageret:     &
varlenname:     tmpint
sizeofstart:    sizeof(
sizeofend:      )
tmpvar:         int
action:              tmpvar = StorageTmp->$name;
action:              StorageTmp->${name} = *((long *) var_val);
undo:                StorageTmp->${name} = tmpvar;
casttmp:        tmpvar;
#
type:           OBJECTID
storage:            oid     *$name;
storage:            size_t   ${name}Len
varlenname:     StorageTmp->${name}Len
vartest:          if (StorageTmp->${name} == NULL) {
vartest:            config_perror(\"invalid specification for ${name}\");
vartest:            return;
vartest:          }
vartest:
action:              tmpvar = StorageTmp->$name;
action:              tmplen = StorageTmp->${name}Len;
action:              memdup((u_char **) &StorageTmp->$name, var_val, var_val_len);
action:              StorageTmp->${name}Len = var_val_len/sizeof(oid);
undo:                SNMP_FREE(StorageTmp->${name});
undo:                StorageTmp->${name} = tmpvar;
undo:                StorageTmp->${name}Len = tmplen;
commit:              SNMP_FREE(tmpvar);
sizeofstart:    
sizeofend:      Len
tmpvar:         oid *
casttmp:        (oid *) tmpvar;
freetmp:        SNMP_FREE(tmpvar);
#
type:           COUNTER64
storage:            struct counter64 $name;
varlenname:     tmpint
sizeofstart:    sizeof(
sizeofend:      )
tmpvar:         struct counter64 *
casttmp:        (struct counter64 *) tmpvar;

############################################################################
# source variable typing information:
include: mib2c.vartypes.conf

############################################################################
# The .h file
############################################################################
type:   code-dot-h
code:   /* This file was generated by mib2c and is intended for use as a mib module
code:     for the ucd-snmp snmpd agent. */
code:
code:   #ifndef _MIBGROUP_${OUTPUTNAME}_H
code:   #define _MIBGROUP_${OUTPUTNAME}_H
code:   
code:   /* we may use header_complex from the header_complex module */
code:   
code:   config_require(header_complex)
code:
code:   /* our storage structure(s) */
code:   $variables{'code-structure-per-table'}{'processed'}
code:
code:   /* enum definitions from the covered mib sections */
code:
code:   $variables{'code-enums'}{'processed'}
code:
code:   /* function prototypes */
code:   
code:   void   init_$outputName(void);
code:   $variables{'code-var-table-decl'}{'processed'}
code:   $variables{'code-write-func-decl'}{'processed'}
code:   $variables{'code-write-rowstatus-decl'}{'processed'}
code:   
code:   #endif /* _MIBGROUP_${OUTPUTNAME}_H */

#
# Structure definition, one per table
#
type:           code-structure-per-table
processtable:   code-structure-per-table

code:   struct ${vtable}_data {
code:   $variables{$vtable}{'code-structure'}{'processed'}
code:   };

#
# Structure storage arrays, one per table
#
type:           code-structure-storage
processtable:   code-structure-storage

code:   static struct header_complex_index *${vtable}Storage = NULL;

#
# Structure definition line.
#
type:   code-structure
process: code-structure

code:   " . eval ("\"$variables{$mib->{'type'}}{'storage'}\"") . "
#$variables{$i}{'code'}\""evalstr(
#
# ENUM definitions
#
type:           code-enums
process:        code-enums
skipif: $mib->{'textualConvention'} eq "RowStatus" || $mib->{'textualConvention'} eq "StorageType"

code:   " . eval{ my ($i, $x); foreach $i (sort {$mib->{'enums'}{$a} <=> $mib->{'enums'}{$b}} keys(%{$mib->{'enums'}})) { $x .= sprintf("#define %-40s %d\n","${NAME}_" . uc($i),$mib->{'enums'}{$i}); } $x; } . "

############################################################################
# The .c file, top
############################################################################
type:   code-main-part
code:   /* This file was generated by mib2c and is intended for use as
code:      a mib module for the ucd-snmp snmpd agent. */
code:   
code:   /* This should always be included first before anything else */
code:   #include <config.h>
code:   #if HAVE_STDLIB_H
code:   #include <stdlib.h>
code:   #endif
code:   #if HAVE_STRING_H
code:   #include <string.h>
code:   #else
code:   #include <strings.h>
code:   #endif
code:   
code:   /* minimal include directives */
code:   #include \"mibincl.h\"
code:   #include \"header_complex.h\"
code:   #include \"$outputName.h\"
code:   #include \"snmp-tc.h\"
code:   
code:   /* 
code:    * ${outputName}_variables_oid:
code:    *   this is the top level oid that we want to register under.  This
code:    *   is essentially a prefix, with the suffix appearing in the
code:    *   variable below.
code:    */
code:   
code:   oid ${outputName}_variables_oid[] = { $commaoid };
code:   
code:   /* 
code:    * variable$varlen ${outputName}_variables:
code:    *   this variable defines function callbacks and type return information 
code:    *   for the $outputName mib section 
code:    */
code:   
code:   struct variable$varlen ${outputName}_variables[] = {
code:   /*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
code:   $variables{'variable-structure-info'}{'processed'}
code:   };
code:   /*    (L = length of the oidsuffix) */
code:   
code:   /* global storage of our data, saved in and configured by header_complex() */
code:   $variables{'code-structure-storage'}{'processed'}
code:
code:   /*
code:    * init_$outputName():
code:    *   Initialization routine.  This is called when the agent starts up.
code:    *   At a minimum, registration of your variables should take place here.
code:    */
code:   void init_$outputName(void) {
code:     DEBUGMSGTL((\"$outputName\", \"initializing...  \"));
code:   
code:     /* register ourselves with the agent to handle our mib tree */
code:     REGISTER_MIB(\"$outputName\", ${outputName}_variables, variable$varlen,\
code:                  ${outputName}_variables_oid);
code:
code:     /* register our config handler(s) to deal with registrations */
code:   $variables{'code-parser-registration'}{'processed'}
code:
code:     /* place any other initialization junk you need here */
code:   
code:     DEBUGMSGTL((\"$outputName\", \"done.\\n\"));
code:   }
code:   
code:   $variables{'code-parser'}{'processed'}
code:   
code:   $variables{'code-var_table'}{'processed'}
code:
code:   $variables{'code-write-func'}{'processed'}
code:
code:   $variables{'code-write-rowstatus'}{'processed'}

############################################################################
# var_ function for tables, which is handled specially and used above
#
#   Note: $vtable is set to the table name in the processtable loop.
############################################################################

#
# header file defs first
#
type:           code-var-table-decl
processtable:   code-var-table-decl

code:   FindVarMethod var_$vtable;
code:   void parse_$vtable(char *, char *);

#
# .conf Parser Code per table
#
type:           code-parser-registration
processtable:   code-parser-registration
code:     snmpd_register_config_handler(\"$vtable\", parse_$vtable, NULL,
code:                                   \"HELP STRING\");

type:           code-varlist-add
process:        code-varlist-add
skipif:         $variables{$vroutine}{$name}{'isanindex'} != 1
code:     snmp_varlist_add_variable(&vars, NULL, 0, $variables{$mib->{type}}{asnType}, ($variables{$mib->{type}}{'cast'}) thedata->$name, $variables{$mib->{type}}{'sizeofstart'}thedata->$name$variables{$mib->{type}}{'sizeofend'}); /* $name */

type:           code-parser
processtable:   code-parser

code:   /* 
code:    * ${vtable}_add(): adds a structure node to our data set 
code:    */
code:   int
code:   ${vtable}_add(struct ${vtable}_data *thedata) {
code:     struct variable_list *vars = NULL;
code:
code:     DEBUGMSGTL((\"$outputName\", \"adding data...  \"));
code:    /* add the index variables to the varbind list, which is 
code:       used by header_complex to index the data */
code:
code:   $variables{$vtable}{'code-varlist-add'}{'processed'}
code:
code:     header_complex_add_data(&${vtable}Storage, vars, thedata);
code:     DEBUGMSGTL((\"$vtable\",\"registered an entry\\n\"));
code:   
code:     DEBUGMSGTL((\"$outputName\", \"done.\\n\"));
code:     return SNMPERR_SUCCESS;
code:   }
code:
code:   /*
code:    * parse_$vtable():
code:    *   parses .conf file entries needed to configure the mib.
code:    */
code:   void
code:   parse_$vtable(char *token, char *line) {
code:     size_t tmpint;
code:     struct ${vtable}_data *StorageTmp = SNMP_MALLOC_STRUCT(${vtable}_data);
code:     struct variable_list *vars = NULL;
code:
code:       DEBUGMSGTL((\"$outputName\", \"parsing config...  \"));
code:
code:     if (StorageTmp == NULL) {
code:       config_perror(\"malloc failure\");
code:       return;
code:     }
code:
code:   $variables{$vtable}{'code-parser-sections'}{'processed'}
code:
code:     ${vtable}_add(StorageTmp);
code:       
code:     DEBUGMSGTL((\"$outputName\", \"done.\\n\"));
code:   }
code:   
code:   
code:   /*
code:    * store_$vtable():
code:    *   stores .conf file entries needed to configure the mib.
code:    */
code:   void
code:   store_$vtable(void) {
code:     char line[SNMP_MAXBUF];
code:     char *cptr;
code:     size_t tmpint;
code:     struct ${vtable}_data *StorageTmp;
code:     struct header_complex_index *hcindex;
code:   
code:     DEBUGMSGTL((\"$outputName\", \"storing data...  \"));
code:   
code:     memset(line,0,sizeof(line));
code:   
code:     strcat(line, \"$vtable\");
code:     cptr = line + strlen(line);
code:
code:     for(hcindex=${vtable}Storage; hcindex != NULL; 
code:         hcindex = hcindex->next) {
code:       StorageTmp = (struct ${vtable}_data *) hcindex->data;
code:
code:   $variables{$vtable}{'code-persistent-sections'}{'processed'}
code:
code:       snmpd_store_config(line);
code:     }
code:     DEBUGMSGTL((\"$outputName\", \"done.\\n\"));
code:   }

# individual sections for the parser
type:           code-parser-sections
process:        code-parser-sections
skipif:         $mib->{'access'} =~ /NoAccess/

code:     line = read_config_read_data($variables{$mib->{type}}{asnType}, line, &StorageTmp->$name, &" . eval ("\"$variables{$mib->{type}}{varlenname}\"") . ");
code:   " . eval ("\"$variables{$mib->{type}}{vartest}\"") . "

#
# .conf persistent save Code per table
#
type:           code-persistent-sections
process:        code-persistent-sections
skipif:         $mib->{'access'} =~ /NoAccess/
code:       cptr = read_config_store_data($variables{$mib->{type}}{asnType}, cptr, &StorageTmp->$name, &" . eval ("\"$variables{$mib->{type}}{varlenname}\"") . ");

#
# Code code per table
#
type:           code-var_table
processtable:   code-var_table

code:   /*
code:    * var_$vtable():
code:    *   Handle this table separately from the scalar value case.
code:    *   The workings of this are basically the same as for var_$outputName above.
code:    */
code:   unsigned char *
code:   var_$vtable(struct variable *vp,
code:               oid     *name,
code:               size_t  *length,
code:               int     exact,
code:               size_t  *var_len,
code:               WriteMethod **write_method)
code:   {
code:
code:   struct ${vtable}_data *StorageTmp = NULL;
code:   
code:     DEBUGMSGTL((\"$outputName\", \"var_$vtable: Entering...  \\n\"));
code:     /* 
code:      * this assumes you have registered all your data properly
cdoe:      * with header_complex_add() somewhere before this
code:      */
code:     if ((StorageTmp =
code:          header_complex(${vtable}Storage, vp,name,length,exact,
code:                              var_len,write_method)) == NULL)
code:       return NULL;
code:   
code:     /* 
code:      * this is where we do the value assignments for the mib results.
code:      */
code:     switch(vp->magic) {\n\n
code:   $variables{$vtable}{'code-case-statements'}{'processed'}
code:       default:
code:         ERROR_MSG(\"\");
code:     }
code:     return NULL;
code:   }


############################################################################
# case statement sections
############################################################################
type:           code-case-statements
process:        code-case-statements
skipif:         $mib->{'access'} =~ /NoAccess/

code:               case $NAME:
code:                   " . (($mib->{'access'} =~ /ReadWrite|WriteOnly|Create/) ? "*write_method = write_$mib->{label};" : "") . "
code:                   *var_len = $variables{$mib->{'type'}}{'sizeofstart'}StorageTmp->$mib->{label}$variables{$mib->{'type'}}{'sizeofend'};
code:                   return (u_char *) $variables{$mib->{'type'}}{'storageret'}StorageTmp->$mib->{label};
code:           

############################################################################
# storage structure information
############################################################################
type:           variable-structure-info
process:        variable-structure-info
skipif:         $mib->{'access'} =~ /NoAccess/
code:           " . sprintf("#define   %-20s  $count", $NAME) . "
code:           " . sprintf("  { %-20s, %-14s, %-6.6s, %s, %d, { %s } },", $NAME, $variables{$mib->{'type'}}{'asnType'}, $accessToUCD{$mib->{'access'}}, "var_$vroutine", $depth-1, $subid) . "

############################################################################
# write function definition, also appended to the end of the .c file.
############################################################################
#
# Header info: declair write functions for set processing
#
process:        code-write-func-decl
type:           code-write-func-decl
skipif:         $mib->{'access'} !~ /Write|Create/
code:           WriteMethod write_$name;
#
# C code
#
type:           code-write-func
process:        code-write-func
skipif:         $mib->{'textualConvention'} eq "RowStatus" || $mib->{'access'} !~ /Write|Create/
code:   int
code:   write_$name(int      action,
code:               u_char   *var_val,
code:               u_char   var_val_type,
code:               size_t   var_val_len,
code:               u_char   *statP,
code:               oid      *name,
code:               size_t    name_len)
code:   {
code:     static $variables{$mib->{'type'}}{tmpvar} tmpvar;
code:     struct ${vroutine}_data *StorageTmp = NULL;
code:     static size_t tmplen;
code:     size_t newlen=name_len - (sizeof(${outputName}_variables_oid)/sizeof(oid) + $depth - 1);
code:
code:     DEBUGMSGTL((\"$outputName\", \"write_$name entering action=%d...  \\n\", action));
code:     if ((StorageTmp =
code:          header_complex(${vroutine}Storage, NULL,
code:                         &name[sizeof(${outputName}_variables_oid)/sizeof(oid) + $depth - 1], 
code:                         &newlen, 1, NULL, NULL)) == NULL)
code:         return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
code:   
code:     switch ( action ) {
code:           case RESERVE1:
code:             if (var_val_type != $variables{$mib->{'type'}}{asnType}){
code:                 fprintf(stderr, \"write to $name not $variables{$mib->{'type'}}{asnType}\\n\");
code:                 return SNMP_ERR_WRONGTYPE;
code:             }
code:             break;
code:   
code:           case RESERVE2:
code:                /* memory reseveration, final preparation... */
code:             break;
code:   
code:           case FREE:
code:                /* Release any resources that have been allocated */
code:             break;
code:   
code:           case ACTION:
code:                /* The variable has been stored in $variables{$mib->{'type'}}{variable} for
code:                you to use, and you have just been asked to do something with
code:                it.  Note that anything done here must be reversable in the UNDO case */
code:           ".eval ("\"$variables{$mib->{type}}{action}\"")."
code:             break;
code:   
code:           case UNDO:
code:                /* Back out any changes made in the ACTION case */
code:           ".eval ("\"$variables{$mib->{type}}{undo}\"")."
code:             break;
code:   
code:           case COMMIT:
code:                /* Things are working well, so it's now safe to make the change
code:                permanently.  Make sure that anything done here can't fail! */
code:           ".eval ("\"$variables{$mib->{'type'}}{'commit'}\"")."
code:             break;
code:     }
code:     return SNMP_ERR_NOERROR;
code:   }
code:
code:
############################################################################
# copy memory from varlist
############################################################################
type:           code-varlist-copy
process:        code-varlist-copy
skipif:         $variables{$vroutine}{$name}{'isanindex'} != 1
code:               memdup((u_char **) &(StorageNew->$name), 
code:                      vp->val.$variables{$mib->{'type'}}{variable},
code:                      vp->val_len);
code:               StorageNew->${name}Len = vp->val_len;
code:               vp = vp->next_variable;
############################################################################
# add null pointers to a varlist; value to be parsed later
############################################################################
type:           code-varlist-add-null
process:        code-varlist-add-null
skipif:         $variables{$vroutine}{$name}{'isanindex'} != 1
code:             snmp_varlist_add_variable(&vars, NULL, 0, $variables{$mib->{'type'}}{asnType}, NULL, 0); /* $name */
############################################################################
# write function definition for a RowStatus object, 
#   - allows for creation/deletion.
############################################################################
#
# Header info: declair write functions for set processing
#
process:        code-write-rowstatus-decl
type:           code-write-rowstatus-decl
skipif:         $mib->{'textualConvention'} ne "RowStatus"
code:           WriteMethod write_$name;
#
# code
#
type:           code-write-rowstatus
process:        code-write-rowstatus
skipif:         $mib->{'textualConvention'} ne "RowStatus"
code:   int
code:   write_$name(int      action,
code:               u_char   *var_val,
code:               u_char   var_val_type,
code:               size_t   var_val_len,
code:               u_char   *statP,
code:               oid      *name,
code:               size_t    name_len)
code:   {
code:     struct ${vroutine}_data *StorageTmp = NULL;
code:     static struct ${vroutine}_data *StorageNew, *StorageDel;
code:     size_t newlen=name_len - (sizeof(${vroutine}_variables_oid)/sizeof(oid) + 3 - 1);
code:     static int old_value;
code:     int set_value;
code:     static struct variable_list *vars, *vp;
code:     struct header_complex_index *hciptr;
code:     char who[MAX_OID_LEN], flagName[MAX_OID_LEN];
code:   
code:     StorageTmp =
code:       header_complex(${vroutine}Storage, NULL,
code:                      &name[sizeof(${vroutine}_variables_oid)/sizeof(oid) + 3 - 1], 
code:                      &newlen, 1, NULL, NULL);
code:     
code:     
code:     if (var_val_type != ASN_INTEGER || var_val == NULL){
code:       fprintf(stderr, \"write to $name not ASN_INTEGER\\n\");
code:       return SNMP_ERR_WRONGTYPE;
code:     }
code:     set_value = *((long *) var_val);
code:   
code:     /* check legal range, and notReady is reserved for us, not a user */
code:     if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
code:       return SNMP_ERR_INCONSISTENTVALUE;
code:       
code:     switch ( action ) {
code:           case RESERVE1:
code:             /* stage one: test validity */
code:             if (StorageTmp == NULL) {
code:               /* create the row now? */
code:   
code:               /* ditch illegal values now */
code:               if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
code:                 return SNMP_ERR_INCONSISTENTVALUE;
code:       
code:               /* destroying a non-existent row is actually legal */
code:               if (set_value == RS_DESTROY) {
code:                 return SNMP_ERR_NOERROR;
code:               }
code:   
code:               /* illegal creation values */
code:               if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
code:                 return SNMP_ERR_INCONSISTENTVALUE;
code:               }
code:             } else {
code:               /* row exists.  Check for a valid state change */
code:               if (set_value == RS_CREATEANDGO || set_value == RS_CREATEANDWAIT) {
code:                 /* can't create a row that exists */
code:                 return SNMP_ERR_INCONSISTENTVALUE;
code:               }
code:               /* XXX: interaction with row storage type needed */
code:             }
code:             break;
code:   
code:   
code:           case RESERVE2:
code:             /* memory reseveration, final preparation... */
code:             if (StorageTmp == NULL) {
code:               /* creation */
code:               vars = NULL;
code:   
code:   $variables{'code-varlist-add-null'}{'processed'}
code:                       
code:               if (header_complex_parse_oid(&(name[sizeof(${vroutine}_variables_oid)/sizeof(oid)+2]), newlen,
code:                                            vars) != SNMPERR_SUCCESS) {
code:                 /* XXX: free, zero vars */
code:                 return SNMP_ERR_INCONSISTENTNAME;
code:               }
code:               vp = vars;
code:   
code:               StorageNew = SNMP_MALLOC_STRUCT(${vroutine}_data);
code:   $variables{'code-varlist-copy'}{'processed'}
code:   
code:               StorageNew->$name = set_value;
code:               /* XXX: free, zero vars, no longer needed? */
code:             }
code:             
code:             break;
code:   
code:   
code:           case FREE:
code:             /* XXX: free, zero vars */
code:             /* Release any resources that have been allocated */
code:             break;
code:   
code:   
code:           case ACTION:
code:                /* The variable has been stored in set_value for you to
code:                use, and you have just been asked to do something with
code:                it.  Note that anything done here must be reversable in
code:                the UNDO case */
code:                
code:                if (StorageTmp == NULL) {
code:                  /* row creation, so add it */
code:                  if (StorageNew != NULL)
code:                    ${vroutine}_add(StorageNew);
code:                  /* XXX: ack, and if it is NULL? */
code:                } else if (set_value != RS_DESTROY) {
code:                  /* set the flag? */
code:                  old_value = StorageTmp->$name;
code:                  StorageTmp->$name = *((long *) var_val);
code:                } else {
code:                  /* destroy...  extract it for now */
code:                  hciptr =
code:                    header_complex_find_entry(${vroutine}Storage,
code:                                              StorageTmp);
code:                  StorageDel =
code:                    header_complex_extract_entry(&${vroutine}Storage,
code:                                                 hciptr);
code:                }
code:             break;
code:   
code:   
code:           case UNDO:
code:                /* Back out any changes made in the ACTION case */
code:                if (StorageTmp == NULL) {
code:                  /* row creation, so remove it again */
code:                  hciptr =
code:                    header_complex_find_entry(${vroutine}Storage,
code:                                              StorageTmp);
code:                  StorageDel =
code:                    header_complex_extract_entry(&${vroutine}Storage,
code:                                                 hciptr);
code:                  /* XXX: free it */
code:                } else if (StorageDel != NULL) {
code:                  /* row deletion, so add it again */
code:                  ${vroutine}_add(StorageDel);
code:                } else {
code:                  StorageTmp->$name = old_value;
code:                }
code:             break;
code:   
code:   
code:           case COMMIT:
code:                /* Things are working well, so it's now safe to make the change
code:                permanently.  Make sure that anything done here can't fail! */
code:             if (StorageDel != NULL) {
code:               StorageDel == 0;
code:               /* XXX: free it, its dead */
code:             }
code:             break;
code:     }
code:     return SNMP_ERR_NOERROR;
code:   }
code: