snmptargetaddrentry.c

ucd-snmp源代码

   size_t   var_val_len,
   u_char   *statP,
   oid      *name,
   size_t   name_len)
{
  struct targetAddrTable_struct *target = NULL;
  static char *old_params = NULL;

  if (action == RESERVE1) {
      if (var_val_type != ASN_OCTET_STR) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrParams not ASN_OCTET_STR\n"));
	  return SNMP_ERR_WRONGTYPE;
      } else if (var_val_len < 1 || var_val_len > 32) {
	  return SNMP_ERR_WRONGLENGTH;
      }
  } else if (action == RESERVE2) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRPARAMSCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen,
					       name, &name_len, 1)) == 0) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrParams: BAD OID!\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  if (target->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",	
		      "write to snmpTargetAddrParams: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  if (target->rowStatus == SNMP_ROW_ACTIVE) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",
	     "write to snmpTargetAddrParams: not allowed in active row.\n"));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  old_params = target->params;
	  target->params = (u_char *)malloc(var_val_len + 1);
	  if (target->params == NULL) {
	      return SNMP_ERR_RESOURCEUNAVAILABLE;
	  }
	  memcpy(target->params, var_val, var_val_len);
	  target->params[var_val_len] = '\0';

	  /*  If row is new, check if its status can be updated.  */
	  if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
	      (snmpTargetAddr_rowStatusCheck(target) != 0)) {
	      target->rowStatus = SNMP_ROW_NOTINSERVICE;
	  }
      }
  } else if (action == COMMIT) {
      SNMP_FREE(old_params);
      old_params = NULL;
  } else if (action == FREE || action == UNDO) {
      /*  Try to undo the SET here (abnormal usage of FREE clause)  */
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRPARAMSCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen,
					       name, &name_len, 1)) != NULL) {
	  if (target->storageType != SNMP_STORAGE_READONLY && 
	      target->rowStatus   != SNMP_ROW_ACTIVE) {
	      SNMP_FREE(target->params);
	      target->params = old_params;
	      if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  snmpTargetAddr_rowStatusCheck(target) == 0) {
		  target->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  }

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrParams */

int
write_snmpTargetAddrStorageType(
   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);
  struct targetAddrTable_struct *target;

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrStorageType not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrStorageType: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (long_ret != SNMP_STORAGE_OTHER && 
	  long_ret != SNMP_STORAGE_VOLATILE &&
	  long_ret != SNMP_STORAGE_NONVOLATILE) {
	  DEBUGMSGTL(("snmpTargetAddrEntry", "write to snmpTargetAddrStorageType: attempted storage type not a valid"));
	  DEBUGMSG(("snmpTargetAddrEntry", " 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) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = 
	                                       SNMPTARGETADDRSTORAGETYPECOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen, 
					       name, &name_len, 1)) == NULL) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrStorageType: BAD OID\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else { 
	  if (target->storageType == SNMP_STORAGE_PERMANENT || 
	      target->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",
			  "write to snmpTargetAddrStorageType: row has unchangeable storage status: %d\n",
			  target->storageType));
	      return SNMP_ERR_WRONGVALUE;
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = 
	                                       SNMPTARGETADDRSTORAGETYPECOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen, 
					       name, &name_len, 1)) != NULL) {
	  target->storageType = long_ret;
      }
  }

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrStorageType */


/* snmpTargeAddr_createNewRow is called from write_snmpTargetAddrRowStatus
   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 snmpTargetAddr_createNewRow(
     oid   *name,
     size_t name_len)
{
  size_t newNameLen;
  int i;
  struct targetAddrTable_struct *temp_struct;

  /* setup a new snmpTargetAddrTable structure and add it to the list */
  newNameLen = name_len - snmpTargetAddrOIDLen;
  if (newNameLen > 0) {
    temp_struct       = snmpTargetAddrTable_create();
    temp_struct->name = (char *)malloc(newNameLen + 1);
    if (temp_struct->name == NULL) {
      return 0;
    }

    for (i = 0; i < (int)newNameLen; i++) {
      temp_struct->name[i] = (char)name[i+snmpTargetAddrOIDLen];
    }

    temp_struct->name[newNameLen]  = '\0';
    temp_struct->rowStatus         = SNMP_ROW_NOTREADY;
    
    snmpTargetAddrTable_addToList(temp_struct, &aAddrTable);

    return 1;
  }

  return 0;
}  /* snmpTargetAddr_createNewRow */
	

/* Assign a value to the Row Status variable */
int
write_snmpTargetAddrRowStatus(
   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 targetAddrTable_struct *target = NULL;

  if (action == RESERVE1) {
      value = *((long *)var_val);
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrRowStatus not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(int)) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrRowStatus: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (value == RS_NOTREADY || value < 1 || value > 6) {
	  return SNMP_ERR_WRONGVALUE;
      }

      /*  Check index value is reasonable.  */

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

      /*  Search for struct in linked list.  */

      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] =SNMPTARGETADDRROWSTATUSCOLUMN;
      target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen, 
					       name, &name_len, 1);

      if (target != NULL) {
	  if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
	      value = RS_NOTREADY;
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }
	  if (target->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetAddrEntry", "row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  if (target->storageType == SNMP_STORAGE_PERMANENT) {
	      if (value == RS_DESTROY) {
		  DEBUGMSGTL(("snmpTargetAddrEntry",
			      "unable to destroy permanent row\n"));
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  }
      } else {
	  if (value == RS_ACTIVE || value == RS_NOTINSERVICE) {
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }
	  if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
	      if (snmpTargetAddr_createNewRow(name, name_len) == 0) {
		  DEBUGMSGTL(("snmpTargetAddrEntry",
			      "couldn't malloc() new row\n"));
		  return SNMP_ERR_RESOURCEUNAVAILABLE;
	      }
	  }
      }
  } else if (action == ACTION) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] =SNMPTARGETADDRROWSTATUSCOLUMN;
      target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					  snmpTargetAddrOIDLen, 
					  name, &name_len, 1);

      if (target != NULL) {
	  if (value == RS_CREATEANDGO) {
	      /*  Check whether all the required objects have been set.  */
	      if (snmpTargetAddr_rowStatusCheck(target)) {
		  target->rowStatus = RS_ACTIVE;
	      } else {
		  target->rowStatus = RS_NOTREADY;
	      }
	  } else if (value == RS_CREATEANDWAIT) {
	      /*  Check whether all the required objects have been set.  */
	      if (snmpTargetAddr_rowStatusCheck(target)) {
		  target->rowStatus = RS_NOTINSERVICE;
	      } else {
		  target->rowStatus = RS_NOTREADY;
	      }
	  } else if (value == RS_ACTIVE) {
	      if (target->rowStatus == RS_NOTINSERVICE) {
		  target->rowStatus = RS_ACTIVE;
	      } else if (target->rowStatus == RS_NOTREADY) {
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  } else if (value == RS_NOTINSERVICE) {
	      if (target->rowStatus == RS_ACTIVE) {
		  target->rowStatus = RS_NOTINSERVICE;
	      } else if (target->rowStatus == RS_NOTREADY) {
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] =SNMPTARGETADDRROWSTATUSCOLUMN;
      target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					  snmpTargetAddrOIDLen, 
					  name, &name_len, 1);
      if (target != NULL) {
	  if (value == RS_DESTROY) {
	      snmpTargetAddrTable_remFromList(target, &aAddrTable);
	  }
	  if (value == RS_NOTINSERVICE) {
	      if (target->sess != NULL) {
		  snmp_close(target->sess);
		  target->sess = NULL;
	      }
	  }
      }
  } else if (action == UNDO || action == FREE) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] =SNMPTARGETADDRROWSTATUSCOLUMN;
      target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					  snmpTargetAddrOIDLen, 
					  name, &name_len, 1);
      if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
	  if (target != NULL) {
	      snmpTargetAddrTable_remFromList(target, &aAddrTable);
	  }
      }
  }
  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrRowStatus */



int
write_targetSpinLock(
   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)
{
    if (action == RESERVE1) {
	if (var_val_type != ASN_INTEGER) {
	    return SNMP_ERR_WRONGTYPE;
	}
	if (var_val_len != sizeof(unsigned long)) {
	    return SNMP_ERR_WRONGLENGTH;
	}
	if (*((unsigned long *)var_val) != snmpTargetSpinLock) {
	    return SNMP_ERR_INCONSISTENTVALUE;
	}
    } else if (action == COMMIT) {
	if (snmpTargetSpinLock == 2147483647) {
	    snmpTargetSpinLock = 0;
	} else {
	    snmpTargetSpinLock++;
	}
    }
    return SNMP_ERR_NOERROR;
}



u_char *
var_targetSpinLock(struct variable *vp,
		   oid *name,
		   size_t *length,
		   int exact,
		   size_t *var_len,
		   WriteMethod **write_method)
{
    if (header_generic(vp, name, length, exact, var_len, write_method) == 
	MATCH_FAILED) {
	*write_method = write_targetSpinLock;
	return NULL;
    }
    if (vp->magic == SNMPTARGETSPINLOCK) {
	*write_method = write_targetSpinLock;
	*var_len = sizeof(unsigned long);
	return (u_char *)&(snmpTargetSpinLock);
    }
    return NULL;
}