---

RMGenericConfig.c

Go to the documentation of this file.

/* This file was generated by mib2c and is intended for use as a mib module
   for the ucd-snmp snmpd agent. */

#include <netinet/in.h>

#ifdef IN_UCD_SNMP_SOURCE
/* If we're compiling this file inside the ucd-snmp source tree */


/* This should always be included first before anything else */
#include <config.h>


/* minimal include directives */
#include "mibincl.h"
#include "util_funcs.h"


#else /* !IN_UCD_SNMP_SOURCE */


#include <ucd-snmp/ucd-snmp-config.h>
#include <ucd-snmp/ucd-snmp-includes.h>
#include <ucd-snmp/ucd-snmp-agent-includes.h>


#endif /* !IN_UCD_SNMP_SOURCE */


#include "RMGenericConfig.h"

#include <string.h>
#include <ucd-snmp/util_funcs.h>
#include "rmClient.h"
#include "utility.h"


/* 
 * RMGenericConfig_variables_oid:
 *   this is the top level oid that we want to register under.  This
 *   is essentially a prefix, with the suffix appearing in the
 *   variable below.
 */


oid RMGenericConfig_variables_oid[] = { 1,3,6,1,4,1,343,2,15,1,2,2,1 };


/* 
 * variable4 RMGenericConfig_variables:
 *   this variable defines function callbacks and type return information 
 *   for the RMGenericConfig mib section 
 */


struct variable4 RMGenericConfig_variables[] = {
/*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
#define   GENERICCONFIGNEXTINDEX  1
  { GENERICCONFIGNEXTINDEX, ASN_UNSIGNED  , RONLY , var_RMGenericConfig, 1, { 1 } },
#define   GENERICSUBSYSTEMID    5
  { GENERICSUBSYSTEMID  , ASN_UNSIGNED  , RWRITE, var_GenericConfigTable, 3, { 2,1,2 } },
#define   GENERICRESOURCEID     6
  { GENERICRESOURCEID   , ASN_UNSIGNED  , RWRITE, var_GenericConfigTable, 3, { 2,1,3 } },
#define   GENERICSTATISTICID    7
  { GENERICSTATISTICID  , ASN_UNSIGNED  , RWRITE, var_GenericConfigTable, 3, { 2,1,4 } },
#define   GENERICCONFIGMONITORTYPE  8
  { GENERICCONFIGMONITORTYPE, ASN_INTEGER   , RWRITE, var_GenericConfigTable, 3, { 2,1,5 } },
#define   GENERICSTATISTICTRANSFORM  9
  { GENERICSTATISTICTRANSFORM , ASN_INTEGER   , RWRITE, var_GenericConfigTable, 3, { 2,1,6 } },
#define   GENERICTHRESHOLDCONFIGINDEX  10 
  { GENERICTHRESHOLDCONFIGINDEX, ASN_UNSIGNED  , RWRITE, var_GenericConfigTable, 3, { 2,1,7 } },
#define   GENERICWATERMARKCONFIGINDEX  11
  { GENERICWATERMARKCONFIGINDEX, ASN_UNSIGNED  , RWRITE, var_GenericConfigTable, 3, { 2,1,8 } },
#define   GENERICLEAKYBUCKETCONFIGINDEX  12
  { GENERICLEAKYBUCKETCONFIGINDEX, ASN_UNSIGNED  , RWRITE, var_GenericConfigTable, 3, { 2,1,9 } },
#define   GENERICCONFIGREFCOUNT  13
  { GENERICCONFIGREFCOUNT, ASN_INTEGER   , RONLY , var_GenericConfigTable, 3, { 2,1,10 } },
#define   GENERICCONFIGSTATUS   14
  { GENERICCONFIGSTATUS , ASN_INTEGER   , RWRITE, var_GenericConfigTable, 3, { 2,1,11 } },

};
/*    (L = length of the oidsuffix) */


/*
 * init_RMGenericConfig():
 *   Initialization routine.  This is called when the agent starts up.
 *   At a minimum, registration of your variables should take place here.
 */
void init_RMGenericConfig(void) {


  /* register ourselves with the agent to handle our mib tree */
  REGISTER_MIB("RMGenericConfig", RMGenericConfig_variables, variable4,
               RMGenericConfig_variables_oid);


  /* place any other initialization junk you need here */
}


/*
 * var_RMGenericConfig():
 *   This function is called every time the agent gets a request for
 *   a scalar variable that might be found within your mib section
 *   registered above.  It is up to you to do the right thing and
 *   return the correct value.
 *     You should also correct the value of "var_len" if necessary.
 *
 *   Please see the documentation for more information about writing
 *   module extensions, and check out the examples in the examples
 *   and mibII directories.
 */
unsigned char *
var_RMGenericConfig(struct variable *vp, 
                oid     *name, 
                size_t  *length, 
                int     exact, 
                size_t  *var_len, 
                WriteMethod **write_method)
{


  /* variables we may use later */
  static u_long ulong_ret;
  /*
  static long long_ret;
  static unsigned char string[SPRINT_MAX_LEN];
  static oid objid[MAX_OID_LEN];
  static struct counter64 c64;
  */


  if (header_generic(vp,name,length,exact,var_len,write_method)
                                  == MATCH_FAILED )
    return NULL;


  /* 
   * this is where we do the value assignments for the mib results.
   */
  switch(vp->magic) {


    case GENERICCONFIGNEXTINDEX:
        
        ulong_ret = getNewId(GENERICCONFIG);
        return (unsigned char *) &ulong_ret;


    default:
      ERROR_MSG("");
  }
  return NULL;
}


/*
 * var_GenericConfigTable():
 *   Handle this table separately from the scalar value case.
 *   The workings of this are basically the same as for var_RMGenericConfig above.
 */
unsigned char *
var_GenericConfigTable(struct variable *vp,
            oid     *name,
            size_t  *length,
            int     exact,
            size_t  *var_len,
            WriteMethod **write_method)
{


  /* variables we may use later */
  static long long_ret;
  static u_long ulong_ret;
  /*
  static unsigned char string[SPRINT_MAX_LEN];
  static oid objid[MAX_OID_LEN];
  static struct counter64 c64;
  */

  unsigned long id;

  id = header_MyGeneric(vp,name,length,exact,var_len,write_method, GENERICCONFIG);
  if(id == 0) {
    switch(vp->magic) {

      case GENERICSUBSYSTEMID:
          *write_method = write_genericSubsystemID;
          break;

      case GENERICRESOURCEID:
          *write_method = write_genericResourceID;
          break;

      case GENERICSTATISTICID:
          *write_method = write_genericStatisticID;
          break;

      case GENERICCONFIGMONITORTYPE:
          *write_method = write_genericConfigMonitorType;
          break;

      case GENERICSTATISTICTRANSFORM:
          *write_method = write_genericStatisticTransform;
          break;

      case GENERICTHRESHOLDCONFIGINDEX:
          *write_method = write_genericThresholdConfigIndex;
          break;

      case GENERICWATERMARKCONFIGINDEX:
          *write_method = write_genericWatermarkConfigIndex;
          break;

      case GENERICLEAKYBUCKETCONFIGINDEX:
          *write_method = write_genericLeakyBucketConfigIndex;
          break;

      case GENERICCONFIGSTATUS:
          *write_method = write_genericConfigStatus;
          break;

      default:
        ERROR_MSG("");
    }
    return NULL;
  }

  /* 
   * this is where we do the value assignments for the mib results.
   */
  switch(vp->magic) {


    case GENERICSUBSYSTEMID:
        *write_method = write_genericSubsystemID;
        ulong_ret = 0;
        getUnsigned(GENERICCONFIG, GENERICCONFIG_SUBSYSTEMID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICRESOURCEID:
        *write_method = write_genericResourceID;
        ulong_ret = 0;
        getUnsigned(GENERICCONFIG, GENERICCONFIG_RESOURCEID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICSTATISTICID:
        *write_method = write_genericStatisticID;
        ulong_ret = 0;
        getUnsigned(GENERICCONFIG, GENERICCONFIG_STATISTICID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICCONFIGMONITORTYPE:
        *write_method = write_genericConfigMonitorType;
        long_ret = 0;
        getInteger32(GENERICCONFIG, GENERICCONFIG_MONITORTYPE, id, &long_ret);
        return (unsigned char *) &long_ret;

    case GENERICSTATISTICTRANSFORM:
        *write_method = write_genericStatisticTransform;
        long_ret = 0;
        getInteger32(GENERICCONFIG, GENERICCONFIG_STATISTICTRANSFORM, id, &long_ret);
        return (unsigned char *) &long_ret;

    case GENERICTHRESHOLDCONFIGINDEX:
        *write_method = write_genericThresholdConfigIndex;
        ulong_ret = 0;
        getUnsigned(GENERICCONFIG, GENERICCONFIG_THRESHOLDID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICWATERMARKCONFIGINDEX:
        *write_method = write_genericWatermarkConfigIndex;
        ulong_ret = 0;
        getUnsigned(GENERICCONFIG, GENERICCONFIG_WATERMARKID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICLEAKYBUCKETCONFIGINDEX:
        *write_method = write_genericLeakyBucketConfigIndex;
        ulong_ret = 0;
        getUnsigned(GENERICCONFIG, GENERICCONFIG_LEAKYBUCKETID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICCONFIGREFCOUNT:
        
        long_ret = 0;
        getInteger32(GENERICCONFIG, GENERICCONFIG_REFCOUNT, id, &long_ret);
        return (unsigned char *) &long_ret;

    case GENERICCONFIGSTATUS:
        *write_method = write_genericConfigStatus;
        long_ret = 0;
        getInteger32(GENERICCONFIG, GENERICCONFIG_STATUS, id, &long_ret);
        return (unsigned char *) &long_ret;


    default:
      ERROR_MSG("");
  }
  return NULL;
}




int
write_genericSubsystemID(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned long *ulong_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static unsigned long oldVal;

  oid suffix[] = { 2, 1, 2 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;

  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_UNSIGNED){
              fprintf(stderr, "write to genericSubsystemID not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericSubsystemID: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          ulong_ret = (unsigned long *) var_val;

          if(!createNew) {
            ret = getUnsigned(GENERICCONFIG,  GENERICCONFIG_SUBSYSTEMID, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }

          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in ulong_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setUnsigned(GENERICCONFIG,  GENERICCONFIG_SUBSYSTEMID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;
 
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONFIG,  GENERICCONFIG_SUBSYSTEMID, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_genericResourceID(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned long *ulong_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static unsigned long oldVal;

  oid suffix[] = { 2, 1, 3 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_UNSIGNED){
              fprintf(stderr, "write to genericResourceID not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericResourceID: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          ulong_ret = (unsigned long *) var_val;

          if(!createNew) {
            ret = getUnsigned(GENERICCONFIG,  GENERICCONFIG_RESOURCEID, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }


          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in ulong_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setUnsigned(GENERICCONFIG,  GENERICCONFIG_RESOURCEID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONFIG,  GENERICCONFIG_RESOURCEID, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_genericStatisticID(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned long *ulong_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static unsigned long oldVal;

  oid suffix[] = { 2, 1, 4 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_UNSIGNED){
              fprintf(stderr, "write to genericStatisticID not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericStatisticID: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          ulong_ret = (unsigned long *) var_val;

          if(!createNew) {
            ret = getUnsigned(GENERICCONFIG,  GENERICCONFIG_STATISTICID, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }


          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in ulong_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setUnsigned(GENERICCONFIG,  GENERICCONFIG_STATISTICID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */

          setUnsigned(GENERICCONFIG,  GENERICCONFIG_STATISTICID, id, oldVal);

          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_genericConfigMonitorType(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static long *long_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static long oldVal;

  oid suffix[] = { 2, 1, 5 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_INTEGER){
              fprintf(stderr, "write to genericConfigMonitorType not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(long_ret)){
              fprintf(stderr,"write to genericConfigMonitorType: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          long_ret = (long *) var_val;

          if(!createNew) {
            ret = getInteger32(GENERICCONFIG,  GENERICCONFIG_MONITORTYPE, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }

          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in long_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setInteger32(GENERICCONFIG,  GENERICCONFIG_MONITORTYPE, id, *long_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setInteger32(GENERICCONFIG,  GENERICCONFIG_MONITORTYPE, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}


int
write_genericStatisticTransform(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static long *long_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static long oldVal;

  oid suffix[] = { 2, 1, 6 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_INTEGER){
              fprintf(stderr, "write to genericConfigMonitorType not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(long_ret)){
              fprintf(stderr,"write to genericConfigMonitorType: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          long_ret = (long *) var_val;

          if(!createNew) {
            ret = getInteger32(GENERICCONFIG,  GENERICCONFIG_STATISTICTRANSFORM, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }

          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in long_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setInteger32(GENERICCONFIG,  GENERICCONFIG_STATISTICTRANSFORM, id, *long_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setInteger32(GENERICCONFIG,  GENERICCONFIG_STATISTICTRANSFORM, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}

int
write_genericThresholdConfigIndex(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned long *ulong_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static unsigned long oldVal;

  oid suffix[] = { 2, 1, 7 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_UNSIGNED){
              fprintf(stderr, "write to genericThresholdConfigIndex not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericThresholdConfigIndex: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          ulong_ret = (unsigned long *) var_val;

          if(!createNew) {
            ret = getUnsigned(GENERICCONFIG,  GENERICCONFIG_THRESHOLDID, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }


          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in ulong_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setUnsigned(GENERICCONFIG,  GENERICCONFIG_THRESHOLDID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONFIG,  GENERICCONFIG_THRESHOLDID, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_genericWatermarkConfigIndex(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned long *ulong_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static unsigned long oldVal;

  oid suffix[] = { 2, 1, 8 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_UNSIGNED){
              fprintf(stderr, "write to genericWatermarkConfigIndex not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericWatermarkConfigIndex: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          ulong_ret = (unsigned long *) var_val;

          if(!createNew) {
            ret = getUnsigned(GENERICCONFIG,  GENERICCONFIG_WATERMARKID, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }


          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in ulong_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setUnsigned(GENERICCONFIG,  GENERICCONFIG_WATERMARKID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONFIG,  GENERICCONFIG_WATERMARKID, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_genericLeakyBucketConfigIndex(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned long *ulong_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static unsigned long oldVal;

  oid suffix[] = { 2, 1, 9 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(id == 0 || (createNew && action == ACTION))
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_UNSIGNED){
              fprintf(stderr, "write to genericLeakyBucketConfigIndex not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericLeakyBucketConfigIndex: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          ulong_ret = (unsigned long *) var_val;

          if(!createNew) {
            ret = getUnsigned(GENERICCONFIG,  GENERICCONFIG_LEAKYBUCKETID, id, &oldVal);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }


          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in ulong_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */
          ret = setUnsigned(GENERICCONFIG,  GENERICCONFIG_LEAKYBUCKETID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONFIG,  GENERICCONFIG_LEAKYBUCKETID, id, oldVal);
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_genericConfigStatus(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static long long_ret;
  int size;

  int createNew, ret;
  unsigned long id;
  size_t prefix_len;

  static long oldStatus;
  static int rowCreated;

  oid suffix[] = { 2, 1, 11 };
  createNew = 0;
  prefix_len = sizeof(RMGenericConfig_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericConfig_variables_oid, prefix_len, suffix, 3, GENERICCONFIG, &createNew);

  if(action == COMMIT && long_ret == DESTROY && id ==0)
    return SNMP_ERR_NOERROR;

  if(id == 0)
    return SNMP_ERR_NOSUCHNAME;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_INTEGER){
              fprintf(stderr, "write to genericConfigStatus not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(long_ret)){
              fprintf(stderr,"write to genericConfigStatus: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
          long_ret = (long ) *var_val;

          rowCreated = 0;
          oldStatus = 0;
          if (long_ret < ACTIVE || long_ret > DESTROY ||
               long_ret == NOTREADY)
            return SNMP_ERR_INCONSISTENTVALUE;

          if(createNew &&
              (long_ret != CREATEANDWAIT && long_ret != CREATEANDGO))
            return SNMP_ERR_INCONSISTENTVALUE;

          if (long_ret == NOTINSERVICE || long_ret == ACTIVE) {
            ret = getInteger32(GENERICCONFIG, GENERICCONFIG_STATUS, id, &oldStatus);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }


          break;


        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
             /* The variable has been stored in long_ret for
             you to use, and you have just been asked to do something with
             it.  Note that anything done here must be reversable in the UNDO case */

          if(long_ret == CREATEANDWAIT || long_ret == CREATEANDGO) {
            ret = newEntry(GENERICCONFIG, id);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;

            rowCreated = 1;
          }
          else if (long_ret == NOTINSERVICE || long_ret == ACTIVE) {
            ret = setInteger32(GENERICCONFIG, GENERICCONFIG_STATUS, id, long_ret);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }
          else if(long_ret == DESTROY) {
            ret = deleteEntry(GENERICCONFIG, id);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          if(rowCreated) {
            deleteEntry(GENERICCONFIG, id);
          }
          else if(long_ret == NOTINSERVICE || long_ret == ACTIVE) {
            if(oldStatus != 0)
              setInteger32(GENERICCONFIG, GENERICCONFIG_STATUS, id, oldStatus);
          }
          else if((long_ret == DESTROY)) {

            // note: don't know how to do this yet. need to be fixed.

          }
          break;


        case COMMIT:
             /* Things are working well, so it's now safe to make the change
             permanently.  Make sure that anything done here can't fail! */
          if(long_ret == CREATEANDGO) {
            ret = setInteger32(GENERICCONFIG, GENERICCONFIG_STATUS, id, ACTIVE);
            if(ret) {
              deleteEntry(GENERICCONFIG, id);
              return SNMP_ERR_COMMITFAILED;
            }
          }
          break;
  }
  return SNMP_ERR_NOERROR;
}

---