X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Foc.c;h=3ba9501db39cea3f71c32f17f830b25ba21cf897;hb=e841247c9086053d774d66e4fbb058d0ead706b2;hp=d4e970d394acf2ef94e25f8e463b4e1d58c63ab8;hpb=5342ce61dd287cc486d8492e315003cb322090c9;p=openldap

diff --git a/servers/slapd/oc.c b/servers/slapd/oc.c
index d4e970d394..3ba9501db3 100644
--- a/servers/slapd/oc.c
+++ b/servers/slapd/oc.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2006 The OpenLDAP Foundation.
+ * Copyright 1998-2009 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,16 +37,16 @@ int is_object_subclass(
 		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;
 		}
 	}
@@ -71,11 +71,11 @@ int is_entry_objectclass(
 	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( flags == SLAP_OCF_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;
@@ -85,17 +85,20 @@ int is_entry_objectclass(
 	 * find objectClass attribute
 	 */
 	attr = attr_find( e->e_attrs, slap_schema.si_ad_objectClass );
-	if( attr == NULL ) {
+	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 ( objectClass == NULL ) {
@@ -132,9 +135,11 @@ struct oindexrec {
 
 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,
@@ -191,7 +196,7 @@ oc_bvfind( struct berval *ocname )
 	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 *
@@ -225,6 +230,10 @@ oc_bvfind_undef( struct berval *ocname )
 	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 );
@@ -386,23 +395,83 @@ oc_add_sups(
 	return 0;
 }
 
+static void
+oc_delete_names( ObjectClass *oc )
+{
+	char			**names = oc->soc_names;
+
+	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);
@@ -411,6 +480,44 @@ oc_destroy( void )
 	}
 }
 
+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
@@ -462,38 +569,68 @@ oc_check_dup(
 	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 */
@@ -557,7 +694,15 @@ oc_insert(
 			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;
 }
@@ -567,6 +712,7 @@ oc_add(
     LDAPObjectClass	*oc,
 	int user,
 	ObjectClass		**rsoc,
+	ObjectClass		*prev,
     const char		**err )
 {
 	ObjectClass	*soc;
@@ -646,7 +792,7 @@ oc_add(
 		soc->soc_flags |= SLAP_OC_HARDCODE;
 	}
 
-	code = oc_insert(soc,err);
+	code = oc_insert(&soc,prev,err);
 done:;
 	if ( code != 0 ) {
 		if ( soc->soc_sups ) {
@@ -683,7 +829,7 @@ oc_unparse( BerVarray *res, ObjectClass *start, ObjectClass *end, int sys )
 	/* 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;
 	}
@@ -700,7 +846,7 @@ oc_unparse( BerVarray *res, ObjectClass *start, ObjectClass *end, int sys )
 	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;
@@ -757,7 +903,7 @@ oc_schema_info( Entry *e )
 }
 
 int
-register_oc( char *def, ObjectClass **soc, int dupok )
+register_oc( const char *def, ObjectClass **soc, int dupok )
 {
 	LDAPObjectClass *oc;
 	int code;
@@ -770,7 +916,7 @@ register_oc( char *def, ObjectClass **soc, int dupok )
 			def, ldap_scherr2str(code), err );
 		return code;
 	}
-	code = oc_add(oc,0,NULL,&err);
+	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",
@@ -778,7 +924,8 @@ register_oc( char *def, ObjectClass **soc, int dupok )
 		ldap_objectclass_free(oc);
 		return code;
 	}
-	*soc = oc_find(oc->oc_names[0]);
+	if ( soc )
+		*soc = oc_find(oc->oc_names[0]);
 	if ( code ) {
 		ldap_objectclass_free(oc);
 	} else {