snmptargetparamsentry.c

ucd-snmp源代码

	  return SNMP_ERR_WRONGVALUE;
      }
  } else if (action == RESERVE2) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                   SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params == NULL) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecLevel: BAD OID\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  /*  Row exists, check if it is changeable.  */
	  if (params->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetParamsEntry",
		       "write to snmpTargetParamSecLevel: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  /*  Check if row is active.  */
	  if (params->rowStatus == SNMP_ROW_ACTIVE) {
	      DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsSecLevel: this change not allowed in active row.\n"));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  old_level = params->secLevel;
	  params->secLevel = long_ret;
	  
	  if (params->rowStatus == SNMP_ROW_NOTREADY &&
	      snmpTargetParams_rowStatusCheck(params)) {
	      params->rowStatus = SNMP_ROW_NOTINSERVICE;
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                   SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  update_timestamp(params);
      }
  } else if (action == FREE || action == UNDO) {
      /*  Try to undo the SET here (abnormal usage of FREE clause)  */
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                   SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  if (params->storageType != SNMP_STORAGE_READONLY &&
	      params->rowStatus   != SNMP_ROW_ACTIVE) {
	      params->secLevel = old_level;
	      if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  !snmpTargetParams_rowStatusCheck(params)) {
		  params->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  } 

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetParamsSecLevel */

/*  Assign a value to the storageType variable.  */
int
write_snmpTargetParamsStorageType(
   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)
{
  long long_ret = *((long *)var_val);
  static long old_st;
  struct targetParamTable_struct *params = NULL;

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		   "write to snmpTargetParamsStorageType: not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsStorageType: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (long_ret != SNMP_STORAGE_OTHER && 
	  long_ret != SNMP_STORAGE_VOLATILE &&
	  long_ret != SNMP_STORAGE_NONVOLATILE) {
	  DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsStorageType: attempted storage type not a valid"));
	  DEBUGMSG(("snmpTargetParamsEntry", " value of other(%d), volatile(%d), or nonvolatile(%d)\n",
		    SNMP_STORAGE_OTHER, 
		    SNMP_STORAGE_VOLATILE, 
		    SNMP_STORAGE_NONVOLATILE));
	  return SNMP_ERR_WRONGVALUE;
      }
  } else if (action == RESERVE2) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                     SNMPTARGETPARAMSSTORAGETYPECOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params == NULL) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsStorageType: BAD OID\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  /*  Row exists, check if it is changeable.  */
	  if (params->storageType == SNMP_STORAGE_READONLY ||
	      params->storageType == SNMP_STORAGE_PERMANENT) {
	      DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsStorageType: row has unchangeable storage status: %d\n",
			  params->storageType));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  old_st = params->storageType;
	  params->storageType = long_ret;
      }
  } else if (action == FREE || action == UNDO) {
      /*  Try to undo the SET here (abnormal usage of FREE clause)  */
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                     SNMPTARGETPARAMSSTORAGETYPECOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  if (params->storageType != SNMP_STORAGE_READONLY &&
	      params->storageType != SNMP_STORAGE_PERMANENT) {
	      params->storageType = old_st;
	  }
      }
  } 

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetParamsStorageType */

/*  Assign a value to the secName variable.  */
int
write_snmpTargetParamsSecName(
   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 char *old_name;
  struct targetParamTable_struct *params = NULL;

  if (action == RESERVE1) {
      if (var_val_type !=ASN_OCTET_STR) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		     "write to snmpTargetParamsSecName: not ASN_OCTET_STR\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len > 255 || var_val_len < 0) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecName: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
  } else if (action == RESERVE2) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                    SNMPTARGETPARAMSSECURITYNAMECOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params == NULL) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecName: BAD OID\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  /*  Row exists, check if it is changeable.  */
	  if (params->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetParamsEntry",
		       "write to snmpTargetParamSecName: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  /*  Check if row is active.  */
	  if (params->rowStatus == SNMP_ROW_ACTIVE) {
	      DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsSecName: this change not allowed in active row.\n"));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  old_name = params->secName;
	  params->secName = (char *)malloc(var_val_len + 1);
	  if (params->secName == NULL) {
	      return SNMP_ERR_RESOURCEUNAVAILABLE;
	  }
	  memcpy(params->secName, var_val, var_val_len);
	  params->secName[var_val_len] = '\0';
	  
	  if (params->rowStatus == SNMP_ROW_NOTREADY &&
	      snmpTargetParams_rowStatusCheck(params)) {
	      params->rowStatus = SNMP_ROW_NOTINSERVICE;
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                    SNMPTARGETPARAMSSECURITYNAMECOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  update_timestamp(params);
	  SNMP_FREE(old_name);
	  old_name = NULL;
      }
  } else if (action == FREE || action == UNDO) {
      /*  Try to undo the SET here (abnormal usage of FREE clause)  */
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                    SNMPTARGETPARAMSSECURITYNAMECOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  if (params->storageType != SNMP_STORAGE_READONLY &&
	      params->rowStatus   != SNMP_ROW_ACTIVE) {
	      SNMP_FREE(params->secName);
	      params->secName = old_name;
	      if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  !snmpTargetParams_rowStatusCheck(params)) {
		  params->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  } 

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetParamsSecName */

/* snmpTargeParams_createNewRow is called from write_snmpTargetParamsRowStatus
   when a new row is required. It creates a new row with 
   the index of the passed in 'name' (i.e. full index OID) and
   adds it to the linked list. 'name' should be the full OID of the new index. 
   It passes back 0 if unsuccessfull.*/
int snmpTargetParams_createNewRow(
     oid  *name,
     size_t name_len)
{
  int    pNameLen, i;
  struct targetParamTable_struct *temp_struct;

  /* setup a new snmpTargetParamTable structure and add it to the list */
  pNameLen = name_len - snmpTargetParamsOIDLen;
  if (pNameLen > 0) {
    temp_struct            = snmpTargetParamTable_create();
    temp_struct->paramName = (char *)malloc(pNameLen + 1);

    for (i = 0; i < pNameLen; i++) {
      temp_struct->paramName[i] = (char)name[i+snmpTargetParamsOIDLen];
    }

    temp_struct->paramName[pNameLen]  = '\0';
    temp_struct->rowStatus            = SNMP_ROW_NOTREADY;
    
    update_timestamp(temp_struct);
    snmpTargetParamTable_addToList(temp_struct, &aPTable);

    return 1;
  }

  return 0;
}  /* snmpTargetParams_createNewRow */
	
/* Assign a value to the Row Status variable */
int
write_snmpTargetParamsRowStatus(
   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 value;
  struct targetParamTable_struct *params = NULL;
  
  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsRowStatus not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsRowStatus: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      value = *((long *)var_val);
      if (value == SNMP_ROW_NOTREADY || value < 1 || value > 6) {
	  return SNMP_ERR_WRONGVALUE;
      }
      
      /*  Check index value is reasonable.  */

      if (name_len < snmpTargetParamsOIDLen + 1 ||
	  name_len > snmpTargetParamsOIDLen + 32) {
	  DEBUGMSGTL(("snmpTargetParamsEntry", "bad index length %d\n",
		      name_len - snmpTargetParamsOIDLen));
	  return SNMP_ERR_NOCREATION;
      }

      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                       SNMPTARGETPARAMSROWSTATUSCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID,
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params != NULL) {
	  if (value == SNMP_ROW_CREATEANDGO||value == SNMP_ROW_CREATEANDWAIT) {
	      value = SNMP_ROW_NOTREADY;
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }
	  if (params->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetParamsEntry", "row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  if (params->storageType == SNMP_STORAGE_PERMANENT) {
	      if (value == SNMP_ROW_DESTROY) {
		  DEBUGMSGTL(("snmpTargetParamsEntry",
			      "unable to destroy permanent row\n"));
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  }
      } else {
	  if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }
	  if (value == SNMP_ROW_CREATEANDGO||value == SNMP_ROW_CREATEANDWAIT) {
	      if (snmpTargetParams_createNewRow(name, name_len) == 0) {
		  DEBUGMSGTL(("snmpTargetParamsEntry",
			      "couldn't malloc() new row\n"));
		  return SNMP_ERR_RESOURCEUNAVAILABLE;
	      }
	  }
      }
  } else if (action == ACTION) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                       SNMPTARGETPARAMSROWSTATUSCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID,
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params != NULL) {
	  if (value == SNMP_ROW_CREATEANDGO) {
	      /*  Check whether all the required objects have been set.  */
	      if (snmpTargetParams_rowStatusCheck(params)) {
		  params->rowStatus = SNMP_ROW_ACTIVE;
	      } else {
		  params->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  } else if (value == SNMP_ROW_CREATEANDWAIT) {
	      /*  Check whether all the required objects have been set.  */
	      if (snmpTargetParams_rowStatusCheck(params)) {
		  params->rowStatus = SNMP_ROW_NOTINSERVICE;
	      } else {
		  params->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  } else if (value == SNMP_ROW_ACTIVE) {
	      if (params->rowStatus == SNMP_ROW_NOTINSERVICE) {
		  params->rowStatus = SNMP_ROW_ACTIVE;
	      } else if (params->rowStatus == SNMP_ROW_NOTREADY) {
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  } else if (value == SNMP_ROW_NOTINSERVICE) {
	      if (params->rowStatus == SNMP_ROW_ACTIVE) {
		  params->rowStatus = SNMP_ROW_NOTINSERVICE;
	      } else if (params->rowStatus == SNMP_ROW_NOTREADY) {
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                       SNMPTARGETPARAMSROWSTATUSCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID,
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params != NULL) {
	  if (value == SNMP_ROW_DESTROY) {
	      snmpTargetParamTable_remFromList(params, &aPTable);
	  }
	  if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
	      update_timestamp(params);
	  }
      }
  } else if (action == UNDO || action == FREE) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                       SNMPTARGETPARAMSROWSTATUSCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID,
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (value == SNMP_ROW_CREATEANDGO || value == SNMP_ROW_CREATEANDWAIT) {
	  if (params != NULL) {
	      snmpTargetParamTable_remFromList(params, &aPTable);
	  }
      }
  }
  return SNMP_ERR_NOERROR;
}

struct targetParamTable_struct *get_paramEntry(char *name) {
    static struct targetParamTable_struct *ptr;
    for(ptr = aPTable; ptr; ptr = ptr->next) {
        if (strcmp(ptr->paramName, name) == 0) {
            return ptr;
        }
    }
    return NULL;
}