snmpnotifyfilterprofiletable.c

Snmp（简单网管协议）软件包。

             tmpvar = StorageTmp->snmpNotifyFilterProfileName;
             tmplen = StorageTmp->snmpNotifyFilterProfileNameLen;
             memdup((u_char **) &StorageTmp->snmpNotifyFilterProfileName, var_val, var_val_len);
             StorageTmp->snmpNotifyFilterProfileNameLen = var_val_len;
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
             SNMP_FREE(StorageTmp->snmpNotifyFilterProfileName);
             StorageTmp->snmpNotifyFilterProfileName = tmpvar;
             StorageTmp->snmpNotifyFilterProfileNameLen = tmplen;
          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! */
     SNMP_FREE(tmpvar);
          break;
  }
  return SNMP_ERR_NOERROR;
}



int
write_snmpNotifyFilterProfileStorType(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 int tmpvar;
  struct snmpNotifyFilterProfileTable_data *StorageTmp = NULL;
  size_t newlen=name_len - (sizeof(snmpNotifyFilterProfileTable_variables_oid)/sizeof(oid) + 3 - 1);


  DEBUGMSGTL(("snmpNotifyFilterProfileTable", "write_snmpNotifyFilterProfileStorType entering action=%d...  \n", action));
  if ((StorageTmp = (struct snmpNotifyFilterProfileTable_data *)
       header_complex((struct header_complex_index *)snmpNotifyFilterProfileTableStorage, NULL,
                      &name[sizeof(snmpNotifyFilterProfileTable_variables_oid)/sizeof(oid) + 3 - 1], 
                      &newlen, 1, NULL, NULL)) == NULL)
      return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_INTEGER){
              fprintf(stderr, "write to snmpNotifyFilterProfileStorType not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
          break;


        case RESERVE2:
             /* memory reseveration, final preparation... */
          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 */
             tmpvar = StorageTmp->snmpNotifyFilterProfileStorType;
             StorageTmp->snmpNotifyFilterProfileStorType = *((long *) var_val);
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
             StorageTmp->snmpNotifyFilterProfileStorType = tmpvar;
          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_snmpNotifyFilterProfileRowStatus(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)
{
  struct snmpNotifyFilterProfileTable_data *StorageTmp = NULL;
  static struct snmpNotifyFilterProfileTable_data *StorageNew, *StorageDel;
  size_t newlen=name_len - (sizeof(snmpNotifyFilterProfileTable_variables_oid)/sizeof(oid) + 3 - 1);
  static int old_value;
  int set_value;
  struct variable_list *vars;
  struct header_complex_index *hciptr;


  StorageTmp = (struct snmpNotifyFilterProfileTable_data *)
    header_complex((struct header_complex_index *)snmpNotifyFilterProfileTableStorage, NULL,
                   &name[sizeof(snmpNotifyFilterProfileTable_variables_oid)/sizeof(oid) + 3 - 1], 
                   &newlen, 1, NULL, NULL);
  

  

  if (var_val_type != ASN_INTEGER || var_val == NULL){
    fprintf(stderr, "write to snmpNotifyFilterProfileRowStatus not ASN_INTEGER\n");
    return SNMP_ERR_WRONGTYPE;
  }
  set_value = *((long *) var_val);


  /* check legal range, and notReady is reserved for us, not a user */
  if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
    return SNMP_ERR_INCONSISTENTVALUE;
    

  switch ( action ) {
        case RESERVE1:
  /* stage one: test validity */
          if (StorageTmp == NULL) {
            /* create the row now? */


            /* ditch illegal values now */
            if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
              return SNMP_ERR_INCONSISTENTVALUE;
    
          } else {
            /* row exists.  Check for a valid state change */
            if (set_value == RS_CREATEANDGO || set_value == RS_CREATEANDWAIT) {
              /* can't create a row that exists */
              return SNMP_ERR_INCONSISTENTVALUE;
            }
    /* XXX: interaction with row storage type needed */
          }
          break;




        case RESERVE2:
          /* memory reseveration, final preparation... */
          if (StorageTmp == NULL &&
              (set_value == RS_CREATEANDGO || set_value == RS_CREATEANDWAIT)) {
            /* creation */
            vars = NULL;

            snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, NULL, 0);

            if (header_complex_parse_oid(&(name[sizeof(snmpNotifyFilterProfileTable_variables_oid)/sizeof(oid)+2]), newlen, vars) != SNMPERR_SUCCESS) {
              snmp_free_var(vars);
              return SNMP_ERR_INCONSISTENTNAME;
            }

            StorageNew =
                SNMP_MALLOC_STRUCT(snmpNotifyFilterProfileTable_data);
            memdup((u_char **) &(StorageNew->snmpTargetParamsName), 
                   vars->val.string,
                   vars->val_len);
            StorageNew->snmpTargetParamsNameLen = vars->val_len;
            StorageNew->snmpNotifyFilterProfileStorType = ST_NONVOLATILE;

            StorageNew->snmpNotifyFilterProfileRowStatus = set_value;
            snmp_free_var(vars);
          }
          

          break;




        case FREE:
          /* XXX: free, zero vars */
          /* Release any resources that have been allocated */
          break;




        case ACTION:
             /* The variable has been stored in set_value 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 (StorageTmp == NULL&&
                 (set_value == RS_CREATEANDGO ||
                  set_value == RS_CREATEANDWAIT)) {
               /* row creation, so add it */
               if (StorageNew != NULL)
                 snmpNotifyFilterProfileTable_add(StorageNew);
               /* XXX: ack, and if it is NULL? */
             } else if (set_value != RS_DESTROY) {
               /* set the flag? */
               old_value = StorageTmp->snmpNotifyFilterProfileRowStatus;
               StorageTmp->snmpNotifyFilterProfileRowStatus = *((long *) var_val);
             } else {
                 /* destroy...  extract it for now */
                 if (StorageTmp) {
                     hciptr =
                         header_complex_find_entry(snmpNotifyFilterProfileTableStorage,
                                                   StorageTmp);
                     StorageDel = (struct snmpNotifyFilterProfileTable_data *)
                         header_complex_extract_entry((struct header_complex_index **)&snmpNotifyFilterProfileTableStorage,
                                                      hciptr);
                 }
                 
             }
          break;




        case UNDO:
             /* Back out any changes made in the ACTION case */
             if (StorageTmp == NULL &&
                 (set_value == RS_CREATEANDGO ||
                  set_value == RS_CREATEANDWAIT)) {
               /* row creation, so remove it again */
               hciptr =
                 header_complex_find_entry(snmpNotifyFilterProfileTableStorage,
                                           StorageNew);
               StorageDel = (struct snmpNotifyFilterProfileTable_data *)
                 header_complex_extract_entry((struct header_complex_index **)&snmpNotifyFilterProfileTableStorage,
                                              hciptr);
               /* XXX: free it */
             } else if (StorageDel != NULL) {
               /* row deletion, so add it again */
               snmpNotifyFilterProfileTable_add(StorageDel);
               StorageDel = NULL;
             } else if (set_value != RS_DESTROY) {
               StorageTmp->snmpNotifyFilterProfileRowStatus = old_value;
             }
          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 (StorageDel != NULL) {
            StorageDel = NULL;
            /* XXX: free it, its dead */
          }
          if (StorageTmp && StorageTmp->snmpNotifyFilterProfileRowStatus == RS_CREATEANDGO) {
              StorageTmp->snmpNotifyFilterProfileRowStatus = RS_ACTIVE;
          } else if (StorageTmp &&
                     StorageTmp->snmpNotifyFilterProfileRowStatus == RS_CREATEANDWAIT) {
              StorageTmp->snmpNotifyFilterProfileRowStatus = RS_NOTINSERVICE;
          }
          break;
  }
  return SNMP_ERR_NOERROR;
}



char *
get_FilterName(char *targetName, size_t targetName_len,
               size_t *profileName_len) {
    struct variable_list *vars = NULL;
    struct snmpNotifyFilterProfileTable_data *data;
    
    /* put requested info into var structure */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR,
                              (u_char *) targetName,
                              targetName_len);

    /* get the data from the header_complex storage */
    data = (struct snmpNotifyFilterProfileTable_data *)
        header_complex_get(snmpNotifyFilterProfileTableStorage, vars);
    
    /* free search index */
    snmp_free_var(vars);

    /* return the requested information (if this row is active) */
    if (data && data->snmpNotifyFilterProfileRowStatus == RS_ACTIVE) {
        *profileName_len = data->snmpNotifyFilterProfileNameLen;
        return data->snmpNotifyFilterProfileName;
    }
        
    *profileName_len = 0;
    return NULL;
}