---

RMGenericControl.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 "RMGenericControl.h"

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



/* 
 * RMGenericControl_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 RMGenericControl_variables_oid[] = { 1,3,6,1,4,1,343,2,15,1,2,3,1 };


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


struct variable4 RMGenericControl_variables[] = {
/*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
#define   GENERICCONTROLNEXTINDEX  1
  { GENERICCONTROLNEXTINDEX, ASN_UNSIGNED  , RONLY , var_RMGenericControl, 1, { 1 } },
#define   GENERICCONTROLMONITORTYPE  5
  { GENERICCONTROLMONITORTYPE, ASN_INTEGER   , RWRITE, var_GenericControlTable, 3, { 2,1,2 } },
#define   GENERICMONITORUUID    6
  { GENERICMONITORUUID  , ASN_OCTET_STR , RWRITE, var_GenericControlTable, 3, { 2,1,3 } },
#define   GENERICMONITORLOCATION  7
  { GENERICMONITORLOCATION, ASN_INTEGER   , RWRITE, var_GenericControlTable, 3, { 2,1,4 } },
#define   GENERICDATACAPTUREUUID  8
  { GENERICDATACAPTUREUUID, ASN_OCTET_STR , RWRITE, var_GenericControlTable, 3, { 2,1,5 } },
#define   GENERICMONITORLIFETIME  9
  { GENERICMONITORLIFETIME, ASN_TIMETICKS , RWRITE, var_GenericControlTable, 3, { 2,1,6 } },
#define   GENERICMONITORRATE    10
  { GENERICMONITORRATE  , ASN_TIMETICKS , RWRITE, var_GenericControlTable, 3, { 2,1,7 } },
#define   GENERICMONITORMICRORATE  11
  { GENERICMONITORMICRORATE, ASN_UNSIGNED  , RWRITE, var_GenericControlTable, 3, { 2,1,8 } },
#define   GENERICTHRESHOLDCONTROLINDEX  12
  { GENERICTHRESHOLDCONTROLINDEX, ASN_UNSIGNED  , RWRITE, var_GenericControlTable, 3, { 2,1,9 } },
#define   GENERICLEAKYBUCKETCONTROLINDEX  13
  { GENERICLEAKYBUCKETCONTROLINDEX, ASN_UNSIGNED  , RWRITE, var_GenericControlTable, 3, { 2,1,10 } },
#define   GENERICCONTROLREFCOUNT  14
  { GENERICCONTROLREFCOUNT, ASN_INTEGER   , RONLY , var_GenericControlTable, 3, { 2,1,11 } },
#define   GENERICCONTROLSTATUS  15
  { GENERICCONTROLSTATUS, ASN_INTEGER   , RWRITE, var_GenericControlTable, 3, { 2,1,12 } },

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


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


  /* register ourselves with the agent to handle our mib tree */
  REGISTER_MIB("RMGenericControl", RMGenericControl_variables, variable4,
               RMGenericControl_variables_oid);


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


/*
 * var_RMGenericControl():
 *   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_RMGenericControl(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;

  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 GENERICCONTROLNEXTINDEX:
        
        ulong_ret = getNewId(GENERICCONTROL);
        return (unsigned char *) &ulong_ret;


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


/*
 * var_GenericControlTable():
 *   Handle this table separately from the scalar value case.
 *   The workings of this are basically the same as for var_RMGenericControl above.
 */
unsigned char *
var_GenericControlTable(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];

  unsigned long id;

  id = header_MyGeneric(vp,name,length,exact,var_len,write_method, GENERICCONTROL);
  if(id == 0) {

    switch(vp->magic) {


      case GENERICCONTROLMONITORTYPE:
          *write_method = write_genericControlMonitorType;
          break;

      case GENERICMONITORUUID:
          *write_method = write_genericMonitorUUID;
          break;

      case GENERICMONITORLOCATION:
          *write_method = write_genericMonitorLocation;
          break;

      case GENERICDATACAPTUREUUID:
          *write_method = write_genericDataCaptureUUID;
          break;

      case GENERICMONITORLIFETIME:
          *write_method = write_genericMonitorLifeTime;
          break;

      case GENERICMONITORRATE:
          *write_method = write_genericMonitorRate;
          break;

      case GENERICMONITORMICRORATE:
          *write_method = write_genericMonitorMicroRate;
          break;

      case GENERICTHRESHOLDCONTROLINDEX:
          *write_method = write_genericThresholdControlIndex;
          break;

      case GENERICLEAKYBUCKETCONTROLINDEX:
          *write_method = write_genericLeakyBucketControlIndex;
          break;

      case GENERICCONTROLSTATUS:
          *write_method = write_genericControlStatus;
          break;

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


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


    case GENERICCONTROLMONITORTYPE:
        *write_method = write_genericControlMonitorType;
        long_ret = 0;
        getInteger32(GENERICCONTROL, GENERICCONTROL_MONITORTYPE, id, &long_ret);
        return (unsigned char *) &long_ret;

    case GENERICMONITORUUID:
        *write_method = write_genericMonitorUUID;
        *string = 0;
        getUUIDString(GENERICCONTROL, GENERICCONTROL_MONITORUUID, id, string);
        *var_len = strlen(string);
        return (unsigned char *) string;

    case GENERICMONITORLOCATION:
        *write_method = write_genericMonitorLocation;
        long_ret = 0;
        getInteger32(GENERICCONTROL, GENERICCONTROL_MONITORLOCATION, id, &long_ret);
        return (unsigned char *) &long_ret;

    case GENERICDATACAPTUREUUID:
        *write_method = write_genericDataCaptureUUID;
        *string = 0;
        getUUIDString(GENERICCONTROL, GENERICCONTROL_DATACAPTURE, id, string);
        *var_len = strlen(string);
        return (unsigned char *) string;

    case GENERICMONITORLIFETIME:
        *write_method = write_genericMonitorLifeTime;
        ulong_ret = 0;
        getUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORLIFE, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICMONITORRATE:
        *write_method = write_genericMonitorRate;
        ulong_ret = 0;
        getUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORRATE, id, &ulong_ret);
        ulong_ret *= 100;
        return (unsigned char *) &ulong_ret;

    case GENERICMONITORMICRORATE:
        *write_method = write_genericMonitorMicroRate;
        ulong_ret = 0;
        getUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORMICRORATE, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICTHRESHOLDCONTROLINDEX:
        *write_method = write_genericThresholdControlIndex;
        ulong_ret = 0;
        getUnsigned(GENERICCONTROL, GENERICCONTROL_THRESHOLDID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICLEAKYBUCKETCONTROLINDEX:
        *write_method = write_genericLeakyBucketControlIndex;
        ulong_ret = 0;
        getUnsigned(GENERICCONTROL, GENERICCONTROL_LEAKYBUCKETID, id, &ulong_ret);
        return (unsigned char *) &ulong_ret;

    case GENERICCONTROLREFCOUNT:
        
        long_ret = 0;
        getInteger32(GENERICCONTROL, GENERICCONTROL_REFCOUNT, id, &long_ret);
        return (unsigned char *) &long_ret;

    case GENERICCONTROLSTATUS:
        *write_method = write_genericControlStatus;
        long_ret = 0;
        getInteger32(GENERICCONTROL, GENERICCONTROL_STATUS, id, &long_ret);
        return (unsigned char *) &long_ret;


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




int
write_genericControlMonitorType(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, 2 };
  createNew = 0;
  prefix_len = sizeof(RMGenericControl_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &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 genericControlMonitorType not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(long_ret)){
              fprintf(stderr,"write to genericControlMonitorType: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


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

          if(!createNew) {
            ret = getInteger32(GENERICCONTROL, GENERICCONTROL_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(GENERICCONTROL, GENERICCONTROL_MONITORTYPE, id, *long_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setInteger32(GENERICCONTROL, GENERICCONTROL_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_genericMonitorUUID(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 char string[SPRINT_MAX_LEN];
  int size;

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

  static char oldVal[37];

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

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &createNew);

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


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


        case RESERVE2:
          size = var_val_len;
          // string = (char *) var_val;
          strncpy(string, (char *) var_val, size);

          if(!createNew) {
            ret = getUUIDString(GENERICCONTROL, GENERICCONTROL_MONITORUUID, 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 string 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 = setUUIDString(GENERICCONTROL, GENERICCONTROL_MONITORUUID, id, string);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUUIDString(GENERICCONTROL, GENERICCONTROL_MONITORUUID, 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_genericMonitorLocation(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, 4 };
  createNew = 0;
  prefix_len = sizeof(RMGenericControl_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &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 genericMonitorLocation not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(long_ret)){
              fprintf(stderr,"write to genericMonitorLocation: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


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

          if(!createNew) {
            ret = getInteger32(GENERICCONTROL, GENERICCONTROL_MONITORLOCATION, 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(GENERICCONTROL, GENERICCONTROL_MONITORLOCATION, id, *long_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setInteger32(GENERICCONTROL, GENERICCONTROL_MONITORLOCATION, 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_genericDataCaptureUUID(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 char string[SPRINT_MAX_LEN];
  int size;

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

  static char oldVal[37];

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

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &createNew);

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


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


        case RESERVE2:
          size = var_val_len;
          // string = (char *) var_val;
          strncpy(string, (char *) var_val, size);

          if(!createNew) {
            ret = getUUIDString(GENERICCONTROL, GENERICCONTROL_DATACAPTURE, 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 string 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 = setUUIDString(GENERICCONTROL, GENERICCONTROL_DATACAPTURE, id, string);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUUIDString(GENERICCONTROL, GENERICCONTROL_DATACAPTURE, 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_genericMonitorLifeTime(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 unsigned long oldVal;

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

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &createNew);

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


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


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

          if(!createNew) {
            ret = getUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORLIFE, 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 = setUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORLIFE, id, (unsigned long) *long_ret / 100);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORLIFE, 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_genericMonitorRate(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 unsigned long oldVal;

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

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &createNew);

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


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


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

          if(!createNew) {
            ret = getUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORRATE, 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 = setUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORRATE, id, ((unsigned long) *long_ret / 100));
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORRATE, 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_genericMonitorMicroRate(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(RMGenericControl_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &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 genericMonitorMicroRate not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericMonitorMicroRate: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


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

          if(!createNew) {
            ret = getUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORMICRORATE, 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(GENERICCONTROL, GENERICCONTROL_MONITORMICRORATE, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONTROL, GENERICCONTROL_MONITORMICRORATE, 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_genericThresholdControlIndex(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(RMGenericControl_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &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 genericThresholdControlIndex not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericThresholdControlIndex: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


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

          if(!createNew) {
            ret = getUnsigned(GENERICCONTROL, GENERICCONTROL_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(GENERICCONTROL, GENERICCONTROL_THRESHOLDID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONTROL, GENERICCONTROL_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_genericLeakyBucketControlIndex(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, 10 };
  createNew = 0;
  prefix_len = sizeof(RMGenericControl_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &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 genericLeakyBucketControlIndex not ASN_UNSIGNED\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong_ret)){
              fprintf(stderr,"write to genericLeakyBucketControlIndex: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


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

          if(!createNew) {
            ret = getUnsigned(GENERICCONTROL, GENERICCONTROL_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(GENERICCONTROL, GENERICCONTROL_LEAKYBUCKETID, id, *ulong_ret);
          if(ret)
            return SNMP_ERR_INCONSISTENTVALUE;

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          setUnsigned(GENERICCONTROL, GENERICCONTROL_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_genericControlStatus(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, 12 };
  createNew = 0;
  prefix_len = sizeof(RMGenericControl_variables_oid)/sizeof(oid);

  id = header_writeGeneric(name, name_len, RMGenericControl_variables_oid, prefix_len, suffix, 3, GENERICCONTROL, &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 genericControlStatus not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(long_ret)){
              fprintf(stderr,"write to genericControlStatus: 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(GENERICCONTROL, GENERICCONTROL_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(GENERICCONTROL, id);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;

            rowCreated = 1;
          }
          else if (*long_ret == NOTINSERVICE || *long_ret == ACTIVE) {
            ret = setInteger32(GENERICCONTROL, GENERICCONTROL_STATUS, id, *long_ret);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }
          else if(*long_ret == DESTROY) {
            ret = deleteEntry(GENERICCONTROL, id);
            if(ret)
              return SNMP_ERR_INCONSISTENTVALUE;
          }

          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          if(rowCreated) {
            deleteEntry(GENERICCONTROL, id);
          }
          else if(*long_ret == NOTINSERVICE || *long_ret == ACTIVE) {
            if(oldStatus != 0)
              setInteger32(GENERICCONTROL, GENERICCONTROL_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(GENERICCONTROL, GENERICCONTROL_STATUS, id, ACTIVE);
            if(ret) {
              deleteEntry(GENERICCONTROL, id);
              return SNMP_ERR_COMMITFAILED;
            }
          }

          break;
  }
  return SNMP_ERR_NOERROR;
}

---