snmptargetaddrentry.c

ucd-snmp源代码

int
write_snmpTargetAddrTDomain(
   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 targetAddrTable_struct *target = NULL;
  static oid old_oid[MAX_OID_LEN];
  static size_t old_oid_len;
  
  if (action == RESERVE1) {
      if (var_val_type != ASN_OBJECT_ID) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTDomain not ASN_OBJECT_ID\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if ((var_val_len > (MAX_OID_LEN * sizeof(oid))) ||
	  (var_val_len % sizeof(oid) != 0)) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTDomain: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
  } else if (action == RESERVE2) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTDOMAINCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen,
					       name, &name_len, 1)) == 0) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTDomain: BAD OID!\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  if (target->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",	
		      "write to snmpTargetAddrTDomain: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  if (target->rowStatus == SNMP_ROW_ACTIVE) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",
	      "write to snmpTargetAddrTDomain: not allowed in active row.\n"));
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }

	  /*  Finally, we're golden, save current value.  */

	  memcpy(old_oid, target->tDomain, target->tDomainLen * sizeof(oid));
	  old_oid_len = target->tDomainLen;

	  memcpy((u_char *)target->tDomain, var_val, var_val_len);
	  target->tDomainLen = var_val_len / sizeof(oid);

	  /*  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 == FREE || action == UNDO) {
      /*  Try to undo the SET here (abnormal usage of FREE clause)  */
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTDOMAINCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen,
					       name, &name_len, 1)) != NULL) {
	  if (target->storageType != SNMP_STORAGE_READONLY &&
	      target->rowStatus   != SNMP_ROW_ACTIVE) {
	      memcpy((u_char *)target->tDomain, (u_char *)old_oid,
		                                  (old_oid_len * sizeof(oid)));
	      target->tDomainLen = old_oid_len;
	      if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  snmpTargetAddr_rowStatusCheck(target) == 0) {
		  target->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  }
  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrTDomain */


int
write_snmpTargetAddrTAddress(
   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 targetAddrTable_struct *target = NULL;
  static char *old_addr = NULL;
  static size_t old_len = 0;

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

	  old_addr = target->tAddress;
	  old_len  = target->tAddressLen;
	  target->tAddress = (u_char *)malloc(var_val_len);
	  if (target->tAddress == NULL) {
	      return SNMP_ERR_RESOURCEUNAVAILABLE;
	  }
	  memcpy(target->tAddress, var_val, var_val_len);
	  target->tAddressLen = var_val_len;

	  /*  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_addr);
      old_addr = NULL;
  } else if (action == FREE || action == UNDO) {
      /*  Try to undo the SET here (abnormal usage of FREE clause)  */
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTADDRESSCOLUMN;
      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->tAddress);
	      target->tAddress    = old_addr;
	      target->tAddressLen = old_len;
	      if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
		  snmpTargetAddr_rowStatusCheck(target) == 0) {
		  target->rowStatus = SNMP_ROW_NOTREADY;
	      }
	  }
      }
  }

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrTAddress */


int
write_snmpTargetAddrTimeout(
   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)
{
  /* variables we may use later */
  static long                    long_ret;
  size_t                         size;
  struct targetAddrTable_struct *temp_struct;

  if (var_val_type != ASN_INTEGER) {
      DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > (size = sizeof(long_ret))) {
      DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  long_ret = *((long *) var_val);
  
  /* spec check range, no spec check */
  
  /* Find row in linked list and check pertinent status... */
  snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTIMEOUTCOLUMN;
  if ((temp_struct = search_snmpTargetAddrTable
       (snmpTargetAddrOID, snmpTargetAddrOIDLen, 
	name, &name_len, 1)) == 0 ) {
    DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout : BAD OID\n"));
    return SNMP_ERR_NOSUCHNAME;
  }
  /* row exists, check if it is changeable */
  if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
    DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout : row is read only\n"));
    return SNMP_ERR_NOTWRITABLE;
  }

  /* Finally, we're golden, should we save value? */
  if (action == COMMIT)  {
    temp_struct->timeout = long_ret;
  }

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrTimeout */


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

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrRetryCount not ASN_INTEGER\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long)) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrRetryCount: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      long_ret = *((long *) var_val);
      if (long_ret < 0 || long_ret > 255) {
	  return SNMP_ERR_WRONGVALUE;
      }
  } else if (action == RESERVE2) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = 
	                                        SNMPTARGETADDRRETRYCOUNTCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen, 
					       name, &name_len, 1)) == NULL) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTimeout: BAD OID\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  if (target->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",
		     "write to snmpTargetAddrRetryCount: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
      }
  } else if (action == COMMIT) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = 
	                                        SNMPTARGETADDRRETRYCOUNTCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen, 
					       name, &name_len, 1)) != NULL) {
	  target->retryCount = long_ret;
      }
  }

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrRetryCount */

static int is_delim(const char c) {
    return (c == 0x020 || c == 0x09 || c == 0x0d || c == 0x0b);
}

int
snmpTagListValid(const char *tagList, const size_t tagListLen)
{
    size_t i = 0;
    int inTag = 0;

    for (i = 0; i < tagListLen; i++) {
	if (is_delim(tagList[i]) && !inTag) {
	    /*  Either a leading delimiter or two consecutive delimiters.  */
	    return 0;
	} else if (is_delim(tagList[i]) && inTag) {
	    inTag = 0;
	} else if (!is_delim(tagList[i]) && !inTag) {
	    inTag = 1;
	}
    }
    if (!inTag) {
	/*  Trailing delimiter.  */
	return 0;
    }
    return 1;
}

int
write_snmpTargetAddrTagList(
   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 targetAddrTable_struct *target = NULL;
  static char *old_tlist;

  if (action == RESERVE1) {
      if (var_val_type != ASN_OCTET_STR) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTagList not ASN_OCTET_STR\n"));
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len > 255) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTagList: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
      if (!snmpTagListValid(var_val, var_val_len)) {
	  return SNMP_ERR_WRONGVALUE;
      }
  } else if (action == RESERVE2) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTAGLISTCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen,
					       name, &name_len, 1)) == NULL) {
	  DEBUGMSGTL(("snmpTargetAddrEntry",
		      "write to snmpTargetAddrTagList: BAD OID!\n"));
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  if (target->storageType == SNMP_STORAGE_READONLY) {
	      DEBUGMSGTL(("snmpTargetAddrEntry",
			"write to snmpTargetAddrTagList: row is read only\n"));
	      return SNMP_ERR_NOTWRITABLE;
	  }
	  old_tlist = target->tagList;
	  target->tagList = (char *)malloc(var_val_len + 1);
	  if (target->tagList == NULL) {
	      return SNMP_ERR_RESOURCEUNAVAILABLE;
	  }
	  memcpy(target->tagList, var_val, var_val_len);
	  target->tagList[var_val_len] = '\0';
      }
  } else if (action == COMMIT) {
      SNMP_FREE(old_tlist);
      old_tlist = NULL;
  } else if (action == FREE || action == UNDO) {
      snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTAGLISTCOLUMN;
      if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID, 
					       snmpTargetAddrOIDLen,
					       name, &name_len, 1)) != NULL) {
	  if (target->storageType != SNMP_STORAGE_READONLY) {
	      SNMP_FREE(target->tagList);
	      target->tagList = old_tlist;
	  }
      }
  }

  return SNMP_ERR_NOERROR;
}  /* write_snmpTargetAddrTagList */


int
write_snmpTargetAddrParams(
   int      action,
   u_char   *var_val,
   u_char   var_val_type,