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

   1 /* schema_init.c - init builtin schema */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2000 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 #include "ldap_pvt.h"
  18 #include "ldap_pvt_uc.h"
  19
  20 int schema_init_done = 0;
  21
  22 struct slap_internal_schema slap_schema;
  23
  24 #define objectClassIndexer NULL
  25 #define objectClassFilter NULL
  26
  27 static int
  28 objectClassMatch(
  29         int *matchp,
  30         slap_mask_t flags,
  31         Syntax *syntax,
  32         MatchingRule *mr,
  33         struct berval *value,
  34         void *assertedValue )
  35 {
  36         struct berval *a = (struct berval *) assertedValue;
  37         ObjectClass *oc = oc_bvfind( value );
  38         ObjectClass *asserted = oc_bvfind( a );
  39
  40         if( asserted == NULL ) {
  41                 if( OID_LEADCHAR( *a->bv_val ) ) {
  42                         /* OID form, return FALSE */
  43                         *matchp = 1;
  44                         return LDAP_SUCCESS;
  45                 }
  46
  47                 /* desc form, return undefined */
  48                 return SLAPD_COMPARE_UNDEFINED;
  49         }
  50
  51         if ( oc == NULL ) {
  52                 /* unrecognized stored value */
  53                 return SLAPD_COMPARE_UNDEFINED;
  54         }
  55
  56         if( SLAP_IS_MR_VALUE_SYNTAX_MATCH( flags ) ) {
  57                 *matchp = ( asserted != oc );
  58         } else {
  59                 *matchp = !is_object_subclass( asserted, oc );
  60         }
  61
  62 #if 0
  63 #ifdef NEW_LOGGING
  64         LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
  65                    "objectClassMatch(%s, %s) = %d\n",
  66                    value->bv_val, a->bv_val, *matchp ));
  67 #else
  68         Debug( LDAP_DEBUG_TRACE, "objectClassMatch(%s,%s) = %d\n",
  69                 value->bv_val, a->bv_val, *matchp );
  70 #endif
  71
  72 #endif
  73
  74         return LDAP_SUCCESS;
  75 }
  76
  77 #define structuralObjectClassIndexer NULL
  78 #define structuralObjectClassFilter NULL
  79
  80 static int
  81 structuralObjectClassMatch(
  82         int *matchp,
  83         slap_mask_t flags,
  84         Syntax *syntax,
  85         MatchingRule *mr,
  86         struct berval *value,
  87         void *assertedValue )
  88 {
  89         struct berval *a = (struct berval *) assertedValue;
  90         ObjectClass *oc = oc_bvfind( value );
  91         ObjectClass *asserted = oc_bvfind( a );
  92
  93         if( asserted == NULL ) {
  94                 if( OID_LEADCHAR( *a->bv_val ) ) {
  95                         /* OID form, return FALSE */
  96                         *matchp = 1;
  97                         return LDAP_SUCCESS;
  98                 }
  99
 100                 /* desc form, return undefined */
 101                 return SLAPD_COMPARE_UNDEFINED;
 102         }
 103
 104         if ( oc == NULL ) {
 105                 /* unrecognized stored value */
 106                 return SLAPD_COMPARE_UNDEFINED;
 107         }
 108
 109         *matchp = ( asserted != oc );
 110
 111 #if 0
 112 #ifdef NEW_LOGGING
 113         LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
 114                    "structuralObjectClassMatch( %s, %s ) = %d\n",
 115                    value->bv_val, a->bv_val, *matchp ));
 116 #else
 117         Debug( LDAP_DEBUG_TRACE, "structuralObjectClassMatch(%s,%s) = %d\n",
 118                 value->bv_val, a->bv_val, *matchp );
 119 #endif
 120 #endif
 121
 122         return LDAP_SUCCESS;
 123 }
 124
 125 static struct slap_schema_oc_map {
 126         char *ssom_name;
 127         size_t ssom_offset;
 128 } oc_map[] = {
 129         { "top", offsetof(struct slap_internal_schema, si_oc_top) },
 130         { "extensibleObject", offsetof(struct slap_internal_schema, si_oc_extensibleObject) },
 131         { "alias", offsetof(struct slap_internal_schema, si_oc_alias) },
 132         { "referral", offsetof(struct slap_internal_schema, si_oc_referral) },
 133         { "LDAProotDSE", offsetof(struct slap_internal_schema, si_oc_rootdse) },
 134         { "LDAPsubentry", offsetof(struct slap_internal_schema, si_oc_subentry) },
 135         { "subschema", offsetof(struct slap_internal_schema, si_oc_subschema) },
 136         { NULL, 0 }
 137 };
 138
 139 static struct slap_schema_ad_map {
 140         char *ssam_name;
 141         slap_mr_match_func *ssam_match;
 142         slap_mr_indexer_func *ssam_indexer;
 143         slap_mr_filter_func *ssam_filter;
 144         size_t ssam_offset;
 145 } ad_map[] = {
 146         { "objectClass",
 147                 objectClassMatch, objectClassIndexer, objectClassFilter,
 148                 offsetof(struct slap_internal_schema, si_ad_objectClass) },
 149         { "structuralObjectClass",
 150                 structuralObjectClassMatch,
 151                 structuralObjectClassIndexer, structuralObjectClassFilter,
 152                 offsetof(struct slap_internal_schema, si_ad_structuralObjectClass) },
 153
 154         /* user entry operational attributes */
 155         { "entryUUID", NULL, NULL, NULL,
 156                 offsetof(struct slap_internal_schema, si_ad_entryUUID) },
 157         { "entryCSN", NULL, NULL, NULL,
 158                 offsetof(struct slap_internal_schema, si_ad_entryCSN) },
 159         { "creatorsName", NULL, NULL, NULL,
 160                 offsetof(struct slap_internal_schema, si_ad_creatorsName) },
 161         { "createTimestamp", NULL, NULL, NULL,
 162                 offsetof(struct slap_internal_schema, si_ad_createTimestamp) },
 163         { "modifiersName", NULL, NULL, NULL,
 164                 offsetof(struct slap_internal_schema, si_ad_modifiersName) },
 165         { "modifyTimestamp", NULL, NULL, NULL,
 166                 offsetof(struct slap_internal_schema, si_ad_modifyTimestamp) },
 167         { "hasSubordinates", NULL, NULL, NULL,
 168                 offsetof(struct slap_internal_schema, si_ad_hasSubordinates) },
 169         { "subschemaSubentry", NULL, NULL, NULL,
 170                 offsetof(struct slap_internal_schema, si_ad_subschemaSubentry) },
 171
 172         /* root DSE attributes */
 173         { "namingContexts", NULL, NULL, NULL,
 174                 offsetof(struct slap_internal_schema, si_ad_namingContexts) },
 175         { "supportedControl", NULL, NULL, NULL,
 176                 offsetof(struct slap_internal_schema, si_ad_supportedControl) },
 177         { "supportedExtension", NULL, NULL, NULL,
 178                 offsetof(struct slap_internal_schema, si_ad_supportedExtension) },
 179         { "supportedLDAPVersion", NULL, NULL, NULL,
 180                 offsetof(struct slap_internal_schema, si_ad_supportedLDAPVersion) },
 181         { "supportedSASLMechanisms", NULL, NULL, NULL,
 182                 offsetof(struct slap_internal_schema, si_ad_supportedSASLMechanisms) },
 183         { "supportedFeatures", NULL, NULL, NULL,
 184                 offsetof(struct slap_internal_schema, si_ad_supportedFeatures) },
 185
 186         /* subschema subentry attributes */
 187         { "attributeTypes", NULL, NULL, NULL,
 188                 offsetof(struct slap_internal_schema, si_ad_attributeTypes) },
 189         { "ldapSyntaxes", NULL, NULL, NULL,
 190                 offsetof(struct slap_internal_schema, si_ad_ldapSyntaxes) },
 191         { "matchingRules", NULL, NULL, NULL,
 192                 offsetof(struct slap_internal_schema, si_ad_matchingRules) },
 193         { "objectClasses", NULL, NULL, NULL,
 194                 offsetof(struct slap_internal_schema, si_ad_objectClasses) },
 195
 196         /* knowledge information */
 197         { "aliasedObjectName", NULL, NULL, NULL,
 198                 offsetof(struct slap_internal_schema, si_ad_aliasedObjectName) },
 199         { "ref", NULL, NULL, NULL,
 200                 offsetof(struct slap_internal_schema, si_ad_ref) },
 201
 202         /* access control internals */
 203         { "entry", NULL, NULL, NULL,
 204                 offsetof(struct slap_internal_schema, si_ad_entry) },
 205         { "children", NULL, NULL, NULL,
 206                 offsetof(struct slap_internal_schema, si_ad_children) },
 207 #ifdef SLAPD_ACI_ENABLED
 208         { "OpenLDAPaci", NULL, NULL, NULL,
 209                 offsetof(struct slap_internal_schema, si_ad_aci) },
 210 #endif
 211
 212         { "userPassword", NULL, NULL, NULL,
 213                 offsetof(struct slap_internal_schema, si_ad_userPassword) },
 214         { "authPassword", NULL, NULL, NULL,
 215                 offsetof(struct slap_internal_schema, si_ad_authPassword) },
 216 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
 217         { "krbName", NULL, NULL, NULL,
 218                 offsetof(struct slap_internal_schema, si_ad_krbName) },
 219 #endif
 220
 221         { NULL, NULL, NULL, NULL, 0 }
 222 };
 223
 224 static AttributeType slap_at_undefined = {
 225         { "1.1.1", NULL, NULL, 1, NULL,
 226                 NULL, NULL, NULL, NULL,
 227                 0, 0, 0, 1, 3 }, /* LDAPAttributeType */
 228         { sizeof( "UNDEFINED" ) - 1, "UNDEFINED" }, /* cname */
 229         NULL, /* sup */
 230         NULL, /* subtypes */
 231         NULL, NULL, NULL, NULL, /* matching rules */
 232         NULL, /* syntax (this may need to be defined) */
 233         NULL, /* attribute description */
 234         NULL  /* next */
 235         /* mutex (don't know how to initialize it :) */
 236 };
 237
 238 static struct slap_schema_mr_map {
 239         char *ssmm_name;
 240         size_t ssmm_offset;
 241 } mr_map[] = {
 242         { "distinguishedNameMatch",
 243                 offsetof(struct slap_internal_schema, si_mr_distinguishedNameMatch) },
 244         { "integerMatch",
 245                 offsetof(struct slap_internal_schema, si_mr_integerMatch) },
 246         { NULL, 0 }
 247 };
 248
 249 static struct slap_schema_syn_map {
 250         char *sssm_name;
 251         size_t sssm_offset;
 252 } syn_map[] = {
 253         { "1.3.6.1.4.1.1466.115.121.1.12",
 254                 offsetof(struct slap_internal_schema, si_syn_distinguishedName) },
 255         { "1.3.6.1.4.1.1466.115.121.1.27",
 256                 offsetof(struct slap_internal_schema, si_syn_integer) },
 257         { NULL, 0 }
 258 };
 259
 260 int
 261 schema_prep( void )
 262 {
 263         int i;
 264         /* we should only be called once after schema_init() was called */
 265         assert( schema_init_done == 1 );
 266
 267         for( i=0; oc_map[i].ssom_name; i++ ) {
 268                 ObjectClass ** ocp = (ObjectClass **)
 269                         &(((char *) &slap_schema)[oc_map[i].ssom_offset]);
 270
 271                 *ocp = oc_find( oc_map[i].ssom_name );
 272
 273                 if( *ocp == NULL ) {
 274                         fprintf( stderr,
 275                                 "No objectClass \"%s\" defined in schema\n",
 276                                 oc_map[i].ssom_name );
 277                         return LDAP_OBJECT_CLASS_VIOLATION;
 278                 }
 279         }
 280
 281         for( i=0; ad_map[i].ssam_name; i++ ) {
 282                 int rc;
 283                 const char *text;
 284
 285                 AttributeDescription ** adp = (AttributeDescription **)
 286                         &(((char *) &slap_schema)[ad_map[i].ssam_offset]);
 287
 288                 *adp = NULL;
 289
 290                 rc = slap_str2ad( ad_map[i].ssam_name, adp, &text );
 291
 292                 if( rc != LDAP_SUCCESS ) {
 293                         fprintf( stderr,
 294                                 "No attribute \"%s\" defined in schema\n",
 295                                 ad_map[i].ssam_name );
 296                         return rc;
 297                 }
 298
 299                 if( ad_map[i].ssam_match ) {
 300                         /* install custom matching routine */
 301                         (*adp)->ad_type->sat_equality->smr_match = ad_map[i].ssam_match;
 302                 }
 303         }
 304
 305         slap_at_undefined.sat_syntax = syn_find( SLAPD_OCTETSTRING_SYNTAX );
 306         if( slap_at_undefined.sat_syntax == NULL ) {
 307                 fprintf( stderr,
 308                         "No octetString syntax \"" SLAPD_OCTETSTRING_SYNTAX "\"\n" );
 309                 return LDAP_INVALID_SYNTAX;
 310         }
 311         slap_schema.si_at_undefined = &slap_at_undefined;
 312
 313         for( i=0; mr_map[i].ssmm_name; i++ ) {
 314                 MatchingRule ** mrp = (MatchingRule **)
 315                         &(((char *) &slap_schema)[mr_map[i].ssmm_offset]);
 316
 317                 *mrp = mr_find( mr_map[i].ssmm_name );
 318
 319                 if( *mrp == NULL ) {
 320                         fprintf( stderr,
 321                                 "No matching rule \"%s\" defined in schema\n",
 322                                 mr_map[i].ssmm_name );
 323                         return LDAP_INAPPROPRIATE_MATCHING;
 324                 }
 325         }
 326
 327         for( i=0; syn_map[i].sssm_name; i++ ) {
 328                 Syntax ** synp = (Syntax **)
 329                         &(((char *) &slap_schema)[syn_map[i].sssm_offset]);
 330
 331                 *synp = syn_find( syn_map[i].sssm_name );
 332
 333                 if( *synp == NULL ) {
 334                         fprintf( stderr,
 335                                 "No syntax \"%s\" defined in schema\n",
 336                                 syn_map[i].sssm_name );
 337                         return LDAP_INVALID_SYNTAX;
 338                 }
 339         }
 340
 341         ++schema_init_done;
 342         return LDAP_SUCCESS;
 343 }