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

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