vacm_vars.c

ucd-snmp源代码

	  aptr->readView[var_val_len] = 0;
      }
  } else if (action == FREE) {
	/*  Try to undo the SET here (abnormal usage of FREE clause)  */
      if ((aptr = access_parse_accessEntry(name, name_len)) != NULL &&
	  resetOnFail) {
	  memcpy(aptr->readView, string, var_val_len);
      }
  }
  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)
{
  static unsigned char string[VACMSTRINGLEN];
  struct vacm_accessEntry *aptr = NULL;
  static int resetOnFail;

  if (action == RESERVE1) {
      resetOnFail = 0;
      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 > 32) {
	  DEBUGMSGTL(("mibII/vacm_vars",
		      "write to vacmAccessWriteViewName: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
  } else if (action == RESERVE2) {
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  resetOnFail = 1;
	  memcpy(string, aptr->writeView, VACMSTRINGLEN);
	  memcpy(aptr->writeView, var_val, var_val_len);
	  aptr->writeView[var_val_len] = 0;
      }
  } else if (action == FREE) {
	/*  Try to undo the SET here (abnormal usage of FREE clause)  */
      if ((aptr = access_parse_accessEntry(name, name_len)) != NULL &&
	  resetOnFail) {
	  memcpy(aptr->writeView, string, var_val_len);
      }
  }
  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)
{
  static unsigned char string[VACMSTRINGLEN];
  struct vacm_accessEntry *aptr = NULL;
  static int resetOnFail;
  
  if (action == RESERVE1) {
      resetOnFail = 0;
      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 > 32) {
	  DEBUGMSGTL(("mibII/vacm_vars",
		      "write to vacmAccessNotifyViewName: bad length\n"));
	  return SNMP_ERR_WRONGLENGTH;
      }
  } else if (action == RESERVE2) {
      if ((aptr = access_parse_accessEntry(name, name_len)) == NULL) {
	  return SNMP_ERR_INCONSISTENTNAME;
      } else {
	  resetOnFail = 1;
	  memcpy(string, aptr->notifyView, VACMSTRINGLEN);
	  memcpy(aptr->notifyView, var_val, var_val_len);
	  aptr->notifyView[var_val_len] = 0;
      }
  } else if (action == FREE) {
	/*  Try to undo the SET here (abnormal usage of FREE clause)  */
      if ((aptr = access_parse_accessEntry(name, name_len)) != NULL &&
	  resetOnFail) {
	  memcpy(aptr->notifyView, string, var_val_len);
      }
  }
  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, i;

  /* first check the validity of the oid */
  if ((oidLen <= 0) || (!oidIndex)) {
      return SNMP_ERR_INCONSISTENTNAME;
  }
  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 SNMP_ERR_RESOURCEUNAVAILABLE;
  }
  
  if (subtreeL < 0) {
      return SNMP_ERR_NOCREATION;
  }

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

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

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

  for(i = 0; i < subtreeL; i++) {  
      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, 1);
  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)
{
  static long long_ret;
  char *newViewName;
  oid *newViewSubtree;
  size_t viewNameLen,viewSubtreeLen;
  struct vacm_viewEntry *vptr;
  int rc = 0;

  if (action == RESERVE1) {
      if (var_val_type != ASN_INTEGER) {
	  return SNMP_ERR_WRONGTYPE;
      }
      if (var_val_len != sizeof(long_ret)) {
	  return SNMP_ERR_WRONGLENGTH;
      }
      long_ret = *((long *) var_val);
      if (long_ret == RS_NOTREADY || long_ret < 1 || long_ret > 6) {
	  return SNMP_ERR_WRONGVALUE;
      }

      /*  See if we can parse the oid for model/name first.  */
      if ((rc = view_parse_oid(&name[VIEW_MIB_LENGTH],name_len-VIEW_MIB_LENGTH,
			       (u_char **)&newViewName, &viewNameLen,
			       (oid **)&newViewSubtree, &viewSubtreeLen))) {
	  return rc;
      }

      if (viewNameLen < 1 || viewNameLen > 32) {
	  free(newViewName);
	  free(newViewSubtree);
	  return SNMP_ERR_NOCREATION;
      }

      /*  Now see if a group already exists with these index values.  */
      vptr = vacm_getViewEntry(newViewName, newViewSubtree, viewSubtreeLen, 1);

      if (vptr != NULL) {
	    if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {
		free(newViewName);
		free(newViewSubtree);
		long_ret = RS_NOTREADY;
		return SNMP_ERR_INCONSISTENTVALUE;
	    }
      } else {
	  if (long_ret == RS_ACTIVE || long_ret == RS_NOTINSERVICE) {
	      free(newViewName);
	      free(newViewSubtree);
	      return SNMP_ERR_INCONSISTENTVALUE;
	  }
	  if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {

	      /*  Generate a new group entry.  */
	      if ((vptr = vacm_createViewEntry(newViewName, &newViewSubtree[1],
					       viewSubtreeLen-1)) == NULL) {
		  free(newViewName);
		  free(newViewSubtree);
		  return SNMP_ERR_GENERR;
	      }
		
	      /*  Set defaults.  */
	      vptr->viewStorageType = ST_NONVOLATILE;
	      vptr->viewStatus = RS_NOTREADY;
	      vptr->viewType = SNMP_VIEW_INCLUDED;
	  }
      }	
      free(newViewName);
      free(newViewSubtree);
  } else if (action == ACTION) {
      view_parse_oid(&name[VIEW_MIB_LENGTH], name_len-VIEW_MIB_LENGTH,
		     (u_char **)&newViewName, &viewNameLen,
		     (oid **)&newViewSubtree, &viewSubtreeLen);

      vptr = vacm_getViewEntry(newViewName, newViewSubtree, viewSubtreeLen, 1);

      if (vptr != NULL) {
	  if (long_ret == RS_CREATEANDGO || long_ret == RS_ACTIVE) {
	      vptr->viewStatus = RS_ACTIVE;
	  } else if (long_ret == RS_CREATEANDWAIT) {
	      vptr->viewStatus = RS_NOTINSERVICE;
	  } else if (long_ret == RS_NOTINSERVICE) {
	      if (vptr->viewStatus == RS_ACTIVE) {
		  vptr->viewStatus = RS_NOTINSERVICE;
	      } else if (vptr->viewStatus == RS_NOTREADY) {
		  free(newViewName);
		  free(newViewSubtree);
		  return SNMP_ERR_INCONSISTENTVALUE;
	      }
	  }
      }
      free(newViewName);
      free(newViewSubtree);
  } else if (action == COMMIT){
      view_parse_oid(&name[VIEW_MIB_LENGTH], name_len-VIEW_MIB_LENGTH,
		     (u_char **)&newViewName, &viewNameLen,
		     (oid **)&newViewSubtree, &viewSubtreeLen);

      vptr = vacm_getViewEntry(newViewName, newViewSubtree, viewSubtreeLen, 1);
    
      if (vptr != NULL) {
	  if (long_ret == RS_DESTROY) {
	      vacm_destroyViewEntry(newViewName,newViewSubtree,viewSubtreeLen);
	  }
      }
      free(newViewName);
      free(newViewSubtree);
  } else if (action == UNDO) {
      if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {
	  view_parse_oid(&name[VIEW_MIB_LENGTH], name_len-VIEW_MIB_LENGTH,
			 (u_char **)&newViewName, &viewNameLen,
			 (oid **)&newViewSubtree, &viewSubtreeLen);

	  vptr = vacm_getViewEntry(newViewName, newViewSubtree,
				   viewSubtreeLen, 1);
	  
	  if (vptr != NULL) {
	      vacm_destroyViewEntry(newViewName,newViewSubtree,viewSubtreeLen);
	  }
	  free(newViewName);
	  free(newViewSubtree);
      }    
  }

  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)
{
    long newValue = *((long *) var_val);
    static long oldValue;
    struct vacm_viewEntry *vptr = NULL;
  
    if (action == RESERVE1) {
	if (var_val_type != ASN_INTEGER) {
	    return SNMP_ERR_WRONGTYPE;
	}
	if (var_val_len != sizeof(long)){
	    return SNMP_ERR_WRONGLENGTH;
	}
    } else if (action == RESERVE2) {
	if ((vptr = view_parse_viewEntry(name, name_len)) == NULL) {
	    return SNMP_ERR_INCONSISTENTNAME;
	} else {
	    if ((newValue == ST_VOLATILE || newValue == ST_NONVOLATILE) &&
		(vptr->viewStorageType == ST_VOLATILE ||
		 vptr->viewStorageType == ST_NONVOLATILE)) {
		oldValue = vptr->viewStorageType;
		vptr->viewStorageType = newValue;
	    } else if (newValue == vptr->viewStorageType) {
		return SNMP_ERR_NOERROR;
	    } else {
		return SNMP_ERR_INCONSISTENTVALUE ;
	    }
	}
    } else if (action == UNDO) {
	if ((vptr = view_parse_viewEntry(name, name_len)) != NULL) {
	    vptr->viewStorageType = oldValue;
	}
    }

    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)
{
    static unsigned char string[VACMSTRINGLEN];
    static long length;
    struct vacm_viewEntry *vptr = NULL;
  
    if (action == RESERVE1) {
	if (var_val_type != ASN_OCTET_STR) {
	    return SNMP_ERR_WRONGTYPE;
	}
	if (var_val_len > 16) {
	    return SNMP_ERR_WRONGLENGTH;
	}
    } else if (action == RESERVE2) {
	if ((vptr = view_parse_viewEntry(name, name_len)) == NULL) {
	    return SNMP_ERR_INCONSISTENTNAME;
	} else {
	    memcpy(string, vptr->viewMask, vptr->viewMaskLen);
	    length = vptr->viewMaskLen;
	    memcpy(vptr->viewMask, var_val, var_val_len);
	    vptr->viewMaskLen = var_val_len;
	}
    } else if (action == FREE) {
	if ((vptr = view_parse_viewEntry(name, name_len)) != NULL) {
	    memcpy(vptr->viewMask, string, length);
	    vptr->viewMaskLen = length;
	}
    }
    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)
{
    long newValue = *((long *) var_val);
    static long oldValue;
    struct vacm_viewEntry *vptr = NULL;
  
    if (action == RESERVE1) {
	if (var_val_type != ASN_INTEGER) {
	    return SNMP_ERR_WRONGTYPE;
	}
	if (var_val_len != sizeof(long)){
	    return SNMP_ERR_WRONGLENGTH;
	}
	if (newValue < 1 || newValue > 2) {
	    return SNMP_ERR_WRONGVALUE;
	}
    } else if (action == RESERVE2) {
	if ((vptr = view_parse_viewEntry(name, name_len)) == NULL) {
	    return SNMP_ERR_INCONSISTENTNAME;
	} else {
	    oldValue = vptr->viewType;
	    vptr->viewType = newValue;
	}
    } else if (action == UNDO) {
	if ((vptr = view_parse_viewEntry(name, name_len)) != NULL) {
	    vptr->viewType = oldValue;
	}
    }

    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)
{
    static long long_ret;

    if (actio