git.sur5r.net Git - openldap/blob - servers/slapd/back-ldbm/attr.c

   1 /* attr.c - backend routines for dealing with attributes */
   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/socket.h>
  13 #include <ac/string.h>
  14
  15 #include "slap.h"
  16 #include "back-ldbm.h"
  17
  18
  19 /* for the cache of attribute information (which are indexed, etc.) */
  20 typedef struct ldbm_attrinfo {
  21 #ifdef SLAPD_USE_AD
  22         AttributeDescription *ai_desc; /* attribute description cn;lang-en      */
  23 #else
  24         char *ai_desc;
  25 #endif
  26         slap_mask_t ai_indexmask;       /* how the attr is indexed      */
  27 } AttrInfo;
  28
  29 static int
  30 ainfo_type_cmp(
  31 #ifdef SLAPD_USE_AD
  32         AttributeDescription *desc,
  33 #else
  34     char                *desc,
  35 #endif
  36     AttrInfo    *a
  37 )
  38 {
  39 #ifdef SLAPD_USE_AD
  40         return ad_cmp( desc, a->ai_desc );
  41 #else
  42         return( strcasecmp( desc, a->ai_desc ) );
  43 #endif
  44 }
  45
  46 static int
  47 ainfo_cmp(
  48     AttrInfo    *a,
  49     AttrInfo    *b
  50 )
  51 {
  52 #ifdef SLAPD_USE_AD
  53         return ad_cmp( a->ai_desc, b->ai_desc );
  54 #else
  55         return( strcasecmp( a->ai_desc, b->ai_desc ) );
  56 #endif
  57 }
  58
  59 void
  60 attr_mask(
  61     struct ldbminfo     *li,
  62 #ifdef SLAPD_USE_AD
  63         AttributeDescription *desc,
  64 #else
  65     const char *desc,
  66 #endif
  67     slap_mask_t *indexmask )
  68 {
  69         AttrInfo        *a;
  70
  71         a = (AttrInfo *) avl_find( li->li_attrs, desc,
  72             (AVL_CMP) ainfo_type_cmp );
  73
  74         *indexmask = a != NULL ? a->ai_indexmask : 0;
  75 }
  76
  77 int
  78 attr_index_config(
  79     struct ldbminfo     *li,
  80     const char          *fname,
  81     int                 lineno,
  82     int                 argc,
  83     char                **argv )
  84 {
  85         int rc;
  86         int     i;
  87         slap_mask_t mask;
  88         char **attrs;
  89         char **indexes = NULL;
  90
  91         attrs = str2charray( argv[0], "," );
  92
  93         if( attrs == NULL ) {
  94                 fprintf( stderr, "%s: line %d: "
  95                         "no attributes specified: %s\n",
  96                         fname, lineno, argv[0] );
  97                 return LDAP_PARAM_ERROR;
  98         }
  99
 100         if ( argc > 1 ) {
 101                 indexes = str2charray( argv[1], "," );
 102
 103                 if( indexes == NULL ) {
 104                         fprintf( stderr, "%s: line %d: "
 105                                 "no indexes specified: %s\n",
 106                                 fname, lineno, argv[1] );
 107                         return LDAP_PARAM_ERROR;
 108                 }
 109         }
 110
 111         if( indexes == NULL ) {
 112                 mask = li->li_defaultmask;
 113
 114         } else {
 115                 mask = 0;
 116
 117                 for ( i = 0; indexes[i] != NULL; i++ ) {
 118                         slap_mask_t index;
 119                         rc = slap_str2index( indexes[i], &index );
 120
 121                         if( rc != LDAP_SUCCESS ) {
 122                                 fprintf( stderr, "%s: line %d: "
 123                                         "index type \"%s\" undefined\n",
 124                                         fname, lineno, indexes[i] );
 125                                 return LDAP_PARAM_ERROR;
 126                         }
 127
 128                         mask |= index;
 129                 }
 130         }
 131
 132     if( !mask ) {
 133                 fprintf( stderr, "%s: line %d: "
 134                         "no indexes selected\n",
 135                         fname, lineno );
 136                 return LDAP_PARAM_ERROR;
 137         }
 138
 139         for ( i = 0; attrs[i] != NULL; i++ ) {
 140                 AttrInfo        *a;
 141                 AttributeDescription *ad;
 142                 const char *text;
 143
 144                 if( strcasecmp( attrs[i], "default" ) == 0 ) {
 145                         li->li_defaultmask = mask;
 146                         continue;
 147                 }
 148
 149                 a = (AttrInfo *) ch_malloc( sizeof(AttrInfo) );
 150
 151                 ad = NULL;
 152                 rc = slap_str2ad( attrs[i], &ad, &text );
 153
 154                 if( rc != LDAP_SUCCESS ) {
 155                         fprintf( stderr, "%s: line %d: "
 156                                 "index attribute \"%s\" undefined\n",
 157                                 fname, lineno, attrs[i] );
 158                         return rc;
 159                 }
 160
 161                 if( slap_ad_is_binary( ad ) ) {
 162                         fprintf( stderr, "%s: line %d: "
 163                                 "index of attribute \"%s\" disallowed\n",
 164                                 fname, lineno, attrs[i] );
 165                         return LDAP_UNWILLING_TO_PERFORM;
 166                 }
 167
 168                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) && !(
 169                         ( ad->ad_type->sat_approx
 170                                 && ad->ad_type->sat_approx->smr_indexer
 171                                 && ad->ad_type->sat_approx->smr_filter )
 172                         && ( ad->ad_type->sat_equality
 173                                 && ad->ad_type->sat_equality->smr_indexer
 174                                 && ad->ad_type->sat_equality->smr_filter ) ) )
 175                 {
 176                         fprintf( stderr, "%s: line %d: "
 177                                 "approx index of attribute \"%s\" disallowed\n",
 178                                 fname, lineno, attrs[i] );
 179                         return LDAP_INAPPROPRIATE_MATCHING;
 180                 }
 181
 182                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) && !(
 183                         ad->ad_type->sat_equality
 184                                 && ad->ad_type->sat_equality->smr_indexer
 185                                 && ad->ad_type->sat_equality->smr_filter ) )
 186                 {
 187                         fprintf( stderr, "%s: line %d: "
 188                                 "equality index of attribute \"%s\" disallowed\n",
 189                                 fname, lineno, attrs[i] );
 190                         return LDAP_INAPPROPRIATE_MATCHING;
 191                 }
 192
 193                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) && !(
 194                         ad->ad_type->sat_substr
 195                                 && ad->ad_type->sat_substr->smr_indexer
 196                                 && ad->ad_type->sat_substr->smr_filter ) )
 197                 {
 198                         fprintf( stderr, "%s: line %d: "
 199                                 "substr index of attribute \"%s\" disallowed\n",
 200                                 fname, lineno, attrs[i] );
 201                         return LDAP_INAPPROPRIATE_MATCHING;
 202                 }
 203
 204 #ifdef NEW_LOGGING
 205                 LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
 206                            "attr_index_config: index %s 0x%04x\n",
 207                            ad->ad_cname.bv_val, mask ));
 208 #else
 209                 Debug( LDAP_DEBUG_CONFIG, "index %s 0x%04x\n",
 210                         ad->ad_cname.bv_val, mask, 0 );
 211 #endif
 212
 213
 214 #ifdef SLAPD_USE_AD
 215                 a->ai_desc = ad;
 216 #else
 217                 a->ai_desc = ch_strdup( ad->ad_cname.bv_val );
 218 #endif
 219
 220                 a->ai_indexmask = mask;
 221
 222                 rc = avl_insert( &li->li_attrs, (caddr_t) a,
 223                         (AVL_CMP) ainfo_cmp, (AVL_DUP) avl_dup_error );
 224
 225                 if( rc ) {
 226                         fprintf( stderr, "%s: line %d: duplicate index definition "
 227                                 "for attr \"%s\" (ignored)\n",
 228                             fname, lineno, attrs[i] );
 229
 230                         return LDAP_PARAM_ERROR;
 231                 }
 232         }
 233
 234         charray_free( attrs );
 235         if ( indexes != NULL ) charray_free( indexes );
 236
 237         return LDAP_SUCCESS;
 238 }
 239
 240
 241 static void
 242 ainfo_free( void *attr )
 243 {
 244         AttrInfo *ai = attr;
 245 #ifndef SLAPD_USE_AD
 246         free( ai->ai_desc );
 247 #endif
 248         free( ai );
 249 }
 250
 251 void
 252 attr_index_destroy( Avlnode *tree )
 253 {
 254         avl_free( tree, ainfo_free );
 255 }
 256