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
  19 int schema_init_done = 0;
  20
  21 struct slap_internal_schema slap_schema;
  22
  23 #define objectClassIndexer NULL
  24 #define objectClassFilter NULL
  25
  26 static int
  27 objectClassMatch(
  28         int *matchp,
  29         unsigned flags,
  30         Syntax *syntax,
  31         MatchingRule *mr,
  32         struct berval *value,
  33         void *assertedValue )
  34 {
  35         struct berval *a = (struct berval *) assertedValue;
  36         ObjectClass *oc = oc_find( value->bv_val );
  37         ObjectClass *asserted = oc_find( a->bv_val );
  38
  39         if( asserted == NULL ) {
  40                 if( OID_LEADCHAR( *a->bv_val ) ) {
  41                         /* OID form, return FALSE */
  42                         *matchp = 1;
  43                         return LDAP_SUCCESS;
  44                 }
  45
  46                 /* desc form, return undefined */
  47                 return SLAPD_COMPARE_UNDEFINED;
  48         }
  49
  50         if ( oc == NULL ) {
  51                 /* unrecognized stored value */
  52                 return SLAPD_COMPARE_UNDEFINED;
  53         }
  54
  55         if( flags & SLAP_MR_MODIFY_MATCHING ) {
  56                 *matchp = ( asserted != oc );
  57         } else {
  58                 *matchp = !is_object_subclass( asserted, oc );
  59         }
  60
  61 #if 0
  62         Debug( LDAP_DEBUG_TRACE, "objectClassMatch(%s,%s) = %d\n",
  63                 value->bv_val, a->bv_val, *matchp );
  64 #endif
  65
  66         return LDAP_SUCCESS;
  67 }
  68
  69 #define structuralObjectClassIndexer NULL
  70 #define structuralObjectClassFilter NULL
  71
  72 static int
  73 structuralObjectClassMatch(
  74         int *matchp,
  75         unsigned flags,
  76         Syntax *syntax,
  77         MatchingRule *mr,
  78         struct berval *value,
  79         void *assertedValue )
  80 {
  81         struct berval *a = (struct berval *) assertedValue;
  82         ObjectClass *oc = oc_find( value->bv_val );
  83         ObjectClass *asserted = oc_find( a->bv_val );
  84
  85         if( asserted == NULL ) {
  86                 if( OID_LEADCHAR( *a->bv_val ) ) {
  87                         /* OID form, return FALSE */
  88                         *matchp = 1;
  89                         return LDAP_SUCCESS;
  90                 }
  91
  92                 /* desc form, return undefined */
  93                 return SLAPD_COMPARE_UNDEFINED;
  94         }
  95
  96         if ( oc == NULL ) {
  97                 /* unrecognized stored value */
  98                 return SLAPD_COMPARE_UNDEFINED;
  99         }
 100
 101         *matchp = ( asserted != oc );
 102
 103 #if 0
 104         Debug( LDAP_DEBUG_TRACE, "structuralObjectClassMatch(%s,%s) = %d\n",
 105                 value->bv_val, a->bv_val, *matchp );
 106 #endif
 107
 108         return LDAP_SUCCESS;
 109 }
 110
 111 struct slap_schema_oc_map {
 112         char *ssom_name;
 113         size_t ssom_offset;
 114 } oc_map[] = {
 115         { "top", offsetof(struct slap_internal_schema, si_oc_top) },
 116         { "extensibleObject", offsetof(struct slap_internal_schema, si_oc_extensibleObject) },
 117         { "alias", offsetof(struct slap_internal_schema, si_oc_alias) },
 118         { "referral", offsetof(struct slap_internal_schema, si_oc_referral) },
 119         { "LDAProotDSE", offsetof(struct slap_internal_schema, si_oc_rootdse) },
 120         { "LDAPsubentry", offsetof(struct slap_internal_schema, si_oc_subentry) },
 121         { "subschema", offsetof(struct slap_internal_schema, si_oc_subschema) },
 122         { NULL, 0 }
 123 };
 124
 125 struct slap_schema_ad_map {
 126         char *ssam_name;
 127         slap_mr_match_func *ssam_match;
 128         slap_mr_indexer_func *ssam_indexer;
 129         slap_mr_filter_func *ssam_filter;
 130         size_t ssam_offset;
 131 } ad_map[] = {
 132         { "objectClass",
 133                 objectClassMatch, objectClassIndexer, objectClassFilter,
 134                 offsetof(struct slap_internal_schema, si_ad_objectClass) },
 135         { "structuralObjectClass",
 136                 structuralObjectClassMatch,
 137                 structuralObjectClassIndexer, structuralObjectClassFilter,
 138                 offsetof(struct slap_internal_schema, si_ad_structuralObjectClass) },
 139
 140         /* user entry operational attributes */
 141         { "creatorsName", NULL, NULL, NULL,
 142                 offsetof(struct slap_internal_schema, si_ad_creatorsName) },
 143         { "createTimestamp", NULL, NULL, NULL,
 144                 offsetof(struct slap_internal_schema, si_ad_createTimestamp) },
 145         { "modifiersName", NULL, NULL, NULL,
 146                 offsetof(struct slap_internal_schema, si_ad_modifiersName) },
 147         { "modifyTimestamp", NULL, NULL, NULL,
 148                 offsetof(struct slap_internal_schema, si_ad_modifyTimestamp) },
 149         { "subschemaSubentry", NULL, NULL, NULL,
 150                 offsetof(struct slap_internal_schema, si_ad_subschemaSubentry) },
 151
 152         /* root DSE attributes */
 153         { "namingContexts", NULL, NULL, NULL,
 154                 offsetof(struct slap_internal_schema, si_ad_namingContexts) },
 155         { "supportedControl", NULL, NULL, NULL,
 156                 offsetof(struct slap_internal_schema, si_ad_supportedControl) },
 157         { "supportedExtension", NULL, NULL, NULL,
 158                 offsetof(struct slap_internal_schema, si_ad_supportedExtension) },
 159         { "supportedLDAPVersion", NULL, NULL, NULL,
 160                 offsetof(struct slap_internal_schema, si_ad_supportedLDAPVersion) },
 161         { "supportedSASLMechanisms", NULL, NULL, NULL,
 162                 offsetof(struct slap_internal_schema, si_ad_supportedSASLMechanisms) },
 163
 164         /* subschema subentry attributes */
 165         { "attributeTypes", NULL, NULL, NULL,
 166                 offsetof(struct slap_internal_schema, si_ad_attributeTypes) },
 167         { "ldapSyntaxes", NULL, NULL, NULL,
 168                 offsetof(struct slap_internal_schema, si_ad_ldapSyntaxes) },
 169         { "matchingRules", NULL, NULL, NULL,
 170                 offsetof(struct slap_internal_schema, si_ad_matchingRules) },
 171         { "objectClasses", NULL, NULL, NULL,
 172                 offsetof(struct slap_internal_schema, si_ad_objectClasses) },
 173
 174         /* knowledge information */
 175         { "aliasedObjectName", NULL, NULL, NULL,
 176                 offsetof(struct slap_internal_schema, si_ad_aliasedObjectName) },
 177         { "ref", NULL, NULL, NULL,
 178                 offsetof(struct slap_internal_schema, si_ad_ref) },
 179
 180         /* access control internals */
 181         { "entry", NULL, NULL, NULL,
 182                 offsetof(struct slap_internal_schema, si_ad_entry) },
 183         { "children", NULL, NULL, NULL,
 184                 offsetof(struct slap_internal_schema, si_ad_children) },
 185 #ifdef SLAPD_ACI_ENABLED
 186         { "OpenLDAPaci", NULL, NULL, NULL,
 187                 offsetof(struct slap_internal_schema, si_ad_aci) },
 188 #endif
 189
 190         { "userPassword", NULL, NULL, NULL,
 191                 offsetof(struct slap_internal_schema, si_ad_userPassword) },
 192         { "authPassword", NULL, NULL, NULL,
 193                 offsetof(struct slap_internal_schema, si_ad_authPassword) },
 194 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
 195         { "krbName", NULL, NULL, NULL,
 196                 offsetof(struct slap_internal_schema, si_ad_krbName) },
 197 #endif
 198
 199         { NULL, NULL, NULL, NULL, 0 }
 200 };
 201
 202 static AttributeType slap_at_undefined = {
 203         "UNDEFINED", /* cname */
 204         { "1.1.1", NULL, NULL, 1, NULL,
 205                 NULL, NULL, NULL, NULL,
 206                 0, 0, 0, 1, 3 },
 207         NULL, /* sup */
 208         NULL, /* subtypes */
 209         NULL, NULL, NULL, NULL, /* matching rules */
 210         NULL, /* syntax (this may need to be defined) */
 211         NULL  /* next */
 212 };
 213
 214 int
 215 schema_prep( void )
 216 {
 217         int i;
 218         /* we should only be called once after schema_init() was called */
 219         assert( schema_init_done == 1 );
 220
 221         for( i=0; oc_map[i].ssom_name; i++ ) {
 222                 ObjectClass ** ocp = (ObjectClass **)
 223                         &(((char *) &slap_schema)[oc_map[i].ssom_offset]);
 224
 225                 *ocp = oc_find( oc_map[i].ssom_name );
 226
 227                 if( *ocp == NULL ) {
 228                         fprintf( stderr,
 229                                 "No objectClass \"%s\" defined in schema\n",
 230                                 oc_map[i].ssom_name );
 231                         return LDAP_OBJECT_CLASS_VIOLATION;
 232                 }
 233         }
 234
 235         for( i=0; ad_map[i].ssam_name; i++ ) {
 236                 int rc;
 237                 const char *text;
 238
 239                 AttributeDescription ** adp = (AttributeDescription **)
 240                         &(((char *) &slap_schema)[ad_map[i].ssam_offset]);
 241
 242                 *adp = NULL;
 243
 244                 rc = slap_str2ad( ad_map[i].ssam_name, adp, &text );
 245
 246                 if( rc != LDAP_SUCCESS ) {
 247                         fprintf( stderr,
 248                                 "No attribute \"%s\" defined in schema\n",
 249                                 ad_map[i].ssam_name );
 250                         return rc;
 251                 }
 252
 253                 if( ad_map[i].ssam_match ) {
 254                         /* install custom matching routine */
 255                         (*adp)->ad_type->sat_equality->smr_match = ad_map[i].ssam_match;
 256                 }
 257         }
 258
 259         slap_at_undefined.sat_syntax = syn_find( SLAPD_OCTETSTRING_SYNTAX );
 260         if( slap_at_undefined.sat_syntax == NULL ) {
 261                 fprintf( stderr,
 262                         "No octetString syntax \"" SLAPD_OCTETSTRING_SYNTAX "\"\n" );
 263                 return LDAP_INVALID_SYNTAX;
 264         }
 265         slap_schema.si_at_undefined = &slap_at_undefined;
 266
 267         ++schema_init_done;
 268         return LDAP_SUCCESS;
 269 }