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

   1 /* schema.c - routines to enforce schema definitions */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/ctype.h>
  13 #include <ac/string.h>
  14 #include <ac/socket.h>
  15
  16 #include "slap.h"
  17
  18 static char *   oc_check_required(Entry *e, char *ocname);
  19 static int              oc_check_allowed(char *type, struct berval **ocl);
  20
  21
  22 /*
  23  * oc_check - check that entry e conforms to the schema required by
  24  * its object class(es). returns 0 if so, non-zero otherwise.
  25  */
  26
  27 int
  28 oc_schema_check( Entry *e )
  29 {
  30         Attribute       *a, *aoc;
  31         ObjectClass *oc;
  32         int             i;
  33         int             ret = 0;
  34
  35
  36         /* find the object class attribute - could error out here */
  37         if ( (aoc = attr_find( e->e_attrs, "objectclass" )) == NULL ) {
  38                 Debug( LDAP_DEBUG_ANY, "No object class for entry (%s)\n",
  39                     e->e_dn, 0, 0 );
  40                 return( 1 );
  41         }
  42
  43         /* check that the entry has required attrs for each oc */
  44         for ( i = 0; aoc->a_vals[i] != NULL; i++ ) {
  45                 if ( (oc = oc_find( aoc->a_vals[i]->bv_val )) == NULL ) {
  46                         Debug( LDAP_DEBUG_ANY,
  47                                 "Objectclass \"%s\" not defined",
  48                                 aoc->a_vals[i]->bv_val, 0, 0 );
  49                 }
  50                 else
  51                 {
  52                         char *s = oc_check_required( e, aoc->a_vals[i]->bv_val );
  53
  54                         if (s != NULL) {
  55                                 Debug( LDAP_DEBUG_ANY,
  56                                         "Entry (%s), oc \"%s\" requires attr \"%s\"\n",
  57                                         e->e_dn, aoc->a_vals[i]->bv_val, s );
  58                                 ret = 1;
  59                         }
  60                 }
  61         }
  62
  63         if ( ret != 0 ) {
  64             return( ret );
  65         }
  66
  67         /* check that each attr in the entry is allowed by some oc */
  68         for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
  69                 if ( oc_check_allowed( a->a_type, aoc->a_vals ) != 0 ) {
  70                         Debug( LDAP_DEBUG_ANY,
  71                             "Entry (%s), attr \"%s\" not allowed\n",
  72                             e->e_dn, a->a_type, 0 );
  73                         ret = 1;
  74                 }
  75         }
  76
  77         return( ret );
  78 }
  79
  80 static char *
  81 oc_check_required( Entry *e, char *ocname )
  82 {
  83         ObjectClass     *oc;
  84         AttributeType   *at;
  85         int             i;
  86         Attribute       *a;
  87         char            **pp;
  88
  89         Debug( LDAP_DEBUG_TRACE,
  90                "oc_check_required entry (%s), objectclass \"%s\"\n",
  91                e->e_dn, ocname, 0 );
  92
  93         /* find global oc defn. it we don't know about it assume it's ok */
  94         if ( (oc = oc_find( ocname )) == NULL ) {
  95                 return( 0 );
  96         }
  97
  98         /* check for empty oc_required */
  99         if(oc->soc_required == NULL) {
 100                 return( 0 );
 101         }
 102
 103         /* for each required attribute */
 104         for ( i = 0; oc->soc_required[i] != NULL; i++ ) {
 105                 at = oc->soc_required[i];
 106                 /* see if it's in the entry */
 107                 for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
 108                         if ( at->sat_oid &&
 109                              strcmp( a->a_type, at->sat_oid ) == 0 ) {
 110                                 break;
 111                         }
 112                         pp = at->sat_names;
 113                         if ( pp  == NULL ) {
 114                                 /* Empty name list => not found */
 115                                 a = NULL;
 116                                 break;
 117                         }
 118                         while ( *pp ) {
 119                                 if ( strcasecmp( a->a_type, *pp ) == 0 ) {
 120                                         break;
 121                                 }
 122                                 pp++;
 123                         }
 124                         if ( *pp ) {
 125                                 break;
 126                         }
 127                 }
 128                 /* not there => schema violation */
 129                 if ( a == NULL ) {
 130                         if ( at->sat_names && at->sat_names[0] ) {
 131                                 return at->sat_names[0];
 132                         } else {
 133                                 return at->sat_oid;
 134                         }
 135                 }
 136         }
 137
 138         return( NULL );
 139 }
 140
 141 static char *oc_usermod_attrs[] = {
 142         /*
 143          * OpenLDAP doesn't support any user modification of
 144          * operational attributes.
 145          */
 146         NULL
 147 };
 148
 149 static char *oc_operational_attrs[] = {
 150         /*
 151          * these are operational attributes
 152          * most could be user modifiable
 153          */
 154         "objectClasses",
 155         "attributeTypes",
 156         "matchingRules",
 157         "matchingRuleUse",
 158         "dITStructureRules",
 159         "dITContentRules",
 160         "nameForms",
 161         "ldapSyntaxes",
 162         "namingContexts",
 163         "supportedExtension",
 164         "supportedControl",
 165         "supportedSASLMechanisms",
 166         "supportedLDAPversion",
 167         "supportedACIMechanisms",
 168         "subschemaSubentry",            /* NO USER MOD */
 169         NULL
 170
 171 };
 172
 173 /* this list should be extensible  */
 174 static char *oc_no_usermod_attrs[] = {
 175         /*
 176          * Operational and 'no user modification' attributes
 177          * which are STORED in the directory server.
 178          */
 179
 180         /* RFC2252, 3.2.1 */
 181         "creatorsName",
 182         "createTimestamp",
 183         "modifiersName",
 184         "modifyTimestamp",
 185
 186         NULL
 187 };
 188
 189
 190 /*
 191  * check to see if attribute is 'operational' or not.
 192  */
 193 int
 194 oc_check_operational_attr( const char *type )
 195 {
 196         return charray_inlist( oc_operational_attrs, type )
 197                 || charray_inlist( oc_usermod_attrs, type )
 198                 || charray_inlist( oc_no_usermod_attrs, type );
 199 }
 200
 201 /*
 202  * check to see if attribute can be user modified or not.
 203  */
 204 int
 205 oc_check_usermod_attr( const char *type )
 206 {
 207         return charray_inlist( oc_usermod_attrs, type );
 208 }
 209
 210 /*
 211  * check to see if attribute is 'no user modification' or not.
 212  */
 213 int
 214 oc_check_no_usermod_attr( const char *type )
 215 {
 216         return charray_inlist( oc_no_usermod_attrs, type );
 217 }
 218
 219
 220 static int
 221 oc_check_allowed( char *type, struct berval **ocl )
 222 {
 223         ObjectClass     *oc;
 224         AttributeType   *at;
 225         int             i, j;
 226         char            **pp;
 227         char            *p, *t;
 228
 229         Debug( LDAP_DEBUG_TRACE,
 230                "oc_check_allowed type \"%s\"\n", type, 0, 0 );
 231
 232         /* always allow objectclass attribute */
 233         if ( strcasecmp( type, "objectclass" ) == 0 ) {
 234                 return( 0 );
 235         }
 236
 237         /*
 238          * All operational attributions are allowed by schema rules.
 239          * However, we only check attributions which are stored in the
 240          * the directory regardless if they are user or non-user modified.
 241          */
 242         if ( oc_check_usermod_attr( type ) || oc_check_no_usermod_attr( type ) ) {
 243                 return( 0 );
 244         }
 245
 246         /*
 247          * The "type" we have received is actually an AttributeDescription.
 248          * Let's find out the corresponding type.
 249          */
 250         p = strchr( type, ';' );
 251         if ( p ) {
 252                 t = ch_malloc( p-type+1 );
 253                 strncpy( t, type, p-type );
 254                 t[p-type] = '\0';
 255                 Debug( LDAP_DEBUG_TRACE,
 256                        "oc_check_allowed type \"%s\" from \"%s\"\n",
 257                        t, type, 0 );
 258
 259         } else {
 260                 t = type;
 261         }
 262
 263         /* check that the type appears as req or opt in at least one oc */
 264         for ( i = 0; ocl[i] != NULL; i++ ) {
 265                 /* if we know about the oc */
 266                 if ( (oc = oc_find( ocl[i]->bv_val )) != NULL ) {
 267                         /* does it require the type? */
 268                         for ( j = 0; oc->soc_required != NULL &&
 269                                 oc->soc_required[j] != NULL; j++ ) {
 270                                 at = oc->soc_required[j];
 271                                 if ( at->sat_oid &&
 272                                      strcmp(at->sat_oid, t ) == 0 ) {
 273                                         if ( t != type )
 274                                                 ldap_memfree( t );
 275                                         return( 0 );
 276                                 }
 277                                 pp = at->sat_names;
 278                                 if ( pp == NULL )
 279                                         continue;
 280                                 while ( *pp ) {
 281                                         if ( strcasecmp( *pp, t ) == 0 ) {
 282                                                 if ( t != type )
 283                                                         ldap_memfree( t );
 284                                                 return( 0 );
 285                                         }
 286                                         pp++;
 287                                 }
 288                         }
 289                         /* does it allow the type? */
 290                         for ( j = 0; oc->soc_allowed != NULL &&
 291                                 oc->soc_allowed[j] != NULL; j++ ) {
 292                                 at = oc->soc_allowed[j];
 293                                 if ( at->sat_oid &&
 294                                      strcmp( at->sat_oid, t ) == 0 ) {
 295                                         if ( t != type )
 296                                                 ldap_memfree( t );
 297                                         return( 0 );
 298                                 }
 299                                 pp = at->sat_names;
 300                                 if ( pp == NULL )
 301                                         continue;
 302                                 while ( *pp ) {
 303                                         if ( strcasecmp( *pp, t ) == 0 ||
 304                                              strcmp( *pp, "*" ) == 0 ) {
 305                                                 if ( t != type )
 306                                                         ldap_memfree( t );
 307                                                 return( 0 );
 308                                         }
 309                                         pp++;
 310                                 }
 311                         }
 312                         /* maybe the next oc allows it */
 313
 314 #ifdef OC_UNDEFINED_IMPLES_EXTENSIBLE
 315                 /* we don't know about the oc. assume it allows it */
 316                 } else {
 317                         if ( t != type )
 318                                 ldap_memfree( t );
 319                         return( 0 );
 320 #endif
 321                 }
 322         }
 323
 324         if ( t != type )
 325                 ldap_memfree( t );
 326         /* not allowed by any oc */
 327         return( 1 );
 328 }
 329
 330 struct oindexrec {
 331         char            *oir_name;
 332         ObjectClass     *oir_oc;
 333 };
 334
 335 static Avlnode  *oc_index = NULL;
 336 static ObjectClass *oc_list = NULL;
 337
 338 static int
 339 oc_index_cmp(
 340     struct oindexrec    *oir1,
 341     struct oindexrec    *oir2
 342 )
 343 {
 344         return (strcasecmp( oir1->oir_name, oir2->oir_name ));
 345 }
 346
 347 static int
 348 oc_index_name_cmp(
 349     char                *name,
 350     struct oindexrec    *oir
 351 )
 352 {
 353         return (strcasecmp( name, oir->oir_name ));
 354 }
 355
 356 ObjectClass *
 357 oc_find( const char *ocname )
 358 {
 359         struct oindexrec        *oir = NULL;
 360
 361         if ( (oir = (struct oindexrec *) avl_find( oc_index, ocname,
 362             (AVL_CMP) oc_index_name_cmp )) != NULL ) {
 363                 return( oir->oir_oc );
 364         }
 365         return( NULL );
 366 }
 367
 368 static int
 369 oc_create_required(
 370     ObjectClass         *soc,
 371     char                **attrs,
 372     const char          **err
 373 )
 374 {
 375         char            **attrs1;
 376         AttributeType   *sat;
 377         AttributeType   **satp;
 378         int             i;
 379
 380         if ( attrs ) {
 381                 attrs1 = attrs;
 382                 while ( *attrs1 ) {
 383                         sat = at_find(*attrs1);
 384                         if ( !sat ) {
 385                                 *err = *attrs1;
 386                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
 387                         }
 388                         if ( at_find_in_list(sat, soc->soc_required) < 0) {
 389                                 if ( at_append_to_list(sat, &soc->soc_required) ) {
 390                                         *err = *attrs1;
 391                                         return SLAP_SCHERR_OUTOFMEM;
 392                                 }
 393                         }
 394                         attrs1++;
 395                 }
 396                 /* Now delete duplicates from the allowed list */
 397                 for ( satp = soc->soc_required; *satp; satp++ ) {
 398                         i = at_find_in_list(*satp,soc->soc_allowed);
 399                         if ( i >= 0 ) {
 400                                 at_delete_from_list(i, &soc->soc_allowed);
 401                         }
 402                 }
 403         }
 404         return 0;
 405 }
 406
 407 static int
 408 oc_create_allowed(
 409     ObjectClass         *soc,
 410     char                **attrs,
 411     const char          **err
 412 )
 413 {
 414         char            **attrs1;
 415         AttributeType   *sat;
 416
 417         if ( attrs ) {
 418                 attrs1 = attrs;
 419                 while ( *attrs1 ) {
 420                         sat = at_find(*attrs1);
 421                         if ( !sat ) {
 422                                 *err = *attrs1;
 423                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
 424                         }
 425                         if ( at_find_in_list(sat, soc->soc_required) < 0 &&
 426                              at_find_in_list(sat, soc->soc_allowed) < 0 ) {
 427                                 if ( at_append_to_list(sat, &soc->soc_allowed) ) {
 428                                         *err = *attrs1;
 429                                         return SLAP_SCHERR_OUTOFMEM;
 430                                 }
 431                         }
 432                         attrs1++;
 433                 }
 434         }
 435         return 0;
 436 }
 437
 438 static int
 439 oc_add_sups(
 440     ObjectClass         *soc,
 441     char                **sups,
 442     const char          **err
 443 )
 444 {
 445         int             code;
 446         ObjectClass     *soc1;
 447         int             nsups;
 448         char            **sups1;
 449         int             add_sups = 0;
 450
 451         if ( sups ) {
 452                 if ( !soc->soc_sups ) {
 453                         /* We are at the first recursive level */
 454                         add_sups = 1;
 455                         nsups = 0;
 456                         sups1 = sups;
 457                         while ( *sups1 ) {
 458                                 nsups++;
 459                                 sups1++;
 460                         }
 461                         nsups++;
 462                         soc->soc_sups = (ObjectClass **)ch_calloc(1,
 463                                           nsups*sizeof(ObjectClass *));
 464                 }
 465                 nsups = 0;
 466                 sups1 = sups;
 467                 while ( *sups1 ) {
 468                         soc1 = oc_find(*sups1);
 469                         if ( !soc1 ) {
 470                                 *err = *sups1;
 471                                 return SLAP_SCHERR_CLASS_NOT_FOUND;
 472                         }
 473
 474                         if ( add_sups )
 475                                 soc->soc_sups[nsups] = soc1;
 476
 477                         code = oc_add_sups(soc,soc1->soc_sup_oids, err);
 478                         if ( code )
 479                                 return code;
 480
 481                         code = oc_create_required(soc,soc1->soc_at_oids_must,err);
 482                         if ( code )
 483                                 return code;
 484                         code = oc_create_allowed(soc,soc1->soc_at_oids_may,err);
 485                         if ( code )
 486                                 return code;
 487
 488                         nsups++;
 489                         sups1++;
 490                 }
 491         }
 492         return 0;
 493 }
 494
 495 static int
 496 oc_insert(
 497     ObjectClass         *soc,
 498     const char          **err
 499 )
 500 {
 501         ObjectClass     **ocp;
 502         struct oindexrec        *oir;
 503         char                    **names;
 504
 505         ocp = &oc_list;
 506         while ( *ocp != NULL ) {
 507                 ocp = &(*ocp)->soc_next;
 508         }
 509         *ocp = soc;
 510
 511         if ( soc->soc_oid ) {
 512                 oir = (struct oindexrec *)
 513                         ch_calloc( 1, sizeof(struct oindexrec) );
 514                 oir->oir_name = soc->soc_oid;
 515                 oir->oir_oc = soc;
 516                 if ( avl_insert( &oc_index, (caddr_t) oir,
 517                                  (AVL_CMP) oc_index_cmp,
 518                                  (AVL_DUP) avl_dup_error ) ) {
 519                         *err = soc->soc_oid;
 520                         ldap_memfree(oir);
 521                         return SLAP_SCHERR_DUP_CLASS;
 522                 }
 523                 /* FIX: temporal consistency check */
 524                 oc_find(oir->oir_name);
 525         }
 526         if ( (names = soc->soc_names) ) {
 527                 while ( *names ) {
 528                         oir = (struct oindexrec *)
 529                                 ch_calloc( 1, sizeof(struct oindexrec) );
 530                         oir->oir_name = ch_strdup(*names);
 531                         oir->oir_oc = soc;
 532                         if ( avl_insert( &oc_index, (caddr_t) oir,
 533                                          (AVL_CMP) oc_index_cmp,
 534                                          (AVL_DUP) avl_dup_error ) ) {
 535                                 *err = *names;
 536                                 ldap_memfree(oir);
 537                                 return SLAP_SCHERR_DUP_CLASS;
 538                         }
 539                         /* FIX: temporal consistency check */
 540                         oc_find(oir->oir_name);
 541                         names++;
 542                 }
 543         }
 544         return 0;
 545 }
 546
 547 int
 548 oc_add(
 549     LDAP_OBJECT_CLASS   *oc,
 550     const char          **err
 551 )
 552 {
 553         ObjectClass     *soc;
 554         int             code;
 555
 556         soc = (ObjectClass *) ch_calloc( 1, sizeof(ObjectClass) );
 557         memcpy( &soc->soc_oclass, oc, sizeof(LDAP_OBJECT_CLASS));
 558         if ( (code = oc_add_sups(soc,soc->soc_sup_oids,err)) != 0 )
 559                 return code;
 560         if ( (code = oc_create_required(soc,soc->soc_at_oids_must,err)) != 0 )
 561                 return code;
 562         if ( (code = oc_create_allowed(soc,soc->soc_at_oids_may,err)) != 0 )
 563                 return code;
 564         code = oc_insert(soc,err);
 565         return code;
 566 }
 567
 568 struct sindexrec {
 569         char            *sir_name;
 570         Syntax          *sir_syn;
 571 };
 572
 573 static Avlnode  *syn_index = NULL;
 574 static Syntax *syn_list = NULL;
 575
 576 static int
 577 syn_index_cmp(
 578     struct sindexrec    *sir1,
 579     struct sindexrec    *sir2
 580 )
 581 {
 582         return (strcmp( sir1->sir_name, sir2->sir_name ));
 583 }
 584
 585 static int
 586 syn_index_name_cmp(
 587     char                *name,
 588     struct sindexrec    *sir
 589 )
 590 {
 591         return (strcmp( name, sir->sir_name ));
 592 }
 593
 594 Syntax *
 595 syn_find( const char *synname )
 596 {
 597         struct sindexrec        *sir = NULL;
 598
 599         if ( (sir = (struct sindexrec *) avl_find( syn_index, synname,
 600             (AVL_CMP) syn_index_name_cmp )) != NULL ) {
 601                 return( sir->sir_syn );
 602         }
 603         return( NULL );
 604 }
 605
 606 Syntax *
 607 syn_find_desc( const char *syndesc, int *len )
 608 {
 609         Syntax          *synp;
 610
 611         for (synp = syn_list; synp; synp = synp->ssyn_next)
 612                 if ((*len = dscompare( synp->ssyn_syn.syn_desc, syndesc, '{')))
 613                         return synp;
 614         return( NULL );
 615 }
 616
 617 static int
 618 syn_insert(
 619     Syntax              *ssyn,
 620     const char          **err
 621 )
 622 {
 623         Syntax          **synp;
 624         struct sindexrec        *sir;
 625
 626         synp = &syn_list;
 627         while ( *synp != NULL ) {
 628                 synp = &(*synp)->ssyn_next;
 629         }
 630         *synp = ssyn;
 631
 632         if ( ssyn->ssyn_oid ) {
 633                 sir = (struct sindexrec *)
 634                         ch_calloc( 1, sizeof(struct sindexrec) );
 635                 sir->sir_name = ssyn->ssyn_oid;
 636                 sir->sir_syn = ssyn;
 637                 if ( avl_insert( &syn_index, (caddr_t) sir,
 638                                  (AVL_CMP) syn_index_cmp,
 639                                  (AVL_DUP) avl_dup_error ) ) {
 640                         *err = ssyn->ssyn_oid;
 641                         ldap_memfree(sir);
 642                         return SLAP_SCHERR_DUP_SYNTAX;
 643                 }
 644                 /* FIX: temporal consistency check */
 645                 syn_find(sir->sir_name);
 646         }
 647         return 0;
 648 }
 649
 650 int
 651 syn_add(
 652     LDAP_SYNTAX         *syn,
 653     slap_syntax_check_func      *check,
 654     const char          **err
 655 )
 656 {
 657         Syntax          *ssyn;
 658         int             code;
 659
 660         ssyn = (Syntax *) ch_calloc( 1, sizeof(Syntax) );
 661         memcpy( &ssyn->ssyn_syn, syn, sizeof(LDAP_SYNTAX));
 662         ssyn->ssyn_check = check;
 663         code = syn_insert(ssyn,err);
 664         return code;
 665 }
 666
 667 struct mindexrec {
 668         char            *mir_name;
 669         MatchingRule    *mir_mr;
 670 };
 671
 672 static Avlnode  *mr_index = NULL;
 673 static MatchingRule *mr_list = NULL;
 674
 675 static int
 676 mr_index_cmp(
 677     struct mindexrec    *mir1,
 678     struct mindexrec    *mir2
 679 )
 680 {
 681         return (strcmp( mir1->mir_name, mir2->mir_name ));
 682 }
 683
 684 static int
 685 mr_index_name_cmp(
 686     char                *name,
 687     struct mindexrec    *mir
 688 )
 689 {
 690         return (strcmp( name, mir->mir_name ));
 691 }
 692
 693 MatchingRule *
 694 mr_find( const char *mrname )
 695 {
 696         struct mindexrec        *mir = NULL;
 697
 698         if ( (mir = (struct mindexrec *) avl_find( mr_index, mrname,
 699             (AVL_CMP) mr_index_name_cmp )) != NULL ) {
 700                 return( mir->mir_mr );
 701         }
 702         return( NULL );
 703 }
 704
 705 static int
 706 mr_insert(
 707     MatchingRule        *smr,
 708     const char          **err
 709 )
 710 {
 711         MatchingRule            **mrp;
 712         struct mindexrec        *mir;
 713         char                    **names;
 714
 715         mrp = &mr_list;
 716         while ( *mrp != NULL ) {
 717                 mrp = &(*mrp)->smr_next;
 718         }
 719         *mrp = smr;
 720
 721         if ( smr->smr_oid ) {
 722                 mir = (struct mindexrec *)
 723                         ch_calloc( 1, sizeof(struct mindexrec) );
 724                 mir->mir_name = smr->smr_oid;
 725                 mir->mir_mr = smr;
 726                 if ( avl_insert( &mr_index, (caddr_t) mir,
 727                                  (AVL_CMP) mr_index_cmp,
 728                                  (AVL_DUP) avl_dup_error ) ) {
 729                         *err = smr->smr_oid;
 730                         ldap_memfree(mir);
 731                         return SLAP_SCHERR_DUP_RULE;
 732                 }
 733                 /* FIX: temporal consistency check */
 734                 mr_find(mir->mir_name);
 735         }
 736         if ( (names = smr->smr_names) ) {
 737                 while ( *names ) {
 738                         mir = (struct mindexrec *)
 739                                 ch_calloc( 1, sizeof(struct mindexrec) );
 740                         mir->mir_name = ch_strdup(*names);
 741                         mir->mir_mr = smr;
 742                         if ( avl_insert( &mr_index, (caddr_t) mir,
 743                                          (AVL_CMP) mr_index_cmp,
 744                                          (AVL_DUP) avl_dup_error ) ) {
 745                                 *err = *names;
 746                                 ldap_memfree(mir);
 747                                 return SLAP_SCHERR_DUP_RULE;
 748                         }
 749                         /* FIX: temporal consistency check */
 750                         mr_find(mir->mir_name);
 751                         names++;
 752                 }
 753         }
 754         return 0;
 755 }
 756
 757 int
 758 mr_add(
 759     LDAP_MATCHING_RULE          *mr,
 760     slap_mr_normalize_func      *normalize,
 761     slap_mr_compare_func        *compare,
 762     const char          **err
 763 )
 764 {
 765         MatchingRule    *smr;
 766         Syntax          *syn;
 767         int             code;
 768
 769         smr = (MatchingRule *) ch_calloc( 1, sizeof(MatchingRule) );
 770         memcpy( &smr->smr_mrule, mr, sizeof(LDAP_MATCHING_RULE));
 771         smr->smr_normalize = normalize;
 772         smr->smr_compare = compare;
 773         if ( smr->smr_syntax_oid ) {
 774                 if ( (syn = syn_find(smr->smr_syntax_oid)) ) {
 775                         smr->smr_syntax = syn;
 776                 } else {
 777                         *err = smr->smr_syntax_oid;
 778                         return SLAP_SCHERR_SYN_NOT_FOUND;
 779                 }
 780         } else {
 781                 *err = "";
 782                 return SLAP_SCHERR_MR_INCOMPLETE;
 783         }
 784         code = mr_insert(smr,err);
 785         return code;
 786 }
 787
 788 static int
 789 case_exact_normalize(
 790         struct berval *val,
 791         struct berval **normalized
 792 )
 793 {
 794         struct berval *newval;
 795         char *p, *q;
 796
 797         newval = ber_bvdup( val );
 798         p = q = newval->bv_val;
 799         /* Ignore initial whitespace */
 800         while ( isspace( *p++ ) )
 801                 ;
 802         while ( *p ) {
 803                 if ( isspace( *p ) ) {
 804                         *q++ = *p++;
 805                         /* Ignore the extra whitespace */
 806                         while ( isspace(*p++) )
 807                                 ;
 808                 } else {
 809                         *q++ = *p++;
 810                 }
 811         }
 812         /*
 813          * If the string ended in space, backup the pointer one
 814          * position.  One is enough because the above loop collapsed
 815          * all whitespace to a single space.
 816          */
 817         if ( p != newval->bv_val && isspace( *(p-1) ) ) {
 818                 *(q-1) = '\0';
 819         }
 820         newval->bv_len = strlen( newval->bv_val );
 821         normalized = &newval;
 822
 823         return 0;
 824 }
 825
 826 static int
 827 case_exact_compare(
 828         struct berval *val1,
 829         struct berval *val2
 830 )
 831 {
 832         return strcmp( val1->bv_val, val2->bv_val );
 833 }
 834
 835 int
 836 case_ignore_normalize(
 837         struct berval *val,
 838         struct berval **normalized
 839 )
 840 {
 841         struct berval *newval;
 842         char *p, *q;
 843
 844         newval = ber_bvdup( val );
 845         p = q = newval->bv_val;
 846         /* Ignore initial whitespace */
 847         while ( isspace( *p++ ) )
 848                 ;
 849         while ( *p ) {
 850                 if ( isspace( *p ) ) {
 851                         *q++ = *p++;
 852                         /* Ignore the extra whitespace */
 853                         while ( isspace(*p++) )
 854                                 ;
 855                 } else {
 856                         *q++ = TOUPPER( *p++ );
 857                 }
 858         }
 859         /*
 860          * If the string ended in space, backup the pointer one
 861          * position.  One is enough because the above loop collapsed
 862          * all whitespace to a single space.
 863          */
 864         if ( p != newval->bv_val && isspace( *(p-1) ) ) {
 865                 *(q-1) = '\0';
 866         }
 867         newval->bv_len = strlen( newval->bv_val );
 868         normalized = &newval;
 869
 870         return 0;
 871 }
 872
 873 static int
 874 case_ignore_compare(
 875         struct berval *val1,
 876         struct berval *val2
 877 )
 878 {
 879         return strcasecmp( val1->bv_val, val2->bv_val );
 880 }
 881
 882 int
 883 register_syntax(
 884         char * desc,
 885         slap_syntax_check_func *check )
 886 {
 887         LDAP_SYNTAX     *syn;
 888         int             code;
 889         const char      *err;
 890
 891         syn = ldap_str2syntax( desc, &code, &err);
 892         if ( !syn ) {
 893                 Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s before %s in %s\n",
 894                     ldap_scherr2str(code), err, desc );
 895                 return( -1 );
 896         }
 897         code = syn_add( syn, check, &err );
 898         if ( code ) {
 899                 Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s %s in %s\n",
 900                     scherr2str(code), err, desc );
 901                 return( -1 );
 902         }
 903         return( 0 );
 904 }
 905
 906 int
 907 register_matching_rule(
 908         char * desc,
 909         slap_mr_normalize_func *normalize,
 910         slap_mr_compare_func *compare )
 911 {
 912         LDAP_MATCHING_RULE *mr;
 913         int             code;
 914         const char      *err;
 915
 916         mr = ldap_str2matchingrule( desc, &code, &err);
 917         if ( !mr ) {
 918                 Debug( LDAP_DEBUG_ANY, "Error in register_matching_rule: %s before %s in %s\n",
 919                     ldap_scherr2str(code), err, desc );
 920                 return( -1 );
 921         }
 922         code = mr_add( mr, normalize, compare, &err );
 923         if ( code ) {
 924                 Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s for %s in %s\n",
 925                     scherr2str(code), err, desc );
 926                 return( -1 );
 927         }
 928         return( 0 );
 929 }
 930
 931 struct syntax_defs_rec {
 932         char *sd_desc;
 933         slap_syntax_check_func *sd_check;
 934 };
 935
 936 struct syntax_defs_rec syntax_defs[] = {
 937         {"( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'AttributeTypeDescription' )", NULL},
 938         {"( 1.3.6.1.4.1.1466.115.121.1.4 DESC 'Audio' )", NULL},
 939         {"( 1.3.6.1.4.1.1466.115.121.1.5 DESC 'Binary' )", NULL},
 940         {"( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'BitString' )", NULL},
 941         {"( 1.3.6.1.4.1.1466.115.121.1.8 DESC 'Certificate' )", NULL},
 942         {"( 1.3.6.1.4.1.1466.115.121.1.9 DESC 'CertificateList' )", NULL},
 943         {"( 1.3.6.1.4.1.1466.115.121.1.10 DESC 'CertificatePair' )", NULL},
 944         {"( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'DN' )", NULL},
 945         {"( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'DeliveryMethod' )", NULL},
 946         {"( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'DirectoryString' )", NULL},
 947         {"( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DITContentRuleDescription' )", NULL},
 948         {"( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DITStructureRuleDescription' )", NULL},
 949         {"( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'EnhancedGuide' )", NULL},
 950         {"( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'FacsimileTelephoneNumber' )", NULL},
 951         {"( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'GeneralizedTime' )", NULL},
 952         {"( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )", NULL},
 953         {"( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5String' )", NULL},
 954         {"( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'Integer' )", NULL},
 955         {"( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' )", NULL},
 956         {"( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'MatchingRuleDescription' )", NULL},
 957         {"( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'MatchingRuleUseDescription' )", NULL},
 958         {"( 1.3.6.1.4.1.1466.115.121.1.32 DESC 'MailPreference' )", NULL},
 959         {"( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'NameAndOptionalUID' )", NULL},
 960         {"( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'NameFormDescription' )", NULL},
 961         {"( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'NumericString' )", NULL},
 962         {"( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'ObjectClassDescription' )", NULL},
 963         {"( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )", NULL},
 964         {"( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'OtherMailbox' )", NULL},
 965         {"( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'OctetString' )", NULL},
 966         {"( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'PostalAddress' )", NULL},
 967         {"( 1.3.6.1.4.1.1466.115.121.1.42 DESC 'ProtocolInformation' )", NULL},
 968         {"( 1.3.6.1.4.1.1466.115.121.1.43 DESC 'PresentationAddress' )", NULL},
 969         {"( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'PrintableString' )", NULL},
 970         {"( 1.3.6.1.4.1.1466.115.121.1.49 DESC 'SupportedAlgorithm' )", NULL},
 971         {"( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'TelephoneNumber' )", NULL},
 972         {"( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'TeletexTerminalIdentifier' )", NULL},
 973         {"( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'TelexNumber' )", NULL},
 974         {"( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTCTime' )", NULL},
 975         {"( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAPSyntaxDescription' )", NULL},
 976         {"( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'SubstringAssertion' )", NULL},
 977         {"( 1.3.6.1.1.1.0.0 DESC 'NISnetgrouptriple' )", NULL},
 978         {"( 1.3.6.1.1.1.0.1 DESC 'Bootparameter' )", NULL},
 979         {NULL, NULL}
 980 };
 981
 982 struct mrule_defs_rec {
 983         char *mrd_desc;
 984         slap_mr_normalize_func *mrd_normalize;
 985         slap_mr_compare_func *mrd_compare;
 986 };
 987
 988 /*
 989  * Other matching rules in X.520 that we do not use:
 990  *
 991  * 2.5.13.9     numericStringOrderingMatch
 992  * 2.5.13.12    caseIgnoreListSubstringsMatch
 993  * 2.5.13.13    booleanMatch
 994  * 2.5.13.15    integerOrderingMatch
 995  * 2.5.13.18    octetStringOrderingMatch
 996  * 2.5.13.19    octetStringSubstringsMatch
 997  * 2.5.13.25    uTCTimeMatch
 998  * 2.5.13.26    uTCTimeOrderingMatch
 999  * 2.5.13.31    directoryStringFirstComponentMatch
1000  * 2.5.13.32    wordMatch
1001  * 2.5.13.33    keywordMatch
1002  * 2.5.13.34    certificateExactMatch
1003  * 2.5.13.35    certificateMatch
1004  * 2.5.13.36    certificatePairExactMatch
1005  * 2.5.13.37    certificatePairMatch
1006  * 2.5.13.38    certificateListExactMatch
1007  * 2.5.13.39    certificateListMatch
1008  * 2.5.13.40    algorithmIdentifierMatch
1009  * 2.5.13.41    storedPrefixMatch
1010  * 2.5.13.42    attributeCertificateMatch
1011  * 2.5.13.43    readerAndKeyIDMatch
1012  * 2.5.13.44    attributeIntegrityMatch
1013  */
1014
1015 struct mrule_defs_rec mrule_defs[] = {
1016         {"( 2.5.13.0 NAME 'objectIdentifierMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )", NULL, NULL},
1017         {"( 2.5.13.1 NAME 'distinguishedNameMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )", NULL, NULL},
1018         {"( 2.5.13.2 NAME 'caseIgnoreMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
1019          case_ignore_normalize, case_ignore_compare},
1020         {"( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
1021          case_ignore_normalize, case_ignore_compare},
1022         {"( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
1023          case_ignore_normalize, case_ignore_compare},
1024         /* Next three are not in the RFC's, but are needed for compatibility */
1025         {"( 2.5.13.5 NAME 'caseExactMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
1026          case_exact_normalize, case_exact_compare},
1027         {"( 2.5.13.6 NAME 'caseExactOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
1028          case_exact_normalize, case_exact_compare},
1029         {"( 2.5.13.7 NAME 'caseExactSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
1030          case_exact_normalize, case_exact_compare},
1031         {"( 2.5.13.8 NAME 'numericStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )", NULL, NULL},
1032         {"( 2.5.13.10 NAME 'numericStringSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )", NULL, NULL},
1033         {"( 2.5.13.11 NAME 'caseIgnoreListMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )", NULL, NULL},
1034         {"( 2.5.13.14 NAME 'integerMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )", NULL, NULL},
1035         {"( 2.5.13.16 NAME 'bitStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )", NULL, NULL},
1036         {"( 2.5.13.17 NAME 'octetStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )", NULL, NULL},
1037         {"( 2.5.13.20 NAME 'telephoneNumberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )", NULL, NULL},
1038         {"( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )", NULL, NULL},
1039         {"( 2.5.13.22 NAME 'presentationAddressMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.43 )", NULL, NULL},
1040         {"( 2.5.13.23 NAME 'uniqueMemberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )", NULL, NULL},
1041         {"( 2.5.13.24 NAME 'protocolInformationMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.42 )", NULL, NULL},
1042         {"( 2.5.13.27 NAME 'generalizedTimeMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )", NULL, NULL},
1043         {"( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )", NULL, NULL},
1044         {"( 2.5.13.29 NAME 'integerFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )", NULL, NULL},
1045         {"( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )", NULL, NULL},
1046         {"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
1047          case_exact_normalize, case_exact_compare},
1048         {"( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
1049          case_ignore_normalize, case_ignore_compare},
1050         {NULL, NULL, NULL}
1051 };
1052
1053 int
1054 schema_init( void )
1055 {
1056         int             res;
1057         int             i;
1058         static int      schema_init_done = 0;
1059
1060         /* We are called from read_config that is recursive */
1061         if ( schema_init_done )
1062                 return( 0 );
1063         for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
1064                 res = register_syntax( syntax_defs[i].sd_desc,
1065                     syntax_defs[i].sd_check );
1066                 if ( res ) {
1067                         fprintf( stderr, "schema_init: Error registering syntax %s\n",
1068                                  syntax_defs[i].sd_desc );
1069                         exit( EXIT_FAILURE );
1070                 }
1071         }
1072         for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
1073                 res = register_matching_rule( mrule_defs[i].mrd_desc,
1074                     ( mrule_defs[i].mrd_normalize ?
1075                       mrule_defs[i].mrd_normalize : case_ignore_normalize ),
1076                     ( mrule_defs[i].mrd_compare ?
1077                       mrule_defs[i].mrd_compare : case_ignore_compare ) );
1078                 if ( res ) {
1079                         fprintf( stderr, "schema_init: Error registering matching rule %s\n",
1080                                  mrule_defs[i].mrd_desc );
1081                         exit( EXIT_FAILURE );
1082                 }
1083         }
1084         schema_init_done = 1;
1085         return( 0 );
1086 }
1087
1088 #if defined( SLAPD_SCHEMA_DN )
1089
1090 static int
1091 syn_schema_info( Entry *e )
1092 {
1093         struct berval   val;
1094         struct berval   *vals[2];
1095         Syntax          *syn;
1096
1097         vals[0] = &val;
1098         vals[1] = NULL;
1099
1100         for ( syn = syn_list; syn; syn = syn->ssyn_next ) {
1101                 val.bv_val = ldap_syntax2str( &syn->ssyn_syn );
1102                 if ( val.bv_val ) {
1103                         val.bv_len = strlen( val.bv_val );
1104                         Debug( LDAP_DEBUG_TRACE, "Merging syn [%ld] %s\n",
1105                                (long) val.bv_len, val.bv_val, 0 );
1106                         attr_merge( e, "ldapSyntaxes", vals );
1107                         ldap_memfree( val.bv_val );
1108                 } else {
1109                         return -1;
1110                 }
1111         }
1112         return 0;
1113 }
1114
1115 static int
1116 mr_schema_info( Entry *e )
1117 {
1118         struct berval   val;
1119         struct berval   *vals[2];
1120         MatchingRule    *mr;
1121
1122         vals[0] = &val;
1123         vals[1] = NULL;
1124
1125         for ( mr = mr_list; mr; mr = mr->smr_next ) {
1126                 val.bv_val = ldap_matchingrule2str( &mr->smr_mrule );
1127                 if ( val.bv_val ) {
1128                         val.bv_len = strlen( val.bv_val );
1129                         Debug( LDAP_DEBUG_TRACE, "Merging mr [%ld] %s\n",
1130                                (long) val.bv_len, val.bv_val, 0 );
1131                         attr_merge( e, "matchingRules", vals );
1132                         ldap_memfree( val.bv_val );
1133                 } else {
1134                         return -1;
1135                 }
1136         }
1137         return 0;
1138 }
1139
1140 static int
1141 oc_schema_info( Entry *e )
1142 {
1143         struct berval   val;
1144         struct berval   *vals[2];
1145         ObjectClass     *oc;
1146
1147         vals[0] = &val;
1148         vals[1] = NULL;
1149
1150         for ( oc = oc_list; oc; oc = oc->soc_next ) {
1151                 val.bv_val = ldap_objectclass2str( &oc->soc_oclass );
1152                 if ( val.bv_val ) {
1153                         val.bv_len = strlen( val.bv_val );
1154                         Debug( LDAP_DEBUG_TRACE, "Merging oc [%ld] %s\n",
1155                                (long) val.bv_len, val.bv_val, 0 );
1156                         attr_merge( e, "objectClasses", vals );
1157                         ldap_memfree( val.bv_val );
1158                 } else {
1159                         return -1;
1160                 }
1161         }
1162         return 0;
1163 }
1164
1165 void
1166 schema_info( Connection *conn, Operation *op, char **attrs, int attrsonly )
1167 {
1168         Entry           *e;
1169         struct berval   val;
1170         struct berval   *vals[2];
1171
1172         vals[0] = &val;
1173         vals[1] = NULL;
1174
1175         e = (Entry *) ch_calloc( 1, sizeof(Entry) );
1176
1177         e->e_attrs = NULL;
1178         e->e_dn = ch_strdup( SLAPD_SCHEMA_DN );
1179         e->e_ndn = ch_strdup( SLAPD_SCHEMA_DN );
1180         (void) dn_normalize( e->e_ndn );
1181         e->e_private = NULL;
1182
1183         {
1184                 char *rdn = ch_strdup( SLAPD_SCHEMA_DN );
1185                 val.bv_val = strchr( rdn, '=' );
1186
1187                 if( val.bv_val != NULL ) {
1188                         *val.bv_val = '\0';
1189                         val.bv_len = strlen( ++val.bv_val );
1190
1191                         attr_merge( e, rdn, vals );
1192                 }
1193
1194                 free( rdn );
1195         }
1196
1197         if ( syn_schema_info( e ) ) {
1198                 /* Out of memory, do something about it */
1199                 entry_free( e );
1200                 return;
1201         }
1202         if ( mr_schema_info( e ) ) {
1203                 /* Out of memory, do something about it */
1204                 entry_free( e );
1205                 return;
1206         }
1207         if ( at_schema_info( e ) ) {
1208                 /* Out of memory, do something about it */
1209                 entry_free( e );
1210                 return;
1211         }
1212         if ( oc_schema_info( e ) ) {
1213                 /* Out of memory, do something about it */
1214                 entry_free( e );
1215                 return;
1216         }
1217
1218         val.bv_val = "top";
1219         val.bv_len = sizeof("top")-1;
1220         attr_merge( e, "objectClass", vals );
1221
1222         val.bv_val = "LDAPsubentry";
1223         val.bv_len = sizeof("LDAPsubentry")-1;
1224         attr_merge( e, "objectClass", vals );
1225
1226         val.bv_val = "subschema";
1227         val.bv_len = sizeof("subschema")-1;
1228         attr_merge( e, "objectClass", vals );
1229
1230         val.bv_val = "extensibleObject";
1231         val.bv_len = sizeof("extensibleObject")-1;
1232         attr_merge( e, "objectClass", vals );
1233
1234         send_search_entry( &backends[0], conn, op,
1235                 e, attrs, attrsonly, NULL );
1236         send_search_result( conn, op, LDAP_SUCCESS,
1237                 NULL, NULL, NULL, NULL, 1 );
1238
1239         entry_free( e );
1240 }
1241 #endif
1242
1243 #ifdef LDAP_DEBUG
1244
1245 static void
1246 oc_print( ObjectClass *oc )
1247 {
1248         int     i;
1249         const char *mid;
1250
1251         printf( "objectclass %s\n", ldap_objectclass2name( &oc->soc_oclass ) );
1252         if ( oc->soc_required != NULL ) {
1253                 mid = "\trequires ";
1254                 for ( i = 0; oc->soc_required[i] != NULL; i++, mid = "," )
1255                         printf( "%s%s", mid,
1256                                 ldap_attributetype2name( &oc->soc_required[i]->sat_atype ) );
1257                 printf( "\n" );
1258         }
1259         if ( oc->soc_allowed != NULL ) {
1260                 mid = "\tallows ";
1261                 for ( i = 0; oc->soc_allowed[i] != NULL; i++, mid = "," )
1262                         printf( "%s%s", mid,
1263                                 ldap_attributetype2name( &oc->soc_allowed[i]->sat_atype ) );
1264                 printf( "\n" );
1265         }
1266 }
1267
1268 #endif
1269
1270
1271 int is_entry_objectclass(
1272         Entry*  e,
1273         const char*     oc)
1274 {
1275         Attribute *attr;
1276         struct berval bv;
1277
1278         if( e == NULL || oc == NULL || *oc == '\0' )
1279                 return 0;
1280
1281         /*
1282          * find objectClass attribute
1283          */
1284         attr = attr_find(e->e_attrs, "objectclass");
1285
1286         if( attr == NULL ) {
1287                 /* no objectClass attribute */
1288                 return 0;
1289         }
1290
1291         bv.bv_val = (char *) oc;
1292         bv.bv_len = strlen( bv.bv_val );
1293
1294         if( value_find(attr->a_vals, &bv, attr->a_syntax, 1) != 0) {
1295                 /* entry is not of this objectclass */
1296                 return 0;
1297         }
1298
1299         return 1;
1300 }