2000-02-05 13:01:41 +08:00
|
|
|
/* schema_check.c - routines to enforce schema definitions */
|
|
|
|
/* $OpenLDAP$ */
|
|
|
|
/*
|
2000-05-13 10:47:56 +08:00
|
|
|
* Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
|
2000-02-05 13:01:41 +08:00
|
|
|
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "portable.h"
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include <ac/ctype.h>
|
|
|
|
#include <ac/string.h>
|
|
|
|
#include <ac/socket.h>
|
|
|
|
|
|
|
|
#include "slap.h"
|
|
|
|
#include "ldap_pvt.h"
|
|
|
|
|
2001-12-20 06:08:24 +08:00
|
|
|
static char * oc_check_required(
|
|
|
|
Entry *e,
|
|
|
|
ObjectClass *oc,
|
|
|
|
struct berval *ocname );
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine the structural object class from a set of OIDs
|
|
|
|
*/
|
2001-12-20 06:41:00 +08:00
|
|
|
int structural_class(
|
2001-12-20 06:08:24 +08:00
|
|
|
struct berval **ocs,
|
|
|
|
struct berval *scbv,
|
|
|
|
const char **text )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
ObjectClass *oc;
|
|
|
|
ObjectClass *sc = NULL;
|
|
|
|
int scn = 0;
|
|
|
|
|
|
|
|
*text = "structural object error";
|
|
|
|
scbv->bv_len = 0;
|
|
|
|
|
|
|
|
for( i=0; ocs[i]; i++ ) {
|
|
|
|
oc = oc_find( ocs[i]->bv_val );
|
|
|
|
|
|
|
|
if( oc == NULL ) {
|
|
|
|
*text = "unrecongized objectClass attribute";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( oc->soc_kind == LDAP_SCHEMA_STRUCTURAL ) {
|
|
|
|
if( sc == NULL || is_object_subclass( sc, oc ) ) {
|
|
|
|
sc = oc;
|
|
|
|
scn = i;
|
|
|
|
|
|
|
|
} else if ( !is_object_subclass( oc, sc ) ) {
|
|
|
|
/* FIXME: multiple inheritance possible! */
|
|
|
|
*text = "invalid strucutural object class chain";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( sc == NULL ) {
|
|
|
|
*text = "no strucutural object classes";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
*scbv = *ocs[scn];
|
|
|
|
return LDAP_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return structural object class from list of modifications
|
|
|
|
*/
|
|
|
|
int mods_structural_class(
|
|
|
|
Modifications *mods,
|
|
|
|
struct berval *sc,
|
|
|
|
const char **text )
|
|
|
|
{
|
|
|
|
Modifications *ocmod = NULL;
|
|
|
|
|
|
|
|
for( ; mods != NULL; mods = mods->sml_next ) {
|
|
|
|
if( mods->sml_desc == slap_schema.si_ad_objectClass ) {
|
|
|
|
if( ocmod != NULL ) {
|
|
|
|
*text = "entry has multiple objectClass attributes";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
ocmod = mods;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( ocmod == NULL ) {
|
|
|
|
*text = "entry has no objectClass attribute";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( ocmod->sml_bvalues == NULL || ocmod->sml_bvalues[0] == NULL ) {
|
|
|
|
*text = "objectClass attribute has no values";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
return structural_class( ocmod->sml_bvalues, sc, text );
|
|
|
|
}
|
2000-02-05 13:01:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* entry_schema_check - check that entry e conforms to the schema required
|
|
|
|
* by its object class(es).
|
|
|
|
*
|
|
|
|
* returns 0 if so, non-zero otherwise.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2000-04-25 21:15:55 +08:00
|
|
|
entry_schema_check(
|
2001-12-20 06:08:24 +08:00
|
|
|
Entry *e, Attribute *oldattrs,
|
|
|
|
const char** text,
|
2001-06-06 08:23:56 +08:00
|
|
|
char *textbuf, size_t textlen )
|
2000-02-05 13:01:41 +08:00
|
|
|
{
|
2001-12-20 06:08:24 +08:00
|
|
|
Attribute *a, *asc, *aoc;
|
|
|
|
ObjectClass *sc, *oc;
|
|
|
|
int rc, i;
|
|
|
|
struct berval nsc;
|
|
|
|
AttributeDescription *ad_structuralObjectClass
|
|
|
|
= slap_schema.si_ad_structuralObjectClass;
|
|
|
|
AttributeDescription *ad_objectClass
|
|
|
|
= slap_schema.si_ad_objectClass;
|
2000-06-01 02:46:13 +08:00
|
|
|
int extensible = 0;
|
2000-02-15 04:57:34 +08:00
|
|
|
|
2001-08-29 05:43:00 +08:00
|
|
|
*text = textbuf;
|
|
|
|
|
2001-07-24 12:31:01 +08:00
|
|
|
/* check single-valued attrs for multiple values */
|
|
|
|
for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
|
|
|
|
/* there should be at least one value */
|
|
|
|
assert( a->a_vals );
|
|
|
|
assert( a->a_vals[0] != NULL );
|
|
|
|
|
|
|
|
/* if single value type, check for multiple values */
|
|
|
|
if( is_at_single_value( a->a_desc->ad_type ) &&
|
|
|
|
a->a_vals[1] != NULL )
|
|
|
|
{
|
2001-10-22 21:23:05 +08:00
|
|
|
char *type = a->a_desc->ad_cname.bv_val;
|
2001-07-24 12:31:01 +08:00
|
|
|
|
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"attribute '%s' cannot have multiple values",
|
|
|
|
type );
|
|
|
|
|
|
|
|
#ifdef NEW_LOGGING
|
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
|
|
|
"entry_schema_check: dn=\"%s\" %s\n",
|
|
|
|
e->e_dn, textbuf ));
|
|
|
|
#else
|
|
|
|
Debug( LDAP_DEBUG_ANY,
|
|
|
|
"Entry (%s), %s\n",
|
|
|
|
e->e_dn, textbuf, 0 );
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return LDAP_CONSTRAINT_VIOLATION;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-25 21:15:55 +08:00
|
|
|
if( !global_schemacheck ) return LDAP_SUCCESS;
|
2000-02-05 13:01:41 +08:00
|
|
|
|
|
|
|
/* find the object class attribute - could error out here */
|
2001-12-20 06:08:24 +08:00
|
|
|
asc = attr_find( e->e_attrs, ad_structuralObjectClass );
|
|
|
|
if ( asc == NULL ) {
|
|
|
|
#ifdef NEW_LOGGING
|
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO, "entry_schema_check: "
|
|
|
|
"No structuralObjectClass for entry (%s)\n",
|
|
|
|
e->e_dn ));
|
|
|
|
#else
|
|
|
|
Debug( LDAP_DEBUG_ANY,
|
|
|
|
"No structuralObjectClass for entry (%s)\n",
|
|
|
|
e->e_dn, 0, 0 );
|
|
|
|
#endif
|
|
|
|
|
|
|
|
*text = "no structuralObjectClass operational attribute";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert( asc->a_vals != NULL );
|
|
|
|
assert( asc->a_vals[0] != NULL );
|
|
|
|
assert( asc->a_vals[1] == NULL );
|
|
|
|
|
|
|
|
sc = oc_find( asc->a_vals[0]->bv_val );
|
|
|
|
if( sc == NULL ) {
|
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"unrecognized structuralObjectClass '%s'",
|
|
|
|
aoc->a_vals[0]->bv_val );
|
|
|
|
|
|
|
|
#ifdef NEW_LOGGING
|
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
|
|
|
"entry_schema_check: dn (%s), %s\n",
|
|
|
|
e->e_dn, textbuf ));
|
|
|
|
#else
|
|
|
|
Debug( LDAP_DEBUG_ANY,
|
|
|
|
"entry_check_schema(%s): %s\n",
|
|
|
|
e->e_dn, textbuf, 0 );
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( sc->soc_kind != LDAP_SCHEMA_STRUCTURAL ) {
|
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"structuralObjectClass '%s' is not STRUCTURAL",
|
|
|
|
aoc->a_vals[0]->bv_val );
|
|
|
|
|
|
|
|
#ifdef NEW_LOGGING
|
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
|
|
|
"entry_schema_check: dn (%s), %s\n",
|
|
|
|
e->e_dn, textbuf ));
|
|
|
|
#else
|
|
|
|
Debug( LDAP_DEBUG_ANY,
|
|
|
|
"entry_check_schema(%s): %s\n",
|
|
|
|
e->e_dn, textbuf, 0 );
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find the object class attribute */
|
|
|
|
aoc = attr_find( e->e_attrs, ad_objectClass );
|
|
|
|
if ( aoc == NULL ) {
|
2001-01-16 03:17:29 +08:00
|
|
|
#ifdef NEW_LOGGING
|
2001-01-18 00:35:53 +08:00
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
2001-12-20 06:08:24 +08:00
|
|
|
"entry_schema_check: No objectClass for entry (%s).\n", e->e_dn ));
|
2001-01-16 03:17:29 +08:00
|
|
|
#else
|
2001-01-17 10:51:05 +08:00
|
|
|
Debug( LDAP_DEBUG_ANY, "No objectClass for entry (%s)\n",
|
2000-02-05 13:01:41 +08:00
|
|
|
e->e_dn, 0, 0 );
|
2001-01-16 03:17:29 +08:00
|
|
|
#endif
|
|
|
|
|
2001-01-11 03:00:47 +08:00
|
|
|
*text = "no objectClass attribute";
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
|
2001-12-20 06:08:24 +08:00
|
|
|
assert( aoc->a_vals != NULL );
|
|
|
|
assert( aoc->a_vals[0] != NULL );
|
|
|
|
|
|
|
|
rc = structural_class( aoc->a_vals, &nsc, text );
|
|
|
|
if( rc != LDAP_SUCCESS ) {
|
|
|
|
return rc;
|
|
|
|
} else if ( nsc.bv_len == 0 ) {
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
}
|
|
|
|
|
|
|
|
oc = oc_find( nsc.bv_val );
|
|
|
|
if ( oc == NULL ) {
|
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"unrecognized objectClass '%s'",
|
|
|
|
aoc->a_vals[i]->bv_val );
|
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
|
|
|
|
|
|
|
} else if ( sc != oc ) {
|
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"structuralObjectClass modification from '%s' to '%s' not allowed",
|
|
|
|
asc->a_vals[0]->bv_val, nsc.bv_val );
|
|
|
|
return LDAP_NO_OBJECT_CLASS_MODS;
|
|
|
|
}
|
|
|
|
|
2000-02-05 13:01:41 +08:00
|
|
|
/* check that the entry has required attrs for each oc */
|
|
|
|
for ( i = 0; aoc->a_vals[i] != NULL; i++ ) {
|
|
|
|
if ( (oc = oc_find( aoc->a_vals[i]->bv_val )) == NULL ) {
|
2001-06-06 08:23:56 +08:00
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"unrecognized objectClass '%s'",
|
|
|
|
aoc->a_vals[i]->bv_val );
|
|
|
|
|
2001-01-16 03:17:29 +08:00
|
|
|
#ifdef NEW_LOGGING
|
2001-01-18 00:35:53 +08:00
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
2001-06-06 08:23:56 +08:00
|
|
|
"entry_schema_check: dn (%s), %s\n",
|
|
|
|
e->e_dn, textbuf ));
|
2001-01-16 03:17:29 +08:00
|
|
|
#else
|
2000-02-05 13:01:41 +08:00
|
|
|
Debug( LDAP_DEBUG_ANY,
|
2001-06-06 08:23:56 +08:00
|
|
|
"entry_check_schema(%s): \"%s\" not recognized\n",
|
|
|
|
e->e_dn, textbuf, 0 );
|
2001-01-16 03:17:29 +08:00
|
|
|
#endif
|
|
|
|
|
2001-01-11 03:00:47 +08:00
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
2000-04-25 21:15:55 +08:00
|
|
|
|
2001-12-20 06:08:24 +08:00
|
|
|
} else if ( oc->soc_kind == LDAP_SCHEMA_ABSTRACT ) {
|
|
|
|
/* object class is abstract */
|
|
|
|
/* FIXME: need to check that is is a superclass of something */
|
|
|
|
|
|
|
|
} else if ( oc->soc_kind == LDAP_SCHEMA_STRUCTURAL && oc != sc ) {
|
|
|
|
/* object class is a superclass of the structural class */
|
|
|
|
/* nothing in particular to check */
|
|
|
|
|
2000-04-25 21:15:55 +08:00
|
|
|
} else {
|
2001-12-20 06:08:24 +08:00
|
|
|
char *s = oc_check_required( e, oc, aoc->a_vals[i] );
|
2000-02-05 13:01:41 +08:00
|
|
|
|
|
|
|
if (s != NULL) {
|
2001-06-06 08:23:56 +08:00
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"object class '%s' requires attribute '%s'",
|
|
|
|
aoc->a_vals[i]->bv_val, s );
|
|
|
|
|
2001-01-16 03:17:29 +08:00
|
|
|
#ifdef NEW_LOGGING
|
2001-01-18 00:35:53 +08:00
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
2001-06-06 08:23:56 +08:00
|
|
|
"entry_schema_check: dn=\"%s\" %s",
|
|
|
|
e->e_dn, textbuf ));
|
2001-01-16 03:17:29 +08:00
|
|
|
#else
|
2000-02-05 13:01:41 +08:00
|
|
|
Debug( LDAP_DEBUG_ANY,
|
2001-06-06 08:23:56 +08:00
|
|
|
"Entry (%s): %s\n",
|
|
|
|
e->e_dn, textbuf, 0 );
|
2001-01-16 03:17:29 +08:00
|
|
|
#endif
|
|
|
|
|
2001-01-11 03:00:47 +08:00
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
2000-06-01 02:46:13 +08:00
|
|
|
|
2001-01-11 03:00:47 +08:00
|
|
|
if( oc == slap_schema.si_oc_extensibleObject ) {
|
2000-06-01 02:46:13 +08:00
|
|
|
extensible=1;
|
|
|
|
}
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-06-01 02:46:13 +08:00
|
|
|
if( extensible ) {
|
|
|
|
return LDAP_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2000-02-05 13:01:41 +08:00
|
|
|
/* check that each attr in the entry is allowed by some oc */
|
|
|
|
for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
|
2001-07-24 12:31:01 +08:00
|
|
|
int ret = oc_check_allowed( a->a_desc->ad_type, aoc->a_vals );
|
|
|
|
if ( ret != LDAP_SUCCESS ) {
|
2001-10-22 21:23:05 +08:00
|
|
|
char *type = a->a_desc->ad_cname.bv_val;
|
2001-06-06 08:23:56 +08:00
|
|
|
|
|
|
|
snprintf( textbuf, textlen,
|
|
|
|
"attribute '%s' not allowed",
|
|
|
|
type );
|
|
|
|
|
2001-01-16 03:17:29 +08:00
|
|
|
#ifdef NEW_LOGGING
|
2001-01-18 00:35:53 +08:00
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
|
2001-06-06 08:23:56 +08:00
|
|
|
"entry_schema_check: dn=\"%s\" %s\n",
|
|
|
|
e->e_dn, textbuf ));
|
2001-01-16 03:17:29 +08:00
|
|
|
#else
|
2000-02-05 13:01:41 +08:00
|
|
|
Debug( LDAP_DEBUG_ANY,
|
2001-06-06 08:23:56 +08:00
|
|
|
"Entry (%s), %s\n",
|
|
|
|
e->e_dn, textbuf, 0 );
|
2001-01-16 03:17:29 +08:00
|
|
|
#endif
|
|
|
|
|
2001-07-24 12:31:01 +08:00
|
|
|
return ret;
|
2001-07-24 11:25:17 +08:00
|
|
|
}
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
|
2001-07-24 12:31:01 +08:00
|
|
|
return LDAP_SUCCESS;
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2001-12-20 06:08:24 +08:00
|
|
|
oc_check_required(
|
|
|
|
Entry *e,
|
|
|
|
ObjectClass *oc,
|
|
|
|
struct berval *ocname )
|
2000-02-05 13:01:41 +08:00
|
|
|
{
|
|
|
|
AttributeType *at;
|
|
|
|
int i;
|
|
|
|
Attribute *a;
|
|
|
|
|
2001-01-16 03:17:29 +08:00
|
|
|
#ifdef NEW_LOGGING
|
2001-01-18 00:35:53 +08:00
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
|
2001-12-20 06:08:24 +08:00
|
|
|
"oc_check_required: dn (%s), objectClass \"%s\"\n",
|
|
|
|
e->e_dn, ocname->bv_val ));
|
2001-01-16 03:17:29 +08:00
|
|
|
#else
|
2000-02-05 13:01:41 +08:00
|
|
|
Debug( LDAP_DEBUG_TRACE,
|
2001-12-20 06:08:24 +08:00
|
|
|
"oc_check_required entry (%s), objectClass \"%s\"\n",
|
|
|
|
e->e_dn, ocname->bv_val, 0 );
|
2001-01-16 03:17:29 +08:00
|
|
|
#endif
|
|
|
|
|
2000-02-05 13:01:41 +08:00
|
|
|
|
|
|
|
/* check for empty oc_required */
|
|
|
|
if(oc->soc_required == NULL) {
|
2000-04-25 21:15:55 +08:00
|
|
|
return NULL;
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* for each required attribute */
|
|
|
|
for ( i = 0; oc->soc_required[i] != NULL; i++ ) {
|
|
|
|
at = oc->soc_required[i];
|
|
|
|
/* see if it's in the entry */
|
|
|
|
for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
|
2000-02-29 05:16:05 +08:00
|
|
|
if( a->a_desc->ad_type == at ) {
|
2000-02-05 13:01:41 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* not there => schema violation */
|
|
|
|
if ( a == NULL ) {
|
2001-11-16 15:45:37 +08:00
|
|
|
return at->sat_cname.bv_val;
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return( NULL );
|
|
|
|
}
|
|
|
|
|
2000-05-29 00:36:34 +08:00
|
|
|
int oc_check_allowed(
|
2000-02-07 05:09:44 +08:00
|
|
|
AttributeType *at,
|
|
|
|
struct berval **ocl )
|
2000-02-05 13:01:41 +08:00
|
|
|
{
|
|
|
|
ObjectClass *oc;
|
|
|
|
int i, j;
|
2000-02-07 05:09:44 +08:00
|
|
|
|
2001-01-16 03:17:29 +08:00
|
|
|
#ifdef NEW_LOGGING
|
2001-01-18 00:35:53 +08:00
|
|
|
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
|
2001-12-20 06:08:24 +08:00
|
|
|
"oc_check_allowed: type \"%s\"\n", at->sat_cname.bv_val ));
|
2001-01-16 03:17:29 +08:00
|
|
|
#else
|
2000-02-07 05:09:44 +08:00
|
|
|
Debug( LDAP_DEBUG_TRACE,
|
|
|
|
"oc_check_allowed type \"%s\"\n",
|
2001-11-16 15:45:37 +08:00
|
|
|
at->sat_cname.bv_val, 0, 0 );
|
2001-01-16 03:17:29 +08:00
|
|
|
#endif
|
|
|
|
|
2001-01-17 10:51:05 +08:00
|
|
|
/* always allow objectClass attribute */
|
2001-11-16 15:45:37 +08:00
|
|
|
if ( strcasecmp( at->sat_cname.bv_val, "objectClass" ) == 0 ) {
|
2000-04-25 21:15:55 +08:00
|
|
|
return LDAP_SUCCESS;
|
2000-02-07 05:09:44 +08:00
|
|
|
}
|
|
|
|
|
2000-05-22 11:46:57 +08:00
|
|
|
/*
|
|
|
|
* All operational attributions are allowed by schema rules.
|
|
|
|
*/
|
2000-02-07 05:09:44 +08:00
|
|
|
if( is_at_operational(at) ) {
|
2000-04-25 21:15:55 +08:00
|
|
|
return LDAP_SUCCESS;
|
2000-02-07 05:09:44 +08:00
|
|
|
}
|
2000-02-05 13:01:41 +08:00
|
|
|
|
|
|
|
/* check that the type appears as req or opt in at least one oc */
|
|
|
|
for ( i = 0; ocl[i] != NULL; i++ ) {
|
|
|
|
/* if we know about the oc */
|
|
|
|
if ( (oc = oc_find( ocl[i]->bv_val )) != NULL ) {
|
|
|
|
/* does it require the type? */
|
|
|
|
for ( j = 0; oc->soc_required != NULL &&
|
2000-02-07 05:09:44 +08:00
|
|
|
oc->soc_required[j] != NULL; j++ )
|
|
|
|
{
|
|
|
|
if( at == oc->soc_required[j] ) {
|
2000-04-25 21:15:55 +08:00
|
|
|
return LDAP_SUCCESS;
|
2000-02-07 05:09:44 +08:00
|
|
|
}
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
/* does it allow the type? */
|
|
|
|
for ( j = 0; oc->soc_allowed != NULL &&
|
2000-02-07 05:09:44 +08:00
|
|
|
oc->soc_allowed[j] != NULL; j++ )
|
|
|
|
{
|
|
|
|
if( at == oc->soc_allowed[j] ) {
|
2000-04-25 21:15:55 +08:00
|
|
|
return LDAP_SUCCESS;
|
2000-02-07 05:09:44 +08:00
|
|
|
}
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|
|
|
|
/* maybe the next oc allows it */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* not allowed by any oc */
|
2000-04-25 21:15:55 +08:00
|
|
|
return LDAP_OBJECT_CLASS_VIOLATION;
|
2000-02-05 13:01:41 +08:00
|
|
|
}
|