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

   1 /* schema.c - routines to enforce schema definitions */
   2
   3 #include "portable.h"
   4
   5 #include <stdio.h>
   6
   7 #include <ac/string.h>
   8 #include <ac/socket.h>
   9
  10 #include "ldapconfig.h"
  11 #include "slap.h"
  12
  13 static char *   oc_check_required(Entry *e, char *ocname);
  14 static int              oc_check_allowed(char *type, struct berval **ocl);
  15
  16 /*
  17  * oc_check - check that entry e conforms to the schema required by
  18  * its object class(es). returns 0 if so, non-zero otherwise.
  19  */
  20
  21 int
  22 oc_schema_check( Entry *e )
  23 {
  24         Attribute       *a, *aoc;
  25         int             i;
  26         int             ret = 0;
  27
  28         /* find the object class attribute - could error out here */
  29         if ( (aoc = attr_find( e->e_attrs, "objectclass" )) == NULL ) {
  30                 Debug( LDAP_DEBUG_ANY, "No object class for entry (%s)\n",
  31                     e->e_dn, 0, 0 );
  32                 return( 1 );
  33         }
  34
  35         /* check that the entry has required attrs for each oc */
  36         for ( i = 0; aoc->a_vals[i] != NULL; i++ ) {
  37                 char *s = oc_check_required( e, aoc->a_vals[i]->bv_val );
  38
  39                 if (s != NULL) {
  40                         Debug( LDAP_DEBUG_ANY,
  41                             "Entry (%s), oc \"%s\" requires attr \"%s\"\n",
  42                             e->e_dn, aoc->a_vals[i]->bv_val, s );
  43                         ret = 1;
  44                 }
  45         }
  46
  47         if ( ret != 0 ) {
  48             return( ret );
  49         }
  50
  51         /* check that each attr in the entry is allowed by some oc */
  52         for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
  53                 if ( oc_check_allowed( a->a_type, aoc->a_vals ) != 0 ) {
  54                         Debug( LDAP_DEBUG_ANY,
  55                             "Entry (%s), attr \"%s\" not allowed\n",
  56                             e->e_dn, a->a_type, 0 );
  57                         ret = 1;
  58                 }
  59         }
  60
  61         return( ret );
  62 }
  63
  64 static char *
  65 oc_check_required( Entry *e, char *ocname )
  66 {
  67         ObjectClass     *oc;
  68         AttributeType   *at;
  69         int             i;
  70         Attribute       *a;
  71         char            **pp;
  72
  73         Debug( LDAP_DEBUG_TRACE,
  74                "oc_check_required entry (%s), objectclass \"%s\"\n",
  75                e->e_dn, ocname, 0 );
  76
  77         /* find global oc defn. it we don't know about it assume it's ok */
  78         if ( (oc = oc_find( ocname )) == NULL ) {
  79                 return( 0 );
  80         }
  81
  82         /* check for empty oc_required */
  83         if(oc->soc_required == NULL) {
  84                 return( 0 );
  85         }
  86
  87         /* for each required attribute */
  88         for ( i = 0; oc->soc_required[i] != NULL; i++ ) {
  89                 at = oc->soc_required[i];
  90                 /* see if it's in the entry */
  91                 for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
  92                         if ( at->sat_oid &&
  93                              strcmp( a->a_type, at->sat_oid ) == 0 ) {
  94                                 break;
  95                         }
  96                         pp = at->sat_names;
  97                         if ( pp  == NULL ) {
  98                                 /* Empty name list => not found */
  99                                 a = NULL;
 100                                 break;
 101                         }
 102                         while ( *pp ) {
 103                                 if ( strcasecmp( a->a_type, *pp ) == 0 ) {
 104                                         break;
 105                                 }
 106                                 pp++;
 107                         }
 108                         if ( *pp ) {
 109                                 break;
 110                         }
 111                 }
 112                 /* not there => schema violation */
 113                 if ( a == NULL ) {
 114                         if ( at->sat_names && at->sat_names[0] ) {
 115                                 return at->sat_names[0];
 116                         } else {
 117                                 return at->sat_oid;
 118                         }
 119                 }
 120         }
 121
 122         return( NULL );
 123 }
 124
 125 /*
 126  * check to see if attribute is 'operational' or not.
 127  * this function should be externalized...
 128  */
 129 static int
 130 oc_check_operational( char *type )
 131 {
 132         return ( strcasecmp( type, "modifiersname" ) == 0 ||
 133                 strcasecmp( type, "modifytimestamp" ) == 0 ||
 134                 strcasecmp( type, "creatorsname" ) == 0 ||
 135                 strcasecmp( type, "createtimestamp" ) == 0 )
 136                 ? 1 : 0;
 137 }
 138
 139 static int
 140 oc_check_allowed( char *type, struct berval **ocl )
 141 {
 142         ObjectClass     *oc;
 143         AttributeType   *at;
 144         int             i, j;
 145         char            **pp;
 146
 147         Debug( LDAP_DEBUG_TRACE,
 148                "oc_check_allowed type \"%s\"\n", type, 0, 0 );
 149
 150         /* always allow objectclass attribute */
 151         if ( strcasecmp( type, "objectclass" ) == 0 ) {
 152                 return( 0 );
 153         }
 154
 155         if ( oc_check_operational( type ) ) {
 156                 return( 0 );
 157         }
 158
 159         /* check that the type appears as req or opt in at least one oc */
 160         for ( i = 0; ocl[i] != NULL; i++ ) {
 161                 /* if we know about the oc */
 162                 if ( (oc = oc_find( ocl[i]->bv_val )) != NULL ) {
 163                         /* does it require the type? */
 164                         for ( j = 0; oc->soc_required != NULL &&
 165                                 oc->soc_required[j] != NULL; j++ ) {
 166                                 at = oc->soc_required[j];
 167                                 if ( at->sat_oid &&
 168                                      strcmp(at->sat_oid, type ) == 0 ) {
 169                                         return( 0 );
 170                                 }
 171                                 pp = at->sat_names;
 172                                 if ( pp == NULL )
 173                                         continue;
 174                                 while ( *pp ) {
 175                                         if ( strcasecmp( *pp, type ) == 0 ) {
 176                                                 return( 0 );
 177                                         }
 178                                         pp++;
 179                                 }
 180                         }
 181                         /* does it allow the type? */
 182                         for ( j = 0; oc->soc_allowed != NULL &&
 183                                 oc->soc_allowed[j] != NULL; j++ ) {
 184                                 at = oc->soc_allowed[j];
 185                                 if ( at->sat_oid &&
 186                                      strcmp(at->sat_oid, type ) == 0 ) {
 187                                         return( 0 );
 188                                 }
 189                                 pp = at->sat_names;
 190                                 if ( pp == NULL )
 191                                         continue;
 192                                 while ( *pp ) {
 193                                         if ( strcasecmp( *pp, type ) == 0 ||
 194                                              strcmp( *pp, "*" ) == 0 ) {
 195                                                 return( 0 );
 196                                         }
 197                                         pp++;
 198                                 }
 199                         }
 200                         /* maybe the next oc allows it */
 201
 202                 /* we don't know about the oc. assume it allows it */
 203                 } else {
 204                         return( 0 );
 205                 }
 206         }
 207
 208         /* not allowed by any oc */
 209         return( 1 );
 210 }
 211
 212 struct oindexrec {
 213         char            *oir_name;
 214         ObjectClass     *oir_oc;
 215 };
 216
 217 static Avlnode  *oc_index = NULL;
 218 static ObjectClass *oc_list = NULL;
 219
 220 static int
 221 oc_index_cmp(
 222     struct oindexrec    *oir1,
 223     struct oindexrec    *oir2
 224 )
 225 {
 226         return (strcasecmp( oir1->oir_name, oir2->oir_name ));
 227 }
 228
 229 static int
 230 oc_index_name_cmp(
 231     char                *name,
 232     struct oindexrec    *oir
 233 )
 234 {
 235         return (strcasecmp( name, oir->oir_name ));
 236 }
 237
 238 ObjectClass *
 239 oc_find( const char *ocname )
 240 {
 241         struct oindexrec        *oir = NULL;
 242
 243         if ( (oir = (struct oindexrec *) avl_find( oc_index, ocname,
 244             (AVL_CMP) oc_index_name_cmp )) != NULL ) {
 245                 return( oir->oir_oc );
 246         }
 247         return( NULL );
 248 }
 249
 250 static int
 251 oc_create_required(
 252     ObjectClass         *soc,
 253     char                **attrs,
 254     const char          **err
 255 )
 256 {
 257         char            **attrs1;
 258         AttributeType   *sat;
 259         AttributeType   **satp;
 260         int             i;
 261
 262         if ( attrs ) {
 263                 attrs1 = attrs;
 264                 while ( *attrs1 ) {
 265                         sat = at_find(*attrs1);
 266                         if ( !sat ) {
 267                                 *err = *attrs1;
 268                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
 269                         }
 270                         if ( at_find_in_list(sat, soc->soc_required) < 0) {
 271                                 if ( at_append_to_list(sat, &soc->soc_required) ) {
 272                                         *err = *attrs1;
 273                                         return SLAP_SCHERR_OUTOFMEM;
 274                                 }
 275                         }
 276                         attrs1++;
 277                 }
 278                 /* Now delete duplicates from the allowed list */
 279                 for ( satp = soc->soc_required; *satp; satp++ ) {
 280                         i = at_find_in_list(*satp,soc->soc_allowed);
 281                         if ( i >= 0 ) {
 282                                 at_delete_from_list(i, &soc->soc_allowed);
 283                         }
 284                 }
 285         }
 286         return 0;
 287 }
 288
 289 static int
 290 oc_create_allowed(
 291     ObjectClass         *soc,
 292     char                **attrs,
 293     const char          **err
 294 )
 295 {
 296         char            **attrs1;
 297         AttributeType   *sat;
 298
 299         if ( attrs ) {
 300                 attrs1 = attrs;
 301                 while ( *attrs1 ) {
 302                         sat = at_find(*attrs1);
 303                         if ( !sat ) {
 304                                 *err = *attrs1;
 305                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
 306                         }
 307                         if ( at_find_in_list(sat, soc->soc_required) < 0 &&
 308                              at_find_in_list(sat, soc->soc_allowed) < 0 ) {
 309                                 if ( at_append_to_list(sat, &soc->soc_allowed) ) {
 310                                         *err = *attrs1;
 311                                         return SLAP_SCHERR_OUTOFMEM;
 312                                 }
 313                         }
 314                         attrs1++;
 315                 }
 316         }
 317         return 0;
 318 }
 319
 320 static int
 321 oc_add_sups(
 322     ObjectClass         *soc,
 323     char                **sups,
 324     const char          **err
 325 )
 326 {
 327         int             code;
 328         ObjectClass     *soc1;
 329         int             nsups;
 330         char            **sups1;
 331         int             add_sups = 0;
 332
 333         if ( sups ) {
 334                 if ( !soc->soc_sups ) {
 335                         /* We are at the first recursive level */
 336                         add_sups = 1;
 337                         nsups = 0;
 338                         sups1 = sups;
 339                         while ( *sups1 ) {
 340                                 nsups++;
 341                                 sups1++;
 342                         }
 343                         nsups++;
 344                         soc->soc_sups = (ObjectClass **)ch_calloc(1,
 345                                           nsups*sizeof(ObjectClass *));
 346                 }
 347                 nsups = 0;
 348                 sups1 = sups;
 349                 while ( *sups1 ) {
 350                         soc1 = oc_find(*sups1);
 351                         if ( !soc1 ) {
 352                                 *err = *sups1;
 353                                 return SLAP_SCHERR_CLASS_NOT_FOUND;
 354                         }
 355
 356                         if ( add_sups )
 357                                 soc->soc_sups[nsups] = soc1;
 358
 359                         code = oc_add_sups(soc,soc1->soc_sup_oids, err);
 360                         if ( code )
 361                                 return code;
 362
 363                         if ( code = oc_create_required(soc,
 364                                 soc1->soc_at_oids_must,err) )
 365                                 return code;
 366                         if ( code = oc_create_allowed(soc,
 367                                 soc1->soc_at_oids_may,err) )
 368                                 return code;
 369                         nsups++;
 370                         sups1++;
 371                 }
 372         }
 373         return 0;
 374 }
 375
 376 static int
 377 oc_insert(
 378     ObjectClass         *soc,
 379     const char          **err
 380 )
 381 {
 382         ObjectClass     **ocp;
 383         struct oindexrec        *oir;
 384         char                    **names;
 385
 386         ocp = &oc_list;
 387         while ( *ocp != NULL ) {
 388                 ocp = &(*ocp)->soc_next;
 389         }
 390         *ocp = soc;
 391
 392         if ( soc->soc_oid ) {
 393                 oir = (struct oindexrec *)
 394                         ch_calloc( 1, sizeof(struct oindexrec) );
 395                 oir->oir_name = soc->soc_oid;
 396                 oir->oir_oc = soc;
 397                 if ( avl_insert( &oc_index, (caddr_t) oir,
 398                                  (AVL_CMP) oc_index_cmp,
 399                                  (AVL_DUP) avl_dup_error ) ) {
 400                         *err = soc->soc_oid;
 401                         ldap_memfree(oir);
 402                         return SLAP_SCHERR_DUP_CLASS;
 403                 }
 404                 /* FIX: temporal consistency check */
 405                 oc_find(oir->oir_name);
 406         }
 407         if ( (names = soc->soc_names) ) {
 408                 while ( *names ) {
 409                         oir = (struct oindexrec *)
 410                                 ch_calloc( 1, sizeof(struct oindexrec) );
 411                         oir->oir_name = ch_strdup(*names);
 412                         oir->oir_oc = soc;
 413                         if ( avl_insert( &oc_index, (caddr_t) oir,
 414                                          (AVL_CMP) oc_index_cmp,
 415                                          (AVL_DUP) avl_dup_error ) ) {
 416                                 *err = *names;
 417                                 ldap_memfree(oir);
 418                                 return SLAP_SCHERR_DUP_CLASS;
 419                         }
 420                         /* FIX: temporal consistency check */
 421                         oc_find(oir->oir_name);
 422                         names++;
 423                 }
 424         }
 425         return 0;
 426 }
 427
 428 int
 429 oc_add(
 430     LDAP_OBJECT_CLASS   *oc,
 431     const char          **err
 432 )
 433 {
 434         ObjectClass     *soc;
 435         int             code;
 436
 437         soc = (ObjectClass *) ch_calloc( 1, sizeof(ObjectClass) );
 438         memcpy( &soc->soc_oclass, oc, sizeof(LDAP_OBJECT_CLASS));
 439         if ( code = oc_add_sups(soc,soc->soc_sup_oids,err) )
 440                 return code;
 441         if ( code = oc_create_required(soc,soc->soc_at_oids_must,err) )
 442                 return code;
 443         if ( code = oc_create_allowed(soc,soc->soc_at_oids_may,err) )
 444                 return code;
 445         code = oc_insert(soc,err);
 446         return code;
 447 }
 448
 449 struct sindexrec {
 450         char            *sir_name;
 451         Syntax          *sir_syn;
 452 };
 453
 454 static Avlnode  *syn_index = NULL;
 455 static Syntax *syn_list = NULL;
 456
 457 static int
 458 syn_index_cmp(
 459     struct sindexrec    *sir1,
 460     struct sindexrec    *sir2
 461 )
 462 {
 463         return (strcmp( sir1->sir_name, sir2->sir_name ));
 464 }
 465
 466 static int
 467 syn_index_name_cmp(
 468     char                *name,
 469     struct sindexrec    *sir
 470 )
 471 {
 472         return (strcmp( name, sir->sir_name ));
 473 }
 474
 475 Syntax *
 476 syn_find( const char *synname )
 477 {
 478         struct sindexrec        *sir = NULL;
 479
 480         if ( (sir = (struct sindexrec *) avl_find( syn_index, synname,
 481             (AVL_CMP) syn_index_name_cmp )) != NULL ) {
 482                 return( sir->sir_syn );
 483         }
 484         return( NULL );
 485 }
 486
 487 static int
 488 syn_insert(
 489     Syntax              *ssyn,
 490     const char          **err
 491 )
 492 {
 493         Syntax          **synp;
 494         struct sindexrec        *sir;
 495
 496         synp = &syn_list;
 497         while ( *synp != NULL ) {
 498                 synp = &(*synp)->ssyn_next;
 499         }
 500         *synp = ssyn;
 501
 502         if ( ssyn->ssyn_oid ) {
 503                 sir = (struct sindexrec *)
 504                         ch_calloc( 1, sizeof(struct sindexrec) );
 505                 sir->sir_name = ssyn->ssyn_oid;
 506                 sir->sir_syn = ssyn;
 507                 if ( avl_insert( &syn_index, (caddr_t) sir,
 508                                  (AVL_CMP) syn_index_cmp,
 509                                  (AVL_DUP) avl_dup_error ) ) {
 510                         *err = ssyn->ssyn_oid;
 511                         ldap_memfree(sir);
 512                         return SLAP_SCHERR_DUP_SYNTAX;
 513                 }
 514                 /* FIX: temporal consistency check */
 515                 syn_find(sir->sir_name);
 516         }
 517         return 0;
 518 }
 519
 520 int
 521 syn_add(
 522     LDAP_SYNTAX         *syn,
 523     slap_syntax_check_func      *check,
 524     const char          **err
 525 )
 526 {
 527         Syntax          *ssyn;
 528         int             code;
 529
 530         ssyn = (Syntax *) ch_calloc( 1, sizeof(Syntax) );
 531         memcpy( &ssyn->ssyn_syn, syn, sizeof(LDAP_SYNTAX));
 532         ssyn->ssyn_check = check;
 533         code = syn_insert(ssyn,err);
 534         return code;
 535 }
 536
 537 struct mindexrec {
 538         char            *mir_name;
 539         MatchingRule    *mir_mr;
 540 };
 541
 542 static Avlnode  *mr_index = NULL;
 543 static MatchingRule *mr_list = NULL;
 544
 545 static int
 546 mr_index_cmp(
 547     struct mindexrec    *mir1,
 548     struct mindexrec    *mir2
 549 )
 550 {
 551         return (strcmp( mir1->mir_name, mir2->mir_name ));
 552 }
 553
 554 static int
 555 mr_index_name_cmp(
 556     char                *name,
 557     struct mindexrec    *mir
 558 )
 559 {
 560         return (strcmp( name, mir->mir_name ));
 561 }
 562
 563 MatchingRule *
 564 mr_find( const char *mrname )
 565 {
 566         struct mindexrec        *mir = NULL;
 567
 568         if ( (mir = (struct mindexrec *) avl_find( mr_index, mrname,
 569             (AVL_CMP) mr_index_name_cmp )) != NULL ) {
 570                 return( mir->mir_mr );
 571         }
 572         return( NULL );
 573 }
 574
 575 static int
 576 mr_insert(
 577     MatchingRule        *smr,
 578     const char          **err
 579 )
 580 {
 581         MatchingRule            **mrp;
 582         struct mindexrec        *mir;
 583         char                    **names;
 584
 585         mrp = &mr_list;
 586         while ( *mrp != NULL ) {
 587                 mrp = &(*mrp)->smr_next;
 588         }
 589         *mrp = smr;
 590
 591         if ( smr->smr_oid ) {
 592                 mir = (struct mindexrec *)
 593                         ch_calloc( 1, sizeof(struct mindexrec) );
 594                 mir->mir_name = smr->smr_oid;
 595                 mir->mir_mr = smr;
 596                 if ( avl_insert( &mr_index, (caddr_t) mir,
 597                                  (AVL_CMP) mr_index_cmp,
 598                                  (AVL_DUP) avl_dup_error ) ) {
 599                         *err = smr->smr_oid;
 600                         ldap_memfree(mir);
 601                         return SLAP_SCHERR_DUP_RULE;
 602                 }
 603                 /* FIX: temporal consistency check */
 604                 mr_find(mir->mir_name);
 605         }
 606         if ( (names = smr->smr_names) ) {
 607                 while ( *names ) {
 608                         mir = (struct mindexrec *)
 609                                 ch_calloc( 1, sizeof(struct mindexrec) );
 610                         mir->mir_name = ch_strdup(*names);
 611                         mir->mir_mr = smr;
 612                         if ( avl_insert( &mr_index, (caddr_t) mir,
 613                                          (AVL_CMP) mr_index_cmp,
 614                                          (AVL_DUP) avl_dup_error ) ) {
 615                                 *err = *names;
 616                                 ldap_memfree(mir);
 617                                 return SLAP_SCHERR_DUP_RULE;
 618                         }
 619                         /* FIX: temporal consistency check */
 620                         mr_find(mir->mir_name);
 621                         names++;
 622                 }
 623         }
 624         return 0;
 625 }
 626
 627 int
 628 mr_add(
 629     LDAP_MATCHING_RULE          *mr,
 630     slap_mr_normalize_func      *normalize,
 631     slap_mr_compare_func        *compare,
 632     const char          **err
 633 )
 634 {
 635         MatchingRule    *smr;
 636         Syntax          *syn;
 637         int             code;
 638
 639         smr = (MatchingRule *) ch_calloc( 1, sizeof(MatchingRule) );
 640         memcpy( &smr->smr_mrule, mr, sizeof(LDAP_MATCHING_RULE));
 641         smr->smr_normalize = normalize;
 642         smr->smr_compare = compare;
 643         if ( smr->smr_syntax_oid ) {
 644                 if ( (syn = syn_find(smr->smr_syntax_oid)) ) {
 645                         smr->smr_syntax = syn;
 646                 } else {
 647                         *err = smr->smr_syntax_oid;
 648                         return SLAP_SCHERR_SYN_NOT_FOUND;
 649                 }
 650         } else {
 651                 *err = "";
 652                 return SLAP_SCHERR_MR_INCOMPLETE;
 653         }
 654         code = mr_insert(smr,err);
 655         return code;
 656 }
 657
 658 int
 659 register_syntax(
 660         char * desc,
 661         slap_syntax_check_func *check )
 662 {
 663         LDAP_SYNTAX     *syn;
 664         int             code;
 665         const char      *err;
 666
 667         syn = ldap_str2syntax( desc, &code, &err);
 668         if ( !syn ) {
 669                 Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s before %s in %s\n",
 670                     ldap_scherr2str(code), err, desc );
 671                 return( -1 );
 672         }
 673         code = syn_add( syn, check, &err );
 674         if ( code ) {
 675                 Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s %s in %s\n",
 676                     scherr2str(code), err, desc );
 677                 return( -1 );
 678         }
 679         return( 0 );
 680 }
 681
 682 int
 683 register_matching_rule(
 684         char * desc,
 685         slap_mr_normalize_func *normalize,
 686         slap_mr_compare_func *compare )
 687 {
 688         LDAP_MATCHING_RULE *mr;
 689         int             code;
 690         const char      *err;
 691
 692         mr = ldap_str2matchingrule( desc, &code, &err);
 693         if ( !mr ) {
 694                 Debug( LDAP_DEBUG_ANY, "Error in register_matching_rule: %s before %s in %s\n",
 695                     ldap_scherr2str(code), err, desc );
 696                 return( -1 );
 697         }
 698         code = mr_add( mr, normalize, compare, &err );
 699         if ( code ) {
 700                 Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s for %s in %s\n",
 701                     scherr2str(code), err, desc );
 702                 return( -1 );
 703         }
 704         return( 0 );
 705 }
 706
 707 struct syntax_defs_rec {
 708         char *sd_desc;
 709         slap_syntax_check_func *sd_check;
 710 };
 711
 712 struct syntax_defs_rec syntax_defs[] = {
 713         {"( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )", NULL},
 714         {"( 1.3.6.1.4.1.1466.115.121.1.4 DESC 'Audio' )", NULL},
 715         {"( 1.3.6.1.4.1.1466.115.121.1.5 DESC 'Binary' )", NULL},
 716         {"( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )", NULL},
 717         {"( 1.3.6.1.4.1.1466.115.121.1.8 DESC 'Certificate' )", NULL},
 718         {"( 1.3.6.1.4.1.1466.115.121.1.9 DESC 'Certificate List' )", NULL},
 719         {"( 1.3.6.1.4.1.1466.115.121.1.10 DESC 'Certificate Pair' )", NULL},
 720         {"( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'DN' )", NULL},
 721         {"( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )", NULL},
 722         {"( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )", NULL},
 723         {"( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DIT Content Rule Description' )", NULL},
 724         {"( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DIT Structure Rule Description' )", NULL},
 725         {"( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )", NULL},
 726         {"( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number' )", NULL},
 727         {"( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )", NULL},
 728         {"( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )", NULL},
 729         {"( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )", NULL},
 730         {"( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'INTEGER' )", NULL},
 731         {"( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )", NULL},
 732         {"( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'Matching Rule Use Description' )", NULL},
 733         {"( 1.3.6.1.4.1.1466.115.121.1.32 DESC 'Mail Preference' )", NULL},
 734         {"( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )", NULL},
 735         {"( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )", NULL},
 736         {"( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )", NULL},
 737         {"( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )", NULL},
 738         {"( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )", NULL},
 739         {"( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )", NULL},
 740         {"( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )", NULL},
 741         {"( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )", NULL},
 742         {"( 1.3.6.1.4.1.1466.115.121.1.42 DESC 'Protocol Information' )", NULL},
 743         {"( 1.3.6.1.4.1.1466.115.121.1.43 DESC 'Presentation Address' )", NULL},
 744         {"( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )", NULL},
 745         {"( 1.3.6.1.4.1.1466.115.121.1.49 DESC 'Supported Algorithm' )", NULL},
 746         {"( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'Telephone Number' )", NULL},
 747         {"( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'Teletex Terminal Identifier' )", NULL},
 748         {"( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )", NULL},
 749         {"( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )", NULL},
 750         {"( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )", NULL},
 751         {"( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )", NULL},
 752         {"( 1.3.6.1.1.1.0.0 DESC 'NIS netgroup triple' )", NULL},
 753         {"( 1.3.6.1.1.1.0.1 DESC 'Boot parameter' )", NULL},
 754         {NULL, NULL}
 755 };
 756
 757 struct mrule_defs_rec {
 758         char *mrd_desc;
 759         slap_mr_normalize_func *mrd_normalize;
 760         slap_mr_compare_func *mrd_compare;
 761 };
 762
 763 struct mrule_defs_rec mrule_defs[] = {
 764         {"( 2.5.13.0 NAME 'objectIdentifierMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )", NULL, NULL},
 765         {"( 2.5.13.1 NAME 'distinguishedNameMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )", NULL, NULL},
 766         {"( 2.5.13.2 NAME 'caseIgnoreMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )", NULL, NULL},
 767         {"( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )", NULL, NULL},
 768         {"( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )", NULL, NULL},
 769         {"( 2.5.13.8 NAME 'numericStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )", NULL, NULL},
 770         {"( 2.5.13.10 NAME 'numericStringSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )", NULL, NULL},
 771         {"( 2.5.13.11 NAME 'caseIgnoreListMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )", NULL, NULL},
 772         {"( 2.5.13.14 NAME 'integerMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )", NULL, NULL},
 773         {"( 2.5.13.16 NAME 'bitStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )", NULL, NULL},
 774         {"( 2.5.13.17 NAME 'octetStringMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )", NULL, NULL},
 775         {"( 2.5.13.20 NAME 'telephoneNumberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )", NULL, NULL},
 776         {"( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )", NULL, NULL},
 777         {"( 2.5.13.22 NAME 'presentationAddressMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.43 )", NULL, NULL},
 778         {"( 2.5.13.23 NAME 'uniqueMemberMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )", NULL, NULL},
 779         {"( 2.5.13.24 NAME 'protocolInformationMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.42 )", NULL, NULL},
 780         {"( 2.5.13.27 NAME 'generalizedTimeMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )", NULL, NULL},
 781         {"( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )", NULL, NULL},
 782         {"( 2.5.13.29 NAME 'integerFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )", NULL, NULL},
 783         {"( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )", NULL, NULL},
 784         {"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )", NULL, NULL},
 785         {"( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )", NULL, NULL},
 786         {NULL, NULL, NULL}
 787 };
 788
 789 int
 790 schema_init( void )
 791 {
 792         int             res;
 793         int             code;
 794         const char      *err;
 795         int             i;
 796         static int      schema_init_done = 0;
 797
 798         /* We are called from read_config that is recursive */
 799         if ( schema_init_done )
 800                 return( 0 );
 801         for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
 802                 res = register_syntax( syntax_defs[i].sd_desc,
 803                     syntax_defs[i].sd_check );
 804                 if ( res ) {
 805                         fprintf( stderr, "schema_init: Error registering syntax %s\n",
 806                                  syntax_defs[i].sd_desc );
 807                         exit( 1 );
 808                 }
 809         }
 810         for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
 811                 res = register_matching_rule( mrule_defs[i].mrd_desc,
 812                     mrule_defs[i].mrd_normalize,
 813                     mrule_defs[i].mrd_compare );
 814                 if ( res ) {
 815                         fprintf( stderr, "schema_init: Error registering matching rule %s\n",
 816                                  mrule_defs[i].mrd_desc );
 817                         exit( 1 );
 818                 }
 819         }
 820         schema_init_done = 1;
 821         return( 0 );
 822 }
 823
 824 #if defined( SLAPD_SCHEMA_DN )
 825
 826 static int
 827 syn_schema_info( Entry *e )
 828 {
 829         struct berval   val;
 830         struct berval   *vals[2];
 831         Syntax          *syn;
 832
 833         vals[0] = &val;
 834         vals[1] = NULL;
 835
 836         for ( syn = syn_list; syn; syn = syn->ssyn_next ) {
 837                 val.bv_val = ldap_syntax2str( &syn->ssyn_syn );
 838                 if ( val.bv_val ) {
 839                         val.bv_len = strlen( val.bv_val );
 840                         Debug( LDAP_DEBUG_TRACE, "Merging syn [%d] %s\n",
 841                                val.bv_len, val.bv_val, 0 );
 842                         attr_merge( e, "ldapSyntaxes", vals );
 843                         ldap_memfree( val.bv_val );
 844                 } else {
 845                         return -1;
 846                 }
 847         }
 848         return 0;
 849 }
 850
 851 static int
 852 mr_schema_info( Entry *e )
 853 {
 854         struct berval   val;
 855         struct berval   *vals[2];
 856         MatchingRule    *mr;
 857
 858         vals[0] = &val;
 859         vals[1] = NULL;
 860
 861         for ( mr = mr_list; mr; mr = mr->smr_next ) {
 862                 val.bv_val = ldap_matchingrule2str( &mr->smr_mrule );
 863                 if ( val.bv_val ) {
 864                         val.bv_len = strlen( val.bv_val );
 865                         Debug( LDAP_DEBUG_TRACE, "Merging mr [%d] %s\n",
 866                                val.bv_len, val.bv_val, 0 );
 867                         attr_merge( e, "matchingRules", vals );
 868                         ldap_memfree( val.bv_val );
 869                 } else {
 870                         return -1;
 871                 }
 872         }
 873         return 0;
 874 }
 875
 876 static int
 877 oc_schema_info( Entry *e )
 878 {
 879         struct berval   val;
 880         struct berval   *vals[2];
 881         ObjectClass     *oc;
 882
 883         vals[0] = &val;
 884         vals[1] = NULL;
 885
 886         for ( oc = oc_list; oc; oc = oc->soc_next ) {
 887                 val.bv_val = ldap_objectclass2str( &oc->soc_oclass );
 888                 if ( val.bv_val ) {
 889                         val.bv_len = strlen( val.bv_val );
 890                         Debug( LDAP_DEBUG_TRACE, "Merging oc [%d] %s\n",
 891                                val.bv_len, val.bv_val, 0 );
 892                         attr_merge( e, "objectClasses", vals );
 893                         ldap_memfree( val.bv_val );
 894                 } else {
 895                         return -1;
 896                 }
 897         }
 898         return 0;
 899 }
 900
 901 void
 902 schema_info( Connection *conn, Operation *op, char **attrs, int attrsonly )
 903 {
 904         Entry           *e;
 905         struct berval   val;
 906         struct berval   *vals[2];
 907
 908         vals[0] = &val;
 909         vals[1] = NULL;
 910
 911         e = (Entry *) ch_calloc( 1, sizeof(Entry) );
 912
 913         e->e_attrs = NULL;
 914         e->e_dn = ch_strdup( SLAPD_SCHEMA_DN );
 915         e->e_ndn = dn_normalize_case( ch_strdup( SLAPD_SCHEMA_DN ));
 916         e->e_private = NULL;
 917
 918         val.bv_val = ch_strdup( "top" );
 919         val.bv_len = strlen( val.bv_val );
 920         attr_merge( e, "objectclass", vals );
 921         ldap_memfree( val.bv_val );
 922
 923         val.bv_val = ch_strdup( "subschema" );
 924         val.bv_len = strlen( val.bv_val );
 925         attr_merge( e, "objectclass", vals );
 926         ldap_memfree( val.bv_val );
 927
 928         if ( syn_schema_info( e ) ) {
 929                 /* Out of memory, do something about it */
 930                 entry_free( e );
 931                 return;
 932         }
 933         if ( mr_schema_info( e ) ) {
 934                 /* Out of memory, do something about it */
 935                 entry_free( e );
 936                 return;
 937         }
 938         if ( at_schema_info( e ) ) {
 939                 /* Out of memory, do something about it */
 940                 entry_free( e );
 941                 return;
 942         }
 943         if ( oc_schema_info( e ) ) {
 944                 /* Out of memory, do something about it */
 945                 entry_free( e );
 946                 return;
 947         }
 948
 949         send_search_entry( &backends[0], conn, op, e, attrs, attrsonly );
 950         send_ldap_search_result( conn, op, LDAP_SUCCESS, NULL, NULL, 1 );
 951
 952         entry_free( e );
 953 }
 954 #endif
 955
 956 #ifdef LDAP_DEBUG
 957
 958 static void
 959 oc_print( ObjectClass *oc )
 960 {
 961         int     i;
 962
 963         if ( oc->soc_names && oc->soc_names[0] ) {
 964                 printf( "objectclass %s\n", oc->soc_names[0] );
 965         } else {
 966                 printf( "objectclass %s\n", oc->soc_oid );
 967         }
 968         if ( oc->soc_required != NULL ) {
 969                 printf( "\trequires %s", oc->soc_required[0] );
 970                 for ( i = 1; oc->soc_required[i] != NULL; i++ ) {
 971                         printf( ",%s", oc->soc_required[i] );
 972                 }
 973                 printf( "\n" );
 974         }
 975         if ( oc->soc_allowed != NULL ) {
 976                 printf( "\tallows %s", oc->soc_allowed[0] );
 977                 for ( i = 1; oc->soc_allowed[i] != NULL; i++ ) {
 978                         printf( ",%s", oc->soc_allowed[i] );
 979                 }
 980                 printf( "\n" );
 981         }
 982 }
 983
 984 #endif