/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2013 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
sup->soc_oid, sub->soc_oid, sup == sub );
#endif
- if( sup == sub ) {
+ if ( sup == sub ) {
return 1;
}
- if( sub->soc_sups == NULL ) {
+ if ( sub->soc_sups == NULL ) {
return 0;
}
- for( i=0; sub->soc_sups[i] != NULL; i++ ) {
- if( is_object_subclass( sup, sub->soc_sups[i] ) ) {
+ for ( i = 0; sub->soc_sups[i] != NULL; i++ ) {
+ if ( is_object_subclass( sup, sub->soc_sups[i] ) ) {
return 1;
}
}
int is_entry_objectclass(
Entry* e,
ObjectClass *oc,
- int set_flags )
+ unsigned flags )
{
/*
* set_flags should only be true if oc is one of operational
Attribute *attr;
struct berval *bv;
- AttributeDescription *objectClass = slap_schema.si_ad_objectClass;
- assert(!( e == NULL || oc == NULL ));
+ assert( !( e == NULL || oc == NULL ) );
+ assert( ( flags & SLAP_OCF_MASK ) != SLAP_OCF_MASK );
- if( e == NULL || oc == NULL ) {
+ if ( e == NULL || oc == NULL ) {
return 0;
}
- if( set_flags && ( e->e_ocflags & SLAP_OC__END )) {
+ if ( flags == SLAP_OCF_SET_FLAGS && ( e->e_ocflags & SLAP_OC__END ) )
+ {
/* flags are set, use them */
return (e->e_ocflags & oc->soc_flags & SLAP_OC__MASK) != 0;
}
/*
* find objectClass attribute
*/
- attr = attr_find(e->e_attrs, objectClass);
- if( attr == NULL ) {
+ attr = attr_find( e->e_attrs, slap_schema.si_ad_objectClass );
+ if ( attr == NULL ) {
/* no objectClass attribute */
Debug( LDAP_DEBUG_ANY, "is_entry_objectclass(\"%s\", \"%s\") "
"no objectClass attribute\n",
e->e_dn == NULL ? "" : e->e_dn,
oc->soc_oclass.oc_oid, 0 );
+ /* mark flags as set */
+ e->e_ocflags |= SLAP_OC__END;
+
return 0;
}
- for( bv=attr->a_vals; bv->bv_val; bv++ ) {
+ for ( bv = attr->a_vals; bv->bv_val; bv++ ) {
ObjectClass *objectClass = oc_bvfind( bv );
- if ( !set_flags && objectClass == oc ) {
- return 1;
+ if ( objectClass == NULL ) {
+ /* FIXME: is this acceptable? */
+ continue;
}
-
- if ( objectClass != NULL ) {
- e->e_ocflags |= objectClass->soc_flags;
+
+ if ( !( flags & SLAP_OCF_SET_FLAGS ) ) {
+ if ( objectClass == oc ) {
+ return 1;
+ }
+
+ if ( ( flags & SLAP_OCF_CHECK_SUP )
+ && is_object_subclass( oc, objectClass ) )
+ {
+ return 1;
+ }
}
+
+ e->e_ocflags |= objectClass->soc_flags;
}
/* mark flags as set */
e->e_ocflags |= SLAP_OC__END;
- return (e->e_ocflags & oc->soc_flags & SLAP_OC__MASK) != 0;
+ return ( e->e_ocflags & oc->soc_flags & SLAP_OC__MASK ) != 0;
}
static Avlnode *oc_index = NULL;
static Avlnode *oc_cache = NULL;
-static LDAP_STAILQ_HEAD(OCList, slap_object_class) oc_list
+static LDAP_STAILQ_HEAD(OCList, ObjectClass) oc_list
= LDAP_STAILQ_HEAD_INITIALIZER(oc_list);
+ObjectClass *oc_sys_tail;
+
static int
oc_index_cmp(
const void *v_oir1,
return( NULL );
}
-static LDAP_STAILQ_HEAD(OCUList, slap_object_class) oc_undef_list
+static LDAP_STAILQ_HEAD(OCUList, ObjectClass) oc_undef_list
= LDAP_STAILQ_HEAD_INITIALIZER(oc_undef_list);
ObjectClass *
oc->soc_cname.bv_len = ocname->bv_len;
oc->soc_cname.bv_val = (char *)&oc[ 1 ];
AC_MEMCPY( oc->soc_cname.bv_val, ocname->bv_val, ocname->bv_len );
+ oc->soc_cname.bv_val[ oc->soc_cname.bv_len ] = '\0';
+
+ /* canonical to upper case */
+ ldap_pvt_str2upper( oc->soc_cname.bv_val );
LDAP_STAILQ_NEXT( oc, soc_next ) = NULL;
+ ldap_pvt_thread_mutex_lock( &oc_undef_mutex );
LDAP_STAILQ_INSERT_HEAD( &oc_undef_list, oc, soc_next );
+ ldap_pvt_thread_mutex_unlock( &oc_undef_mutex );
return oc;
}
static int
oc_create_required(
- ObjectClass *soc,
- char **attrs,
+ ObjectClass *soc,
+ char **attrs,
int *op,
- const char **err )
+ const char **err )
{
char **attrs1;
AttributeType *sat;
}
/* Now delete duplicates from the allowed list */
for ( satp = soc->soc_required; *satp; satp++ ) {
- i = at_find_in_list(*satp,soc->soc_allowed);
+ i = at_find_in_list(*satp, soc->soc_allowed);
if ( i >= 0 ) {
at_delete_from_list(i, &soc->soc_allowed);
}
static int
oc_add_sups(
- ObjectClass *soc,
- char **sups,
+ ObjectClass *soc,
+ char **sups,
int *op,
- const char **err )
+ const char **err )
{
int code;
ObjectClass *soc1;
return 0;
}
+static void
+oc_delete_names( ObjectClass *oc )
+{
+ char **names = oc->soc_names;
+
+ if (!names) return;
+
+ while (*names) {
+ struct oindexrec tmpoir, *oir;
+
+ ber_str2bv( *names, 0, 0, &tmpoir.oir_name );
+ tmpoir.oir_oc = oc;
+ oir = (struct oindexrec *)avl_delete( &oc_index,
+ (caddr_t)&tmpoir, oc_index_cmp );
+ assert( oir != NULL );
+ ldap_memfree( oir );
+ names++;
+ }
+}
+
+/* Mark the ObjectClass as deleted, remove from list, and remove all its
+ * names from the AVL tree. Leave the OID in the tree.
+ */
+void
+oc_delete( ObjectClass *oc )
+{
+ oc->soc_flags |= SLAP_OC_DELETED;
+
+ LDAP_STAILQ_REMOVE(&oc_list, oc, ObjectClass, soc_next);
+
+ oc_delete_names( oc );
+}
+
+static void
+oc_clean( ObjectClass *o )
+{
+ if (o->soc_sups) {
+ ldap_memfree(o->soc_sups);
+ o->soc_sups = NULL;
+ }
+ if (o->soc_required) {
+ ldap_memfree(o->soc_required);
+ o->soc_required = NULL;
+ }
+ if (o->soc_allowed) {
+ ldap_memfree(o->soc_allowed);
+ o->soc_allowed = NULL;
+ }
+ if (o->soc_oidmacro) {
+ ldap_memfree(o->soc_oidmacro);
+ o->soc_oidmacro = NULL;
+ }
+}
+
+static void
+oc_destroy_one( void *v )
+{
+ struct oindexrec *oir = v;
+ ObjectClass *o = oir->oir_oc;
+
+ oc_clean( o );
+ ldap_objectclass_free((LDAPObjectClass *)o);
+ ldap_memfree(oir);
+}
+
void
oc_destroy( void )
{
ObjectClass *o;
- avl_free(oc_index, ldap_memfree);
while( !LDAP_STAILQ_EMPTY(&oc_list) ) {
o = LDAP_STAILQ_FIRST(&oc_list);
LDAP_STAILQ_REMOVE_HEAD(&oc_list, soc_next);
- if (o->soc_sups) ldap_memfree(o->soc_sups);
- if (o->soc_required) ldap_memfree(o->soc_required);
- if (o->soc_allowed) ldap_memfree(o->soc_allowed);
- if (o->soc_oidmacro) ldap_memfree(o->soc_oidmacro);
- ldap_objectclass_free((LDAPObjectClass *)o);
+ oc_delete_names( o );
}
+ avl_free( oc_index, oc_destroy_one );
+
while( !LDAP_STAILQ_EMPTY(&oc_undef_list) ) {
o = LDAP_STAILQ_FIRST(&oc_undef_list);
LDAP_STAILQ_REMOVE_HEAD(&oc_undef_list, soc_next);
}
}
+int
+oc_start( ObjectClass **oc )
+{
+ assert( oc != NULL );
+
+ *oc = LDAP_STAILQ_FIRST(&oc_list);
+
+ return (*oc != NULL);
+}
+
+int
+oc_next( ObjectClass **oc )
+{
+ assert( oc != NULL );
+
+#if 0 /* pedantic check: breaks when deleting an oc, don't use it. */
+ {
+ ObjectClass *tmp = NULL;
+
+ LDAP_STAILQ_FOREACH(tmp,&oc_list,soc_next) {
+ if ( tmp == *oc ) {
+ break;
+ }
+ }
+
+ assert( tmp != NULL );
+ }
+#endif
+
+ if ( *oc == NULL ) {
+ return 0;
+ }
+
+ *oc = LDAP_STAILQ_NEXT(*oc,soc_next);
+
+ return (*oc != NULL);
+}
+
/*
* check whether the two ObjectClasses actually __are__ identical,
* or rather inconsistent
return SLAP_SCHERR_CLASS_DUP;
}
+static struct oindexrec *oir_old;
+
+static int
+oc_dup_error( void *left, void *right )
+{
+ oir_old = left;
+ return -1;
+}
+
static int
oc_insert(
- ObjectClass *soc,
+ ObjectClass **roc,
+ ObjectClass *prev,
const char **err )
{
struct oindexrec *oir;
char **names;
+ ObjectClass *soc = *roc;
if ( soc->soc_oid ) {
oir = (struct oindexrec *)
ch_calloc( 1, sizeof(struct oindexrec) );
- oir->oir_name.bv_val = soc->soc_oid;
- oir->oir_name.bv_len = strlen( soc->soc_oid );
+ ber_str2bv( soc->soc_oid, 0, 0, &oir->oir_name );
oir->oir_oc = soc;
-
- assert( oir->oir_name.bv_val != NULL );
- assert( oir->oir_oc != NULL );
+ oir_old = NULL;
if ( avl_insert( &oc_index, (caddr_t) oir,
- oc_index_cmp, avl_dup_error ) )
+ oc_index_cmp, oc_dup_error ) )
{
ObjectClass *old_soc;
int rc;
*err = soc->soc_oid;
- old_soc = oc_bvfind( &oir->oir_name );
- assert( old_soc != NULL );
- rc = oc_check_dup( old_soc, soc );
+ assert( oir_old != NULL );
+ old_soc = oir_old->oir_oc;
+
+ /* replacing a deleted definition? */
+ if ( old_soc->soc_flags & SLAP_OC_DELETED ) {
+ ObjectClass tmp;
+
+ /* Keep old oid, free new oid;
+ * Keep new everything else, free old
+ */
+ tmp = *old_soc;
+ *old_soc = *soc;
+ old_soc->soc_oid = tmp.soc_oid;
+ tmp.soc_oid = soc->soc_oid;
+ *soc = tmp;
+
+ oc_clean( soc );
+ oc_destroy_one( oir );
+
+ oir = oir_old;
+ soc = old_soc;
+ *roc = soc;
+ } else {
+ rc = oc_check_dup( old_soc, soc );
- ldap_memfree( oir );
- return rc;
+ ldap_memfree( oir );
+ return rc;
+ }
}
/* FIX: temporal consistency check */
assert( oc_bvfind( &oir->oir_name ) != NULL );
}
+ assert( soc != NULL );
+
if ( (names = soc->soc_names) ) {
while ( *names ) {
oir = (struct oindexrec *)
oir->oir_name.bv_len = strlen( *names );
oir->oir_oc = soc;
- assert( oir->oir_name.bv_val != NULL );
- assert( oir->oir_oc != NULL );
-
if ( avl_insert( &oc_index, (caddr_t) oir,
oc_index_cmp, avl_dup_error ) )
{
rc = oc_check_dup( old_soc, soc );
ldap_memfree( oir );
+
+ while ( names > soc->soc_names ) {
+ struct oindexrec tmpoir;
+
+ names--;
+ ber_str2bv( *names, 0, 0, &tmpoir.oir_name );
+ tmpoir.oir_oc = soc;
+ oir = (struct oindexrec *)avl_delete( &oc_index,
+ (caddr_t)&tmpoir, oc_index_cmp );
+ assert( oir != NULL );
+ ldap_memfree( oir );
+ }
+
+ if ( soc->soc_oid ) {
+ struct oindexrec tmpoir;
+
+ ber_str2bv( soc->soc_oid, 0, 0, &tmpoir.oir_name );
+ tmpoir.oir_oc = soc;
+ oir = (struct oindexrec *)avl_delete( &oc_index,
+ (caddr_t)&tmpoir, oc_index_cmp );
+ assert( oir != NULL );
+ ldap_memfree( oir );
+ }
+
return rc;
}
names++;
}
}
- LDAP_STAILQ_INSERT_TAIL( &oc_list, soc, soc_next );
+ if ( soc->soc_flags & SLAP_OC_HARDCODE ) {
+ prev = oc_sys_tail;
+ oc_sys_tail = soc;
+ }
+ if ( prev ) {
+ LDAP_STAILQ_INSERT_AFTER( &oc_list, prev, soc, soc_next );
+ } else {
+ LDAP_STAILQ_INSERT_TAIL( &oc_list, soc, soc_next );
+ }
return 0;
}
LDAPObjectClass *oc,
int user,
ObjectClass **rsoc,
+ ObjectClass *prev,
const char **err )
{
ObjectClass *soc;
code = oc_add_sups( soc, soc->soc_sup_oids, &op, err );
}
- if ( code != 0 ) return code;
- if( user && op ) return SLAP_SCHERR_CLASS_BAD_SUP;
+ if ( code != 0 ) {
+ goto done;
+ }
+
+ if ( user && op ) {
+ code = SLAP_SCHERR_CLASS_BAD_SUP;
+ goto done;
+ }
code = oc_create_required( soc, soc->soc_at_oids_must, &op, err );
- if ( code != 0 ) return code;
+ if ( code != 0 ) {
+ goto done;
+ }
code = oc_create_allowed( soc, soc->soc_at_oids_may, &op, err );
- if ( code != 0 ) return code;
+ if ( code != 0 ) {
+ goto done;
+ }
- if( user && op ) return SLAP_SCHERR_CLASS_BAD_USAGE;
+ if ( user && op ) {
+ code = SLAP_SCHERR_CLASS_BAD_USAGE;
+ goto done;
+ }
+
+ if ( !user ) {
+ soc->soc_flags |= SLAP_OC_HARDCODE;
+ }
- if( !user ) soc->soc_flags |= SLAP_OC_HARDCODE;
+ code = oc_insert(&soc,prev,err);
+done:;
+ if ( code != 0 ) {
+ if ( soc->soc_sups ) {
+ ch_free( soc->soc_sups );
+ }
- code = oc_insert(soc,err);
- if ( code == 0 && rsoc )
+ if ( soc->soc_required ) {
+ ch_free( soc->soc_required );
+ }
+
+ if ( soc->soc_allowed ) {
+ ch_free( soc->soc_allowed );
+ }
+
+ if ( soc->soc_oidmacro ) {
+ ch_free( soc->soc_oidmacro );
+ }
+
+ ch_free( soc );
+
+ } else if ( rsoc ) {
*rsoc = soc;
+ }
return code;
}
/* count the result size */
i = 0;
for ( oc=start; oc; oc=LDAP_STAILQ_NEXT(oc, soc_next)) {
- if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) continue;
+ if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) break;
i++;
if ( oc == end ) break;
}
i = 0;
for ( oc=start; oc; oc=LDAP_STAILQ_NEXT(oc, soc_next)) {
LDAPObjectClass loc, *locp;
- if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) continue;
+ if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) break;
if ( oc->soc_oidmacro ) {
loc = oc->soc_oclass;
loc.oc_oid = oc->soc_oidmacro;
}
return 0;
}
+
+int
+register_oc( const char *def, ObjectClass **soc, int dupok )
+{
+ LDAPObjectClass *oc;
+ int code;
+ const char *err;
+
+ oc = ldap_str2objectclass( def, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
+ if ( !oc ) {
+ Debug( LDAP_DEBUG_ANY,
+ "register_oc: objectclass \"%s\": %s, %s\n",
+ def, ldap_scherr2str(code), err );
+ return code;
+ }
+ code = oc_add(oc,0,NULL,NULL,&err);
+ if ( code && ( code != SLAP_SCHERR_CLASS_DUP || !dupok )) {
+ Debug( LDAP_DEBUG_ANY,
+ "register_oc: objectclass \"%s\": %s, %s\n",
+ def, scherr2str(code), err );
+ ldap_objectclass_free(oc);
+ return code;
+ }
+ if ( soc )
+ *soc = oc_find(oc->oc_names[0]);
+ if ( code ) {
+ ldap_objectclass_free(oc);
+ } else {
+ ldap_memfree(oc);
+ }
+ return 0;
+}
projects / openldap / blobdiff