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