diff options
Diffstat (limited to '')
| -rw-r--r-- | servers/slapd/oc.c | 940 |
1 files changed, 940 insertions, 0 deletions
diff --git a/servers/slapd/oc.c b/servers/slapd/oc.c new file mode 100644 index 0000000..dc6297e --- /dev/null +++ b/servers/slapd/oc.c @@ -0,0 +1,940 @@ +/* oc.c - object class routines */ +/* $OpenLDAP$ */ +/* This work is part of OpenLDAP Software <http://www.openldap.org/>. + * + * Copyright 1998-2021 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * <http://www.OpenLDAP.org/license.html>. + */ + +#include "portable.h" + +#include <stdio.h> + +#include <ac/ctype.h> +#include <ac/string.h> +#include <ac/socket.h> + +#include "slap.h" + +int is_object_subclass( + ObjectClass *sup, + ObjectClass *sub ) +{ + int i; + + if( sub == NULL || sup == NULL ) return 0; + +#if 0 + Debug( LDAP_DEBUG_TRACE, "is_object_subclass(%s,%s) %d\n", + sup->soc_oid, sub->soc_oid, sup == sub ); +#endif + + if ( sup == sub ) { + return 1; + } + + 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] ) ) { + return 1; + } + } + + return 0; +} + +int is_entry_objectclass( + Entry* e, + ObjectClass *oc, + unsigned flags ) +{ + /* + * set_flags should only be true if oc is one of operational + * object classes which we support objectClass flags for + * (e.g., referral, alias, ...). See <slap.h>. + */ + + Attribute *attr; + struct berval *bv; + + assert( !( e == NULL || oc == NULL ) ); + assert( ( flags & SLAP_OCF_MASK ) != SLAP_OCF_MASK ); + + if ( e == NULL || oc == NULL ) { + return 0; + } + + 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, 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++ ) { + ObjectClass *objectClass = oc_bvfind( bv ); + + if ( objectClass == NULL ) { + /* FIXME: is this acceptable? */ + continue; + } + + 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; +} + + +struct oindexrec { + struct berval oir_name; + ObjectClass *oir_oc; +}; + +static Avlnode *oc_index = NULL; +static Avlnode *oc_cache = NULL; +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, + const void *v_oir2 ) +{ + const struct oindexrec *oir1 = v_oir1, *oir2 = v_oir2; + int i = oir1->oir_name.bv_len - oir2->oir_name.bv_len; + if (i) return i; + return strcasecmp( oir1->oir_name.bv_val, oir2->oir_name.bv_val ); +} + +static int +oc_index_name_cmp( + const void *v_name, + const void *v_oir ) +{ + const struct berval *name = v_name; + const struct oindexrec *oir = v_oir; + int i = name->bv_len - oir->oir_name.bv_len; + if (i) return i; + return strncasecmp( name->bv_val, oir->oir_name.bv_val, name->bv_len ); +} + +ObjectClass * +oc_find( const char *ocname ) +{ + struct berval bv; + + bv.bv_val = (char *)ocname; + bv.bv_len = strlen( ocname ); + + return( oc_bvfind( &bv ) ); +} + +ObjectClass * +oc_bvfind( struct berval *ocname ) +{ + struct oindexrec *oir; + + if ( oc_cache ) { + oir = avl_find( oc_cache, ocname, oc_index_name_cmp ); + if ( oir ) return oir->oir_oc; + } + oir = avl_find( oc_index, ocname, oc_index_name_cmp ); + + if ( oir != NULL ) { + if ( at_oc_cache ) { + avl_insert( &oc_cache, (caddr_t) oir, + oc_index_cmp, avl_dup_error ); + } + return( oir->oir_oc ); + } + + return( NULL ); +} + +static LDAP_STAILQ_HEAD(OCUList, ObjectClass) oc_undef_list + = LDAP_STAILQ_HEAD_INITIALIZER(oc_undef_list); + +ObjectClass * +oc_bvfind_undef( struct berval *ocname ) +{ + ObjectClass *oc = oc_bvfind( ocname ); + + if ( oc ) { + return oc; + } + + LDAP_STAILQ_FOREACH( oc, &oc_undef_list, soc_next ) { + int d = oc->soc_cname.bv_len - ocname->bv_len; + + if ( d ) { + continue; + } + + if ( strcasecmp( oc->soc_cname.bv_val, ocname->bv_val ) == 0 ) { + break; + } + } + + if ( oc ) { + return oc; + } + + oc = ch_malloc( sizeof( ObjectClass ) + ocname->bv_len + 1 ); + memset( oc, 0, sizeof( 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, + int *op, + const char **err ) +{ + char **attrs1; + AttributeType *sat; + AttributeType **satp; + int i; + + if ( attrs ) { + attrs1 = attrs; + while ( *attrs1 ) { + sat = at_find(*attrs1); + if ( !sat ) { + *err = *attrs1; + return SLAP_SCHERR_ATTR_NOT_FOUND; + } + + if( is_at_operational( sat )) (*op)++; + + if ( at_find_in_list(sat, soc->soc_required) < 0) { + if ( at_append_to_list(sat, &soc->soc_required) ) { + *err = *attrs1; + return SLAP_SCHERR_OUTOFMEM; + } + } + attrs1++; + } + /* Now delete duplicates from the allowed list */ + for ( satp = soc->soc_required; *satp; satp++ ) { + i = at_find_in_list(*satp, soc->soc_allowed); + if ( i >= 0 ) { + at_delete_from_list(i, &soc->soc_allowed); + } + } + } + return 0; +} + +static int +oc_create_allowed( + ObjectClass *soc, + char **attrs, + int *op, + const char **err ) +{ + char **attrs1; + AttributeType *sat; + + if ( attrs ) { + attrs1 = attrs; + while ( *attrs1 ) { + sat = at_find(*attrs1); + if ( !sat ) { + *err = *attrs1; + return SLAP_SCHERR_ATTR_NOT_FOUND; + } + + if( is_at_operational( sat )) (*op)++; + + if ( at_find_in_list(sat, soc->soc_required) < 0 && + at_find_in_list(sat, soc->soc_allowed) < 0 ) { + if ( at_append_to_list(sat, &soc->soc_allowed) ) { + *err = *attrs1; + return SLAP_SCHERR_OUTOFMEM; + } + } + attrs1++; + } + } + return 0; +} + +static int +oc_add_sups( + ObjectClass *soc, + char **sups, + int *op, + const char **err ) +{ + int code; + ObjectClass *soc1; + int nsups; + char **sups1; + int add_sups = 0; + + if ( sups ) { + if ( !soc->soc_sups ) { + /* We are at the first recursive level */ + add_sups = 1; + nsups = 1; + sups1 = sups; + while ( *sups1 ) { + nsups++; + sups1++; + } + soc->soc_sups = (ObjectClass **)ch_calloc(nsups, + sizeof(ObjectClass *)); + } + + nsups = 0; + sups1 = sups; + while ( *sups1 ) { + soc1 = oc_find(*sups1); + if ( !soc1 ) { + *err = *sups1; + return SLAP_SCHERR_CLASS_NOT_FOUND; + } + + /* check object class usage + * abstract classes can only sup abstract classes + * structural classes can not sup auxiliary classes + * auxiliary classes can not sup structural classes + */ + if( soc->soc_kind != soc1->soc_kind + && soc1->soc_kind != LDAP_SCHEMA_ABSTRACT ) + { + *err = *sups1; + return SLAP_SCHERR_CLASS_BAD_SUP; + } + + if( soc1->soc_obsolete && !soc->soc_obsolete ) { + *err = *sups1; + return SLAP_SCHERR_CLASS_BAD_SUP; + } + + if( soc->soc_flags & SLAP_OC_OPERATIONAL ) (*op)++; + + if ( add_sups ) { + soc->soc_sups[nsups] = soc1; + } + + code = oc_add_sups( soc, soc1->soc_sup_oids, op, err ); + if ( code ) return code; + + code = oc_create_required( soc, soc1->soc_at_oids_must, op, err ); + if ( code ) return code; + + code = oc_create_allowed( soc, soc1->soc_at_oids_may, op, err ); + if ( code ) return code; + + nsups++; + sups1++; + } + } + + 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; + + while( !LDAP_STAILQ_EMPTY(&oc_list) ) { + o = LDAP_STAILQ_FIRST(&oc_list); + LDAP_STAILQ_REMOVE_HEAD(&oc_list, soc_next); + + 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); + + ch_free( (ObjectClass *)o ); + } +} + +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 + */ +static int +oc_check_dup( + ObjectClass *soc, + ObjectClass *new_soc ) +{ + if ( new_soc->soc_oid != NULL ) { + if ( soc->soc_oid == NULL ) { + return SLAP_SCHERR_CLASS_INCONSISTENT; + } + + if ( strcmp( soc->soc_oid, new_soc->soc_oid ) != 0 ) { + return SLAP_SCHERR_CLASS_INCONSISTENT; + } + + } else { + if ( soc->soc_oid != NULL ) { + return SLAP_SCHERR_CLASS_INCONSISTENT; + } + } + + if ( new_soc->soc_names ) { + int i; + + if ( soc->soc_names == NULL ) { + return SLAP_SCHERR_CLASS_INCONSISTENT; + } + + for ( i = 0; new_soc->soc_names[ i ]; i++ ) { + if ( soc->soc_names[ i ] == NULL ) { + return SLAP_SCHERR_CLASS_INCONSISTENT; + } + + if ( strcasecmp( soc->soc_names[ i ], + new_soc->soc_names[ i ] ) != 0 ) + { + return SLAP_SCHERR_CLASS_INCONSISTENT; + } + } + } else { + if ( soc->soc_names != NULL ) { + return SLAP_SCHERR_CLASS_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 **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) ); + ber_str2bv( soc->soc_oid, 0, 0, &oir->oir_name ); + oir->oir_oc = soc; + oir_old = NULL; + + if ( avl_insert( &oc_index, (caddr_t) oir, + oc_index_cmp, oc_dup_error ) ) + { + ObjectClass *old_soc; + int rc; + + *err = soc->soc_oid; + + 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; + } + } + + /* FIX: temporal consistency check */ + assert( oc_bvfind( &oir->oir_name ) != NULL ); + } + + assert( soc != NULL ); + + if ( (names = soc->soc_names) ) { + while ( *names ) { + oir = (struct oindexrec *) + ch_calloc( 1, sizeof(struct oindexrec) ); + oir->oir_name.bv_val = *names; + oir->oir_name.bv_len = strlen( *names ); + oir->oir_oc = soc; + + if ( avl_insert( &oc_index, (caddr_t) oir, + oc_index_cmp, avl_dup_error ) ) + { + ObjectClass *old_soc; + int rc; + + *err = *names; + + old_soc = oc_bvfind( &oir->oir_name ); + assert( old_soc != NULL ); + 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; + } + + /* FIX: temporal consistency check */ + assert( oc_bvfind(&oir->oir_name) != NULL ); + + names++; + } + } + 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; +} + +int +oc_add( + LDAPObjectClass *oc, + int user, + ObjectClass **rsoc, + ObjectClass *prev, + const char **err ) +{ + ObjectClass *soc; + int code; + int op = 0; + char *oidm = NULL; + + if ( oc->oc_names != NULL ) { + int i; + + for( i=0; oc->oc_names[i]; i++ ) { + if( !slap_valid_descr( oc->oc_names[i] ) ) { + return SLAP_SCHERR_BAD_DESCR; + } + } + } + + if ( !OID_LEADCHAR( oc->oc_oid[0] )) { + /* Expand OID macros */ + char *oid = oidm_find( oc->oc_oid ); + if ( !oid ) { + *err = oc->oc_oid; + return SLAP_SCHERR_OIDM; + } + if ( oid != oc->oc_oid ) { + oidm = oc->oc_oid; + oc->oc_oid = oid; + } + } + + soc = (ObjectClass *) ch_calloc( 1, sizeof(ObjectClass) ); + AC_MEMCPY( &soc->soc_oclass, oc, sizeof(LDAPObjectClass) ); + + soc->soc_oidmacro = oidm; + if( oc->oc_names != NULL ) { + soc->soc_cname.bv_val = soc->soc_names[0]; + } else { + soc->soc_cname.bv_val = soc->soc_oid; + } + soc->soc_cname.bv_len = strlen( soc->soc_cname.bv_val ); + + if( soc->soc_sup_oids == NULL && + soc->soc_kind == LDAP_SCHEMA_STRUCTURAL ) + { + /* structural object classes implicitly inherit from 'top' */ + static char *top_oids[] = { SLAPD_TOP_OID, NULL }; + code = oc_add_sups( soc, top_oids, &op, err ); + } else { + code = oc_add_sups( soc, soc->soc_sup_oids, &op, err ); + } + + 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 ) { + goto done; + } + + code = oc_create_allowed( soc, soc->soc_at_oids_may, &op, err ); + if ( code != 0 ) { + goto done; + } + + if ( user && op ) { + code = SLAP_SCHERR_CLASS_BAD_USAGE; + goto done; + } + + 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 ); + } + + 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; +} + +void +oc_unparse( BerVarray *res, ObjectClass *start, ObjectClass *end, int sys ) +{ + ObjectClass *oc; + int i, num; + struct berval bv, *bva = NULL, idx; + char ibuf[32]; + + if ( !start ) + start = LDAP_STAILQ_FIRST( &oc_list ); + + /* 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)) break; + i++; + if ( oc == end ) break; + } + if (!i) return; + + num = i; + bva = ch_malloc( (num+1) * sizeof(struct berval) ); + BER_BVZERO( bva ); + idx.bv_val = ibuf; + if ( sys ) { + idx.bv_len = 0; + ibuf[0] = '\0'; + } + i = 0; + for ( oc=start; oc; oc=LDAP_STAILQ_NEXT(oc, soc_next)) { + LDAPObjectClass loc, *locp; + if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) break; + if ( oc->soc_oidmacro ) { + loc = oc->soc_oclass; + loc.oc_oid = oc->soc_oidmacro; + locp = &loc; + } else { + locp = &oc->soc_oclass; + } + if ( ldap_objectclass2bv( locp, &bv ) == NULL ) { + ber_bvarray_free( bva ); + } + if ( !sys ) { + idx.bv_len = sprintf(idx.bv_val, "{%d}", i); + } + bva[i].bv_len = idx.bv_len + bv.bv_len; + bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 ); + strcpy( bva[i].bv_val, ibuf ); + strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val ); + i++; + bva[i].bv_val = NULL; + ldap_memfree( bv.bv_val ); + if ( oc == end ) break; + } + *res = bva; +} + +int +oc_schema_info( Entry *e ) +{ + AttributeDescription *ad_objectClasses = slap_schema.si_ad_objectClasses; + ObjectClass *oc; + struct berval val; + struct berval nval; + + LDAP_STAILQ_FOREACH( oc, &oc_list, soc_next ) { + if( oc->soc_flags & SLAP_OC_HIDE ) continue; + + if ( ldap_objectclass2bv( &oc->soc_oclass, &val ) == NULL ) { + return -1; + } + + nval = oc->soc_cname; + +#if 0 + Debug( LDAP_DEBUG_TRACE, "Merging oc [%ld] %s (%s)\n", + (long) val.bv_len, val.bv_val, nval.bv_val ); +#endif + + if( attr_merge_one( e, ad_objectClasses, &val, &nval ) ) { + return -1; + } + ldap_memfree( val.bv_val ); + } + 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; +} |