snmptargetparamsentry.c

ucd-snmp源代码

  return(1);
}  /* snmpTargetParams_addRowStatus  */
    
/* timestamp the current entry's modification time */
void
update_timestamp(struct targetParamTable_struct *temp_struct) {
    temp_struct->updateTime = time(NULL);
}

void snmpd_parse_config_targetParams(
     const char *token, char *char_ptr)
{
  char *cptr = char_ptr, buff[1024];
  struct targetParamTable_struct *newEntry;

  newEntry = snmpTargetParamTable_create();
  
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addParamName(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addMPModel(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addSecModel(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addSecName(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addSecLevel(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addStorageType(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  cptr = copy_word(cptr, buff);
  if (snmpTargetParams_addRowStatus(newEntry, buff) == 0) {
    snmpTargetParamTable_dispose(newEntry);
    return;
  }
  sprintf(buff, "snmp_parse_config_targetParams, read: %s %d %d %s %d %d %d\n",
	  newEntry->paramName, newEntry->mpModel,  newEntry->secModel, 
	  newEntry->secName,   newEntry->secLevel, newEntry->storageType,
	  newEntry->rowStatus);
  DEBUGMSGTL(("snmpTargetParamsEntry", buff));

  update_timestamp(newEntry);
  snmpTargetParamTable_addToList(newEntry, &aPTable);
} /* snmpd_parse_config_target */


/* shutdown routines */


/* store_snmpTargetParamsEntry handles the presistent storage proccess 
   for this MIB table. It writes out all the non-volatile rows 
   to permanent storage on a shutdown  */
int 
store_snmpTargetParamsEntry(int majorID, int minorID, void *serverarg,
                            void *clientarg)
{
  struct targetParamTable_struct *curr_struct;
  char line[1024];

  strcpy(line, "");
  if ( (curr_struct = aPTable) != 0) {
    while (curr_struct != 0) {
      if ( (curr_struct->storageType == SNMP_STORAGE_NONVOLATILE || 
	    curr_struct->storageType == SNMP_STORAGE_PERMANENT) 
	                        &&
	   (curr_struct->rowStatus == SNMP_ROW_ACTIVE ||
	    curr_struct->rowStatus == SNMP_ROW_NOTINSERVICE) ) {
	sprintf(&line[strlen(line)], "targetParams %s %i %i %s %i %i %i\n",
			 curr_struct->paramName, curr_struct->mpModel,
			 curr_struct->secModel,  curr_struct->secName,
			 curr_struct->secLevel,  curr_struct->storageType,
			 curr_struct->rowStatus  );

	/* store to file */
	snmpd_store_config(line);
      }
      curr_struct = curr_struct->next;
    }
  }
  return SNMPERR_SUCCESS;
}  /*  store_snmpTargetParmsEntry  */


/* MIB table access routines */


u_char *
var_snmpTargetParamsEntry(
    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 unsigned char string[1500];
  struct targetParamTable_struct *temp_struct;
  
  switch (vp->magic) {
  case SNMPTARGETPARAMSMPMODEL:
      *write_method = write_snmpTargetParamsMPModel;
      break;
  case SNMPTARGETPARAMSSECURITYMODEL:
      *write_method = write_snmpTargetParamsSecModel;
      break;
  case SNMPTARGETPARAMSSECURITYNAME:
      *write_method = write_snmpTargetParamsSecName;
      break;
  case SNMPTARGETPARAMSSECURITYLEVEL:
      *write_method = write_snmpTargetParamsSecLevel;
      break;
  case SNMPTARGETPARAMSSTORAGETYPE:
      *write_method = write_snmpTargetParamsStorageType;
      break;
  case SNMPTARGETPARAMSROWSTATUS:
      *write_method = write_snmpTargetParamsRowStatus;
      break;
  default:
      *write_method = NULL;
  }

  *var_len = sizeof(long_ret); /* assume an integer and change later if not */
  
  /* look for OID in current table */
  if ( (temp_struct = search_snmpTargetParamsTable(vp->name, vp->namelen, 
				      name, length, exact)) == 0 ) {
    return(0);
  }
  
  /* We found what we were looking for, either the next OID or the exact OID */
  /* this is where we do the value assignments for the mib results. */
  switch(vp->magic) {

    case SNMPTARGETPARAMSMPMODEL:
      /* if unset value, (i.e. new row) */
      if (temp_struct->mpModel == -1)  return(0);
      long_ret = temp_struct->mpModel;
      return (unsigned char *) &long_ret;

    case SNMPTARGETPARAMSSECURITYMODEL:
      /* if unset value, (i.e. new row) */
      if (temp_struct->secModel == -1)  return(0);
      long_ret = temp_struct->secModel;
      return (unsigned char *) &long_ret;

    case SNMPTARGETPARAMSSECURITYNAME:
      /* if unset value, (i.e. new row) */
      if (temp_struct->secName == 0)  return(0);
      /* including null character. */
      memcpy(string, temp_struct->secName, 
	     strlen(temp_struct->secName));
      string[strlen(temp_struct->secName)] = '\0';
      *var_len = strlen(temp_struct->secName);
      return (unsigned char *) string;

    case SNMPTARGETPARAMSSECURITYLEVEL:
      /* if unset value, (i.e. new row) */
      if (temp_struct->secLevel == -1)  return(0);
      long_ret = temp_struct->secLevel;
      return (unsigned char *) &long_ret;

    case SNMPTARGETPARAMSSTORAGETYPE:
      long_ret = temp_struct->storageType;
      return (unsigned char *) &long_ret;

    case SNMPTARGETPARAMSROWSTATUS:
      long_ret = temp_struct->rowStatus;
      return (unsigned char *) &long_ret;

    default:
      DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_snmpTargetParamsEntry\n", vp->magic));
  }
  return 0;
}  /* var_snmpTargetParamsEntry */

/*  Assign a value to the mpModel variable.  */
int
write_snmpTargetParamsMPModel(
   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_mp;
  struct targetParamTable_struct *params = NULL;

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsMPModel: not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsMPModel: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (long_ret < 0) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		 "write to snmpTargetParamsMPModel: MP Model out of range\n"));
	  return SNMP_ERR_INCONSISTENTVALUE;
      }
  } else if (action == RESERVE2) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                         SNMPTARGETPARAMSMPMODELCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params == NULL) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsMPModel: 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 snmpTargetParamMPModel: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  /*  Check if row is active.  */
	  if (params->rowStatus == SNMP_ROW_ACTIVE) {
	      DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsMPModel: this change not allowed in active row.\n"));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  old_mp = params->mpModel;
	  params->mpModel = long_ret;
	  
	  if (params->rowStatus == SNMP_ROW_NOTREADY &&
	      snmpTargetParams_rowStatusCheck(params)) {
	      params->rowStatus = SNMP_ROW_NOTINSERVICE;
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                         SNMPTARGETPARAMSMPMODELCOLUMN;
      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] = 
	                                         SNMPTARGETPARAMSMPMODELCOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  if (params->storageType != SNMP_STORAGE_READONLY &&
	      params->rowStatus   != SNMP_ROW_ACTIVE) {
	      params->mpModel = old_mp;
	      if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  !snmpTargetParams_rowStatusCheck(params)) {
		  params->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  } 

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetParamsMPModel */

/*  Assign a value to the secModel variable.  */
int
write_snmpTargetParamsSecModel(
   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_sec;
  struct targetParamTable_struct *params = NULL;

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecModel: not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecModel: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (long_ret <= 0) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		"write to snmpTargetParamsSecModel: secModel out of range\n"));
	  return SNMP_ERR_WRONGVALUE;
      }
      if (long_ret > 3) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		"write to snmpTargetParamsSecModel: secModel %d unsupported\n",
		      long_ret));
	  return SNMP_ERR_INCONSISTENTVALUE;
      }

  } else if (action == RESERVE2) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                   SNMPTARGETPARAMSSECURITYMODELCOLUMN;
      params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
					    snmpTargetParamsOIDLen, 
					    name, &name_len, 1);
      if (params == NULL) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecModel: 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 snmpTargetParamSecModel: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  /*  Check if row is active.  */
	  if (params->rowStatus == SNMP_ROW_ACTIVE) {
	      DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsSecModel: this change not allowed in active row.\n"));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  old_sec = params->secModel;
	  params->secModel = long_ret;
	  
	  if (params->rowStatus == SNMP_ROW_NOTREADY &&
	      snmpTargetParams_rowStatusCheck(params)) {
	      params->rowStatus = SNMP_ROW_NOTINSERVICE;
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = 
	                                   SNMPTARGETPARAMSSECURITYMODELCOLUMN;
      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] = 
	                                   SNMPTARGETPARAMSSECURITYMODELCOLUMN;
      if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID, 
						 snmpTargetParamsOIDLen, 
						 name, &name_len, 1)) != NULL){
	  if (params->storageType != SNMP_STORAGE_READONLY &&
	      params->rowStatus   != SNMP_ROW_ACTIVE) {
	      params->secModel = old_sec;
	      if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  !snmpTargetParams_rowStatusCheck(params)) {
		  params->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  } 

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetParamsSecModel */

/*  Assign a value to the SecLevel variable.  */
int
write_snmpTargetParamsSecLevel(
   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_level;
  struct targetParamTable_struct *params = NULL;

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecLevel: not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetParamsEntry",
		      "write to snmpTargetParamsSecLevel: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (long_ret <= 0 || long_ret > 3) {
	  DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsSecLevel: security level is not noAuthNoPriv(1), authNopriv(2) or authPriv(3)\n"));