vacm_vars.c

包含一下内容: * An extensible agent * An SNMP library * tools to request or set information from SNMP a

      }
      if (long_ret == RS_DESTROY) {
        /* destroying a non-existent row is actually legal */
        free(newGroupName);
        free(newContextPrefix);
        return SNMP_ERR_NOERROR;
      }

      /* generate a new group entry */
      if ((aptr = vacm_createAccessEntry(newGroupName,newContextPrefix,model,level)) == NULL) {
        free(newGroupName);
        free(newContextPrefix);
        return SNMP_ERR_GENERR;
      }

	  /*set default storage type*/
	  /*This version only supports volatile storage*/
	  aptr->storageType = ST_NONVOLATILE;

      /* set the status of the row based on the request */
      if (long_ret == RS_CREATEANDGO)
        aptr->status = RS_ACTIVE;
      else if (long_ret == RS_CREATEANDWAIT)
        aptr->status = RS_NOTINSERVICE;

    }  /* endif -- uptr */
  }  /* endif -- action==COMMIT */

  return SNMP_ERR_NOERROR;
}

int
write_vacmAccessStorageType(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;
  struct vacm_accessEntry *aptr;
  
  if (var_val_type != ASN_INTEGER){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmSecurityToGroupStorageType not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(long_ret)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmSecurityToGroupStorageType: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      long_ret = *((long *) var_val);
/*      if ((long_ret == ST_VOLATILE || long_ret == ST_NONVOLATILE) &&
          (aptr->storageType == ST_VOLATILE ||
           aptr->storageType == ST_NONVOLATILE)) */
	  /*This version only supports volatile storage*/ 
	  if (long_ret == ST_VOLATILE &&
          aptr->storageType == ST_VOLATILE)           
        aptr->storageType = long_ret;
      else
        return SNMP_ERR_INCONSISTENTVALUE;
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmAccessContextMatch(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;
  struct vacm_accessEntry *aptr;
  
  if (var_val_type != ASN_INTEGER){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessContextMatch not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(long_ret)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessContextMatch: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      long_ret = *((long *) var_val);
      if (long_ret == CM_EXACT || long_ret == CM_PREFIX)
        aptr->contextMatch = long_ret;
      else
        return SNMP_ERR_INCONSISTENTVALUE;
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmAccessReadViewName(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 unsigned char string[VACMSTRINGLEN];
  struct vacm_accessEntry *aptr;
  
  if (var_val_type != ASN_OCTET_STR){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessReadViewName not ASN_OCTET_STR\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(string)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessReadViewName: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      
      memcpy(aptr->readView, var_val, var_val_len);
	  aptr->readView[var_val_len] = 0;
           
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmAccessWriteViewName(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 unsigned char string[VACMSTRINGLEN];
  struct vacm_accessEntry *aptr;
  
  if (var_val_type != ASN_OCTET_STR){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessWriteViewName not ASN_OCTET_STR\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(string)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessWriteViewName: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      
      memcpy(aptr->writeView, var_val, var_val_len);
	  aptr->writeView[var_val_len] = 0;
   
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmAccessNotifyViewName(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 unsigned char string[VACMSTRINGLEN];
  struct vacm_accessEntry *aptr;
  
  if (var_val_type != ASN_OCTET_STR){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessNotifyViewName not ASN_OCTET_STR\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(string)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmAccessNotifyViewName: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      
      memcpy(aptr->notifyView, var_val, var_val_len);
	  aptr->notifyView[var_val_len] = 0;
      
  }
  return SNMP_ERR_NOERROR;
}

int 
view_parse_oid(oid *oidIndex, size_t oidLen,
			  unsigned char **viewName, size_t *viewNameLen,
              oid **subtree, size_t *subtreeLen)
{
  int viewNameL,subtreeL;
  int i;

  /* first check the validity of the oid */
  if ((oidLen <= 0) || (!oidIndex)) {
    return 1;
  }
  viewNameL=oidIndex[0];
  subtreeL = oidLen-viewNameL-1;	/* the initial name length */
 
  /* its valid, malloc the space and store the results */
  if (viewName == NULL || subtree == NULL) {
    return 1;
  }

  
  *viewName = (unsigned char *) malloc(viewNameL+1);

  if (*viewName == NULL) {
    return 1;
  }
  
  *subtree = (oid *) malloc(sizeof(oid)*subtreeL);        
  if (*subtree == NULL) {
	  free(*viewName);
    return 1;
  }
    
  *subtreeLen = subtreeL;
  *viewNameLen = viewNameL;

  for(i = 0; i < viewNameL; i++) {
    if (oidIndex[i+1] > 255) {
      free(*viewName);
      free(*subtree);
      return 1;
    }
    viewName[0][i] = (unsigned char) oidIndex[i+1];
  }
  viewName[0][viewNameL] = 0;
  
  
  for(i = 0; i < subtreeL; i++) {  
    if (oidIndex[i+viewNameL+1] > 255) {
	  free(*viewName);
      free(*subtree);
      return 1;
    }
    subtree[0][i] = (oid) oidIndex[i+viewNameL+1];
  }

  return 0;

} 

oid *
view_generate_OID(oid *prefix, size_t prefixLen, struct vacm_viewEntry *vptr,
                       size_t *length)
{
  oid *indexOid;
  int i,viewNameLen,viewSubtreeLen;

  viewNameLen=strlen(vptr->viewName);
  viewSubtreeLen=vptr->viewSubtreeLen;

  *length = 2 + viewNameLen + viewSubtreeLen + prefixLen;
  indexOid = (oid *) malloc(*length * sizeof(oid));
  if (indexOid) {
    memmove(indexOid, prefix, prefixLen * sizeof (oid));
  
  indexOid[prefixLen]=viewNameLen;    
  for(i = 0; i < viewNameLen; i++)
      indexOid[viewNameLen+1+i] = (oid) vptr->viewName[i];
      
  indexOid[prefixLen+viewNameLen+1]=viewSubtreeLen;    
  for(i = 0; i < viewSubtreeLen; i++)
      indexOid[prefixLen+viewNameLen+2+i] = (oid) vptr->viewSubtree[i];

  }
  return indexOid;

}

struct vacm_viewEntry *
view_parse_viewEntry(oid *name, size_t name_len)
{
  struct vacm_viewEntry *vptr;

  char *newViewName;
  oid *newViewSubtree;
  size_t viewNameLen,viewSubtreeLen;
  
  if (view_parse_oid(&name[VIEW_MIB_LENGTH], name_len-VIEW_MIB_LENGTH,
					  (u_char **)&newViewName, &viewNameLen,
					  (oid **)&newViewSubtree, &viewSubtreeLen))
    return NULL;

  vptr = vacm_getViewEntry(newViewName, newViewSubtree, viewSubtreeLen);
  free(newViewName);
  free(newViewSubtree);
  
  return vptr;

}  /* end vacm_parse_viewEntry() */

int
write_vacmViewStatus(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;
  char *newViewName;
  oid *newViewSubtree;
  size_t viewNameLen,viewSubtreeLen;
  struct vacm_viewEntry *vptr;

  if (var_val_type != ASN_INTEGER){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewStatus not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(long_ret)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewStatus: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
    long_ret = *((long *) var_val);

    /* ditch illegal values now */
    /* notReady can not be used, but the return error code is not mentioned */
    if (long_ret == RS_NOTREADY || long_ret < 1 || long_ret > 6)
      return SNMP_ERR_INCONSISTENTVALUE;
    
    /* see if we can parse the oid for model/name first */
    if (view_parse_oid(&name[VIEW_MIB_LENGTH], name_len-VIEW_MIB_LENGTH,
                      (u_char **)&newViewName, &viewNameLen,
                      (oid **)&newViewSubtree, &viewSubtreeLen))      
      return SNMP_ERR_INCONSISTENTNAME;		
	
	
    /* Now see if a group already exists with these index values */
    vptr = vacm_getViewEntry(newViewName, newViewSubtree, viewSubtreeLen);
    
    if (vptr)
	  {			/* If so, we set the appropriate value... */
		if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) 
		{
		  return SNMP_ERR_INCONSISTENTVALUE;
		}
		if (long_ret == RS_DESTROY) 
		{
		  vacm_destroyViewEntry(newViewName, newViewSubtree, viewSubtreeLen);        
		} 
		else 
		{
		  vptr->viewStatus = long_ret;
		}
	  } 
	  else 
	  {			/* ...else we create a new group entry */
		/* check for a valid status column set */
		if (long_ret == RS_ACTIVE || long_ret == RS_NOTINSERVICE) {
          free(newViewName);
          free(newViewSubtree);
          return SNMP_ERR_INCONSISTENTVALUE;
		}
		
		if (long_ret == RS_DESTROY) {
		  /* destroying a non-existent row is actually legal */
		  free(newViewName);
          free(newViewSubtree);        
          return SNMP_ERR_NOERROR;
        }

	    /* generate a new group entry */
        if ((vptr = vacm_createViewEntry(newViewName,newViewSubtree,viewSubtreeLen)) == NULL) {
		  free(newViewName);
          free(newViewSubtree);
		  return SNMP_ERR_GENERR;
		}
		
		/*set default storage type*/
		vptr->viewStorageType = ST_NONVOLATILE;
		
		/* set the status of the row based on the request */
		if (long_ret == RS_CREATEANDGO)
		  vptr->viewStatus = RS_ACTIVE;
		else if (long_ret == RS_CREATEANDWAIT)
		  vptr->viewStatus = RS_NOTINSERVICE;

	  }  /* endif -- uptr */
	free(newViewName);
	free(newViewSubtree);
    }  /* endif -- action==COMMIT */

  return SNMP_ERR_NOERROR;
}

int
write_vacmViewStorageType(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;
  struct vacm_viewEntry *vptr;
  
  if (var_val_type != ASN_INTEGER){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmSecurityToGroupStorageType not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(long_ret)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmSecurityToGroupStorageType: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((vptr = view_parse_viewEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      long_ret = *((long *) var_val);
      
      if ((long_ret == ST_VOLATILE || long_ret == ST_NONVOLATILE) &&
          (vptr->viewStorageType == ST_VOLATILE ||
           vptr->viewStorageType == ST_NONVOLATILE))
		vptr->viewStorageType = long_ret;
      else
        return SNMP_ERR_INCONSISTENTVALUE;
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmViewMask(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 unsigned char string[VACMSTRINGLEN];
  struct vacm_viewEntry *vptr;
  
  if (var_val_type != ASN_OCTET_STR){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewTreeFamilyMask not ASN_OCTET_STR\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(string)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewTreeFamilyMask: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((vptr = view_parse_viewEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      
      memcpy(vptr->viewMask, var_val, var_val_len);
      vptr->viewMaskLen = var_val_len;   
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmViewType(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;
  struct vacm_viewEntry *vptr;
  
  if (var_val_type != ASN_INTEGER){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewTreeFamilyType not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(long_ret)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewTreeFamilyType: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  if (action == COMMIT){
      /* don't allow creations here */
      if ((vptr = view_parse_viewEntry(name, name_len)) == NULL) {
        return SNMP_ERR_NOSUCHNAME;
      }
      
      long_ret=*((long *) var_val);
	  vptr->viewType=long_ret;
  }
  return SNMP_ERR_NOERROR;
}

int
write_vacmViewSpinLock(
   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;

  if (var_val_type != ASN_INTEGER){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewSpinLock not ASN_INTEGER\n"));
      return SNMP_ERR_WRONGTYPE;
  }
  if (var_val_len > sizeof(long_ret)){
      DEBUGMSGTL(("mibII/vacm_vars","write to vacmViewSpinLock: bad length\n"));
      return SNMP_ERR_WRONGLENGTH;
  }
  long_ret = *((long *) var_val);
  if (long_ret != (long)vacmViewSpinLock)
    return SNMP_ERR_INCONSISTENTVALUE;
  if (action == COMMIT) {
    if (vacmViewSpinLock == 2147483647)
      vacmViewSpinLock = 0;
    else
      vacmViewSpinLock++;
  }
  return SNMP_ERR_NOERROR;
}  /* end write_vacmViewSpinLock() */