git.sur5r.net Git - openldap/blob - servers/slapd/oc.c

   1 /* oc.c - object class routines */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2006 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20
  21 #include <ac/ctype.h>
  22 #include <ac/string.h>
  23 #include <ac/socket.h>
  24
  25 #include "slap.h"
  26
  27 int is_object_subclass(
  28         ObjectClass *sup,
  29         ObjectClass *sub )
  30 {
  31         int i;
  32
  33         if( sub == NULL || sup == NULL ) return 0;
  34
  35 #if 0
  36         Debug( LDAP_DEBUG_TRACE, "is_object_subclass(%s,%s) %d\n",
  37                 sup->soc_oid, sub->soc_oid, sup == sub );
  38 #endif
  39
  40         if( sup == sub ) {
  41                 return 1;
  42         }
  43
  44         if( sub->soc_sups == NULL ) {
  45                 return 0;
  46         }
  47
  48         for( i=0; sub->soc_sups[i] != NULL; i++ ) {
  49                 if( is_object_subclass( sup, sub->soc_sups[i] ) ) {
  50                         return 1;
  51                 }
  52         }
  53
  54         return 0;
  55 }
  56
  57 int is_entry_objectclass(
  58         Entry*  e,
  59         ObjectClass *oc,
  60         unsigned flags )
  61 {
  62         /*
  63          * set_flags should only be true if oc is one of operational
  64          * object classes which we support objectClass flags for
  65          * (e.g., referral, alias, ...).  See <slap.h>.
  66          */
  67
  68         Attribute *attr;
  69         struct berval *bv;
  70
  71         assert( !( e == NULL || oc == NULL ) );
  72         assert( ( flags & SLAP_OCF_MASK ) != SLAP_OCF_MASK );
  73
  74         if( e == NULL || oc == NULL ) {
  75                 return 0;
  76         }
  77
  78         if( flags == SLAP_OCF_SET_FLAGS && ( e->e_ocflags & SLAP_OC__END ) )
  79         {
  80                 /* flags are set, use them */
  81                 return (e->e_ocflags & oc->soc_flags & SLAP_OC__MASK) != 0;
  82         }
  83
  84         /*
  85          * find objectClass attribute
  86          */
  87         attr = attr_find( e->e_attrs, slap_schema.si_ad_objectClass );
  88         if( attr == NULL ) {
  89                 /* no objectClass attribute */
  90                 Debug( LDAP_DEBUG_ANY, "is_entry_objectclass(\"%s\", \"%s\") "
  91                         "no objectClass attribute\n",
  92                         e->e_dn == NULL ? "" : e->e_dn,
  93                         oc->soc_oclass.oc_oid, 0 );
  94
  95                 return 0;
  96         }
  97
  98         for( bv=attr->a_vals; bv->bv_val; bv++ ) {
  99                 ObjectClass *objectClass = oc_bvfind( bv );
 100
 101                 if ( objectClass == NULL ) {
 102                         /* FIXME: is this acceptable? */
 103                         continue;
 104                 }
 105
 106                 if ( !( flags & SLAP_OCF_SET_FLAGS ) ) {
 107                         if ( objectClass == oc ) {
 108                                 return 1;
 109                         }
 110
 111                         if ( ( flags & SLAP_OCF_CHECK_SUP )
 112                                 && is_object_subclass( oc, objectClass ) )
 113                         {
 114                                 return 1;
 115                         }
 116                 }
 117
 118                 e->e_ocflags |= objectClass->soc_flags;
 119         }
 120
 121         /* mark flags as set */
 122         e->e_ocflags |= SLAP_OC__END;
 123
 124         return ( e->e_ocflags & oc->soc_flags & SLAP_OC__MASK ) != 0;
 125 }
 126
 127
 128 struct oindexrec {
 129         struct berval oir_name;
 130         ObjectClass     *oir_oc;
 131 };
 132
 133 static Avlnode  *oc_index = NULL;
 134 static Avlnode  *oc_cache = NULL;
 135 static LDAP_STAILQ_HEAD(OCList, slap_object_class) oc_list
 136         = LDAP_STAILQ_HEAD_INITIALIZER(oc_list);
 137
 138 static int
 139 oc_index_cmp(
 140         const void *v_oir1,
 141         const void *v_oir2 )
 142 {
 143         const struct oindexrec *oir1 = v_oir1, *oir2 = v_oir2;
 144         int i = oir1->oir_name.bv_len - oir2->oir_name.bv_len;
 145         if (i) return i;
 146         return strcasecmp( oir1->oir_name.bv_val, oir2->oir_name.bv_val );
 147 }
 148
 149 static int
 150 oc_index_name_cmp(
 151         const void *v_name,
 152         const void *v_oir )
 153 {
 154         const struct berval    *name = v_name;
 155         const struct oindexrec *oir  = v_oir;
 156         int i = name->bv_len - oir->oir_name.bv_len;
 157         if (i) return i;
 158         return strncasecmp( name->bv_val, oir->oir_name.bv_val, name->bv_len );
 159 }
 160
 161 ObjectClass *
 162 oc_find( const char *ocname )
 163 {
 164         struct berval bv;
 165
 166         bv.bv_val = (char *)ocname;
 167         bv.bv_len = strlen( ocname );
 168
 169         return( oc_bvfind( &bv ) );
 170 }
 171
 172 ObjectClass *
 173 oc_bvfind( struct berval *ocname )
 174 {
 175         struct oindexrec        *oir;
 176
 177         if ( oc_cache ) {
 178                 oir = avl_find( oc_cache, ocname, oc_index_name_cmp );
 179                 if ( oir ) return oir->oir_oc;
 180         }
 181         oir = avl_find( oc_index, ocname, oc_index_name_cmp );
 182
 183         if ( oir != NULL ) {
 184                 if ( at_oc_cache ) {
 185                         avl_insert( &oc_cache, (caddr_t) oir,
 186                                 oc_index_cmp, avl_dup_error );
 187                 }
 188                 return( oir->oir_oc );
 189         }
 190
 191         return( NULL );
 192 }
 193
 194 static LDAP_STAILQ_HEAD(OCUList, slap_object_class) oc_undef_list
 195         = LDAP_STAILQ_HEAD_INITIALIZER(oc_undef_list);
 196
 197 ObjectClass *
 198 oc_bvfind_undef( struct berval *ocname )
 199 {
 200         ObjectClass     *oc = oc_bvfind( ocname );
 201
 202         if ( oc ) {
 203                 return oc;
 204         }
 205
 206         LDAP_STAILQ_FOREACH( oc, &oc_undef_list, soc_next ) {
 207                 int     d = oc->soc_cname.bv_len - ocname->bv_len;
 208
 209                 if ( d ) {
 210                         continue;
 211                 }
 212
 213                 if ( strcasecmp( oc->soc_cname.bv_val, ocname->bv_val ) == 0 ) {
 214                         break;
 215                 }
 216         }
 217
 218         if ( oc ) {
 219                 return oc;
 220         }
 221
 222         oc = ch_malloc( sizeof( ObjectClass ) + ocname->bv_len + 1 );
 223         memset( oc, 0, sizeof( ObjectClass ) );
 224
 225         oc->soc_cname.bv_len = ocname->bv_len;
 226         oc->soc_cname.bv_val = (char *)&oc[ 1 ];
 227         AC_MEMCPY( oc->soc_cname.bv_val, ocname->bv_val, ocname->bv_len );
 228
 229         LDAP_STAILQ_NEXT( oc, soc_next ) = NULL;
 230         ldap_pvt_thread_mutex_lock( &oc_undef_mutex );
 231         LDAP_STAILQ_INSERT_HEAD( &oc_undef_list, oc, soc_next );
 232         ldap_pvt_thread_mutex_unlock( &oc_undef_mutex );
 233
 234         return oc;
 235 }
 236
 237 static int
 238 oc_create_required(
 239         ObjectClass             *soc,
 240         char                    **attrs,
 241         int                     *op,
 242         const char              **err )
 243 {
 244         char            **attrs1;
 245         AttributeType   *sat;
 246         AttributeType   **satp;
 247         int             i;
 248
 249         if ( attrs ) {
 250                 attrs1 = attrs;
 251                 while ( *attrs1 ) {
 252                         sat = at_find(*attrs1);
 253                         if ( !sat ) {
 254                                 *err = *attrs1;
 255                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
 256                         }
 257
 258                         if( is_at_operational( sat )) (*op)++;
 259
 260                         if ( at_find_in_list(sat, soc->soc_required) < 0) {
 261                                 if ( at_append_to_list(sat, &soc->soc_required) ) {
 262                                         *err = *attrs1;
 263                                         return SLAP_SCHERR_OUTOFMEM;
 264                                 }
 265                         }
 266                         attrs1++;
 267                 }
 268                 /* Now delete duplicates from the allowed list */
 269                 for ( satp = soc->soc_required; *satp; satp++ ) {
 270                         i = at_find_in_list(*satp, soc->soc_allowed);
 271                         if ( i >= 0 ) {
 272                                 at_delete_from_list(i, &soc->soc_allowed);
 273                         }
 274                 }
 275         }
 276         return 0;
 277 }
 278
 279 static int
 280 oc_create_allowed(
 281     ObjectClass         *soc,
 282     char                **attrs,
 283         int                     *op,
 284     const char          **err )
 285 {
 286         char            **attrs1;
 287         AttributeType   *sat;
 288
 289         if ( attrs ) {
 290                 attrs1 = attrs;
 291                 while ( *attrs1 ) {
 292                         sat = at_find(*attrs1);
 293                         if ( !sat ) {
 294                                 *err = *attrs1;
 295                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
 296                         }
 297
 298                         if( is_at_operational( sat )) (*op)++;
 299
 300                         if ( at_find_in_list(sat, soc->soc_required) < 0 &&
 301                              at_find_in_list(sat, soc->soc_allowed) < 0 ) {
 302                                 if ( at_append_to_list(sat, &soc->soc_allowed) ) {
 303                                         *err = *attrs1;
 304                                         return SLAP_SCHERR_OUTOFMEM;
 305                                 }
 306                         }
 307                         attrs1++;
 308                 }
 309         }
 310         return 0;
 311 }
 312
 313 static int
 314 oc_add_sups(
 315         ObjectClass             *soc,
 316         char                    **sups,
 317         int                     *op,
 318         const char              **err )
 319 {
 320         int             code;
 321         ObjectClass     *soc1;
 322         int             nsups;
 323         char    **sups1;
 324         int             add_sups = 0;
 325
 326         if ( sups ) {
 327                 if ( !soc->soc_sups ) {
 328                         /* We are at the first recursive level */
 329                         add_sups = 1;
 330                         nsups = 1;
 331                         sups1 = sups;
 332                         while ( *sups1 ) {
 333                                 nsups++;
 334                                 sups1++;
 335                         }
 336                         soc->soc_sups = (ObjectClass **)ch_calloc(nsups,
 337                                           sizeof(ObjectClass *));
 338                 }
 339
 340                 nsups = 0;
 341                 sups1 = sups;
 342                 while ( *sups1 ) {
 343                         soc1 = oc_find(*sups1);
 344                         if ( !soc1 ) {
 345                                 *err = *sups1;
 346                                 return SLAP_SCHERR_CLASS_NOT_FOUND;
 347                         }
 348
 349                         /* check object class usage
 350                          * abstract classes can only sup abstract classes
 351                          * structural classes can not sup auxiliary classes
 352                          * auxiliary classes can not sup structural classes
 353                          */
 354                         if( soc->soc_kind != soc1->soc_kind
 355                                 && soc1->soc_kind != LDAP_SCHEMA_ABSTRACT )
 356                         {
 357                                 *err = *sups1;
 358                                 return SLAP_SCHERR_CLASS_BAD_SUP;
 359                         }
 360
 361                         if( soc1->soc_obsolete && !soc->soc_obsolete ) {
 362                                 *err = *sups1;
 363                                 return SLAP_SCHERR_CLASS_BAD_SUP;
 364                         }
 365
 366                         if( soc->soc_flags & SLAP_OC_OPERATIONAL ) (*op)++;
 367
 368                         if ( add_sups ) {
 369                                 soc->soc_sups[nsups] = soc1;
 370                         }
 371
 372                         code = oc_add_sups( soc, soc1->soc_sup_oids, op, err );
 373                         if ( code ) return code;
 374
 375                         code = oc_create_required( soc, soc1->soc_at_oids_must, op, err );
 376                         if ( code ) return code;
 377
 378                         code = oc_create_allowed( soc, soc1->soc_at_oids_may, op, err );
 379                         if ( code ) return code;
 380
 381                         nsups++;
 382                         sups1++;
 383                 }
 384         }
 385
 386         return 0;
 387 }
 388
 389 void
 390 oc_destroy( void )
 391 {
 392         ObjectClass *o;
 393
 394         avl_free(oc_index, ldap_memfree);
 395         while( !LDAP_STAILQ_EMPTY(&oc_list) ) {
 396                 o = LDAP_STAILQ_FIRST(&oc_list);
 397                 LDAP_STAILQ_REMOVE_HEAD(&oc_list, soc_next);
 398
 399                 if (o->soc_sups) ldap_memfree(o->soc_sups);
 400                 if (o->soc_required) ldap_memfree(o->soc_required);
 401                 if (o->soc_allowed) ldap_memfree(o->soc_allowed);
 402                 if (o->soc_oidmacro) ldap_memfree(o->soc_oidmacro);
 403                 ldap_objectclass_free((LDAPObjectClass *)o);
 404         }
 405
 406         while( !LDAP_STAILQ_EMPTY(&oc_undef_list) ) {
 407                 o = LDAP_STAILQ_FIRST(&oc_undef_list);
 408                 LDAP_STAILQ_REMOVE_HEAD(&oc_undef_list, soc_next);
 409
 410                 ch_free( (ObjectClass *)o );
 411         }
 412 }
 413
 414 /*
 415  * check whether the two ObjectClasses actually __are__ identical,
 416  * or rather inconsistent
 417  */
 418 static int
 419 oc_check_dup(
 420         ObjectClass     *soc,
 421         ObjectClass     *new_soc )
 422 {
 423         if ( new_soc->soc_oid != NULL ) {
 424                 if ( soc->soc_oid == NULL ) {
 425                         return SLAP_SCHERR_CLASS_INCONSISTENT;
 426                 }
 427
 428                 if ( strcmp( soc->soc_oid, new_soc->soc_oid ) != 0 ) {
 429                         return SLAP_SCHERR_CLASS_INCONSISTENT;
 430                 }
 431
 432         } else {
 433                 if ( soc->soc_oid != NULL ) {
 434                         return SLAP_SCHERR_CLASS_INCONSISTENT;
 435                 }
 436         }
 437
 438         if ( new_soc->soc_names ) {
 439                 int     i;
 440
 441                 if ( soc->soc_names == NULL ) {
 442                         return SLAP_SCHERR_CLASS_INCONSISTENT;
 443                 }
 444
 445                 for ( i = 0; new_soc->soc_names[ i ]; i++ ) {
 446                         if ( soc->soc_names[ i ] == NULL ) {
 447                                 return SLAP_SCHERR_CLASS_INCONSISTENT;
 448                         }
 449
 450                         if ( strcasecmp( soc->soc_names[ i ],
 451                                         new_soc->soc_names[ i ] ) != 0 )
 452                         {
 453                                 return SLAP_SCHERR_CLASS_INCONSISTENT;
 454                         }
 455                 }
 456         } else {
 457                 if ( soc->soc_names != NULL ) {
 458                         return SLAP_SCHERR_CLASS_INCONSISTENT;
 459                 }
 460         }
 461
 462         return SLAP_SCHERR_CLASS_DUP;
 463 }
 464
 465 static int
 466 oc_insert(
 467     ObjectClass         *soc,
 468     const char          **err )
 469 {
 470         struct oindexrec        *oir;
 471         char                    **names;
 472
 473         if ( soc->soc_oid ) {
 474                 oir = (struct oindexrec *)
 475                         ch_calloc( 1, sizeof(struct oindexrec) );
 476                 oir->oir_name.bv_val = soc->soc_oid;
 477                 oir->oir_name.bv_len = strlen( soc->soc_oid );
 478                 oir->oir_oc = soc;
 479
 480                 assert( oir->oir_name.bv_val != NULL );
 481                 assert( oir->oir_oc != NULL );
 482
 483                 if ( avl_insert( &oc_index, (caddr_t) oir,
 484                         oc_index_cmp, avl_dup_error ) )
 485                 {
 486                         ObjectClass     *old_soc;
 487                         int             rc;
 488
 489                         *err = soc->soc_oid;
 490
 491                         old_soc = oc_bvfind( &oir->oir_name );
 492                         assert( old_soc != NULL );
 493                         rc = oc_check_dup( old_soc, soc );
 494
 495                         ldap_memfree( oir );
 496                         return rc;
 497                 }
 498
 499                 /* FIX: temporal consistency check */
 500                 assert( oc_bvfind( &oir->oir_name ) != NULL );
 501         }
 502
 503         if ( (names = soc->soc_names) ) {
 504                 while ( *names ) {
 505                         oir = (struct oindexrec *)
 506                                 ch_calloc( 1, sizeof(struct oindexrec) );
 507                         oir->oir_name.bv_val = *names;
 508                         oir->oir_name.bv_len = strlen( *names );
 509                         oir->oir_oc = soc;
 510
 511                         assert( oir->oir_name.bv_val != NULL );
 512                         assert( oir->oir_oc != NULL );
 513
 514                         if ( avl_insert( &oc_index, (caddr_t) oir,
 515                                 oc_index_cmp, avl_dup_error ) )
 516                         {
 517                                 ObjectClass     *old_soc;
 518                                 int             rc;
 519
 520                                 *err = *names;
 521
 522                                 old_soc = oc_bvfind( &oir->oir_name );
 523                                 assert( old_soc != NULL );
 524                                 rc = oc_check_dup( old_soc, soc );
 525
 526                                 ldap_memfree( oir );
 527
 528                                 while ( names > soc->soc_names ) {
 529                                         struct oindexrec        tmpoir;
 530
 531                                         names--;
 532                                         ber_str2bv( *names, 0, 0, &tmpoir.oir_name );
 533                                         tmpoir.oir_oc = soc;
 534                                         oir = (struct oindexrec *)avl_delete( &oc_index,
 535                                                 (caddr_t)&tmpoir, oc_index_cmp );
 536                                         assert( oir != NULL );
 537                                         ldap_memfree( oir );
 538                                 }
 539
 540                                 if ( soc->soc_oid ) {
 541                                         struct oindexrec        tmpoir;
 542
 543                                         ber_str2bv( soc->soc_oid, 0, 0, &tmpoir.oir_name );
 544                                         tmpoir.oir_oc = soc;
 545                                         oir = (struct oindexrec *)avl_delete( &oc_index,
 546                                                 (caddr_t)&tmpoir, oc_index_cmp );
 547                                         assert( oir != NULL );
 548                                         ldap_memfree( oir );
 549                                 }
 550
 551                                 return rc;
 552                         }
 553
 554                         /* FIX: temporal consistency check */
 555                         assert( oc_bvfind(&oir->oir_name) != NULL );
 556
 557                         names++;
 558                 }
 559         }
 560         LDAP_STAILQ_INSERT_TAIL( &oc_list, soc, soc_next );
 561
 562         return 0;
 563 }
 564
 565 int
 566 oc_add(
 567     LDAPObjectClass     *oc,
 568         int user,
 569         ObjectClass             **rsoc,
 570     const char          **err )
 571 {
 572         ObjectClass     *soc;
 573         int             code;
 574         int             op = 0;
 575         char    *oidm = NULL;
 576
 577         if ( oc->oc_names != NULL ) {
 578                 int i;
 579
 580                 for( i=0; oc->oc_names[i]; i++ ) {
 581                         if( !slap_valid_descr( oc->oc_names[i] ) ) {
 582                                 return SLAP_SCHERR_BAD_DESCR;
 583                         }
 584                 }
 585         }
 586
 587         if ( !OID_LEADCHAR( oc->oc_oid[0] )) {
 588                 /* Expand OID macros */
 589                 char *oid = oidm_find( oc->oc_oid );
 590                 if ( !oid ) {
 591                         *err = oc->oc_oid;
 592                         return SLAP_SCHERR_OIDM;
 593                 }
 594                 if ( oid != oc->oc_oid ) {
 595                         oidm = oc->oc_oid;
 596                         oc->oc_oid = oid;
 597                 }
 598         }
 599
 600         soc = (ObjectClass *) ch_calloc( 1, sizeof(ObjectClass) );
 601         AC_MEMCPY( &soc->soc_oclass, oc, sizeof(LDAPObjectClass) );
 602
 603         soc->soc_oidmacro = oidm;
 604         if( oc->oc_names != NULL ) {
 605                 soc->soc_cname.bv_val = soc->soc_names[0];
 606         } else {
 607                 soc->soc_cname.bv_val = soc->soc_oid;
 608         }
 609         soc->soc_cname.bv_len = strlen( soc->soc_cname.bv_val );
 610
 611         if( soc->soc_sup_oids == NULL &&
 612                 soc->soc_kind == LDAP_SCHEMA_STRUCTURAL )
 613         {
 614                 /* structural object classes implicitly inherit from 'top' */
 615                 static char *top_oids[] = { SLAPD_TOP_OID, NULL };
 616                 code = oc_add_sups( soc, top_oids, &op, err );
 617         } else {
 618                 code = oc_add_sups( soc, soc->soc_sup_oids, &op, err );
 619         }
 620
 621         if ( code != 0 ) {
 622                 goto done;
 623         }
 624
 625         if ( user && op ) {
 626                 code = SLAP_SCHERR_CLASS_BAD_SUP;
 627                 goto done;
 628         }
 629
 630         code = oc_create_required( soc, soc->soc_at_oids_must, &op, err );
 631         if ( code != 0 ) {
 632                 goto done;
 633         }
 634
 635         code = oc_create_allowed( soc, soc->soc_at_oids_may, &op, err );
 636         if ( code != 0 ) {
 637                 goto done;
 638         }
 639
 640         if ( user && op ) {
 641                 code = SLAP_SCHERR_CLASS_BAD_USAGE;
 642                 goto done;
 643         }
 644
 645         if ( !user ) {
 646                 soc->soc_flags |= SLAP_OC_HARDCODE;
 647         }
 648
 649         code = oc_insert(soc,err);
 650 done:;
 651         if ( code != 0 ) {
 652                 if ( soc->soc_sups ) {
 653                         ch_free( soc->soc_sups );
 654                 }
 655
 656                 if ( soc->soc_required ) {
 657                         ch_free( soc->soc_required );
 658                 }
 659
 660                 if ( soc->soc_allowed ) {
 661                         ch_free( soc->soc_allowed );
 662                 }
 663
 664                 ch_free( soc );
 665
 666         } else if ( rsoc ) {
 667                 *rsoc = soc;
 668         }
 669         return code;
 670 }
 671
 672 void
 673 oc_unparse( BerVarray *res, ObjectClass *start, ObjectClass *end, int sys )
 674 {
 675         ObjectClass *oc;
 676         int i, num;
 677         struct berval bv, *bva = NULL, idx;
 678         char ibuf[32];
 679
 680         if ( !start )
 681                 start = LDAP_STAILQ_FIRST( &oc_list );
 682
 683         /* count the result size */
 684         i = 0;
 685         for ( oc=start; oc; oc=LDAP_STAILQ_NEXT(oc, soc_next)) {
 686                 if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) continue;
 687                 i++;
 688                 if ( oc == end ) break;
 689         }
 690         if (!i) return;
 691
 692         num = i;
 693         bva = ch_malloc( (num+1) * sizeof(struct berval) );
 694         BER_BVZERO( bva );
 695         idx.bv_val = ibuf;
 696         if ( sys ) {
 697                 idx.bv_len = 0;
 698                 ibuf[0] = '\0';
 699         }
 700         i = 0;
 701         for ( oc=start; oc; oc=LDAP_STAILQ_NEXT(oc, soc_next)) {
 702                 LDAPObjectClass loc, *locp;
 703                 if ( sys && !(oc->soc_flags & SLAP_OC_HARDCODE)) continue;
 704                 if ( oc->soc_oidmacro ) {
 705                         loc = oc->soc_oclass;
 706                         loc.oc_oid = oc->soc_oidmacro;
 707                         locp = &loc;
 708                 } else {
 709                         locp = &oc->soc_oclass;
 710                 }
 711                 if ( ldap_objectclass2bv( locp, &bv ) == NULL ) {
 712                         ber_bvarray_free( bva );
 713                 }
 714                 if ( !sys ) {
 715                         idx.bv_len = sprintf(idx.bv_val, "{%d}", i);
 716                 }
 717                 bva[i].bv_len = idx.bv_len + bv.bv_len;
 718                 bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 );
 719                 strcpy( bva[i].bv_val, ibuf );
 720                 strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val );
 721                 i++;
 722                 bva[i].bv_val = NULL;
 723                 ldap_memfree( bv.bv_val );
 724                 if ( oc == end ) break;
 725         }
 726         *res = bva;
 727 }
 728
 729 int
 730 oc_schema_info( Entry *e )
 731 {
 732         AttributeDescription *ad_objectClasses = slap_schema.si_ad_objectClasses;
 733         ObjectClass     *oc;
 734         struct berval   val;
 735         struct berval   nval;
 736
 737         LDAP_STAILQ_FOREACH( oc, &oc_list, soc_next ) {
 738                 if( oc->soc_flags & SLAP_OC_HIDE ) continue;
 739
 740                 if ( ldap_objectclass2bv( &oc->soc_oclass, &val ) == NULL ) {
 741                         return -1;
 742                 }
 743
 744                 nval = oc->soc_cname;
 745
 746 #if 0
 747                 Debug( LDAP_DEBUG_TRACE, "Merging oc [%ld] %s (%s)\n",
 748                (long) val.bv_len, val.bv_val, nval.bv_val );
 749 #endif
 750
 751                 if( attr_merge_one( e, ad_objectClasses, &val, &nval ) ) {
 752                         return -1;
 753                 }
 754                 ldap_memfree( val.bv_val );
 755         }
 756         return 0;
 757 }