]> git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/attr.c
comment cleanup
[openldap] / servers / slapd / back-bdb / attr.c
1 /* attr.c - backend routines for dealing with attributes */
2 /* $OpenLDAP$ */
3 /*
4  * Copyright 1998-2003 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-bdb.h"
17
18 /* for the cache of attribute information (which are indexed, etc.) */
19 typedef struct bdb_attrinfo {
20         AttributeDescription *ai_desc; /* attribute description cn;lang-en */
21         slap_mask_t ai_indexmask;       /* how the attr is indexed      */
22 } AttrInfo;
23
24 static int
25 ainfo_type_cmp(
26         const void *v_desc,
27         const void *v_a
28 )
29 {
30         const AttributeDescription *desc = v_desc;
31         const AttrInfo  *a = v_a;
32         return SLAP_PTRCMP(desc, a->ai_desc);
33 }
34
35 static int
36 ainfo_cmp(
37         const void      *v_a,
38         const void      *v_b
39 )
40 {
41         const AttrInfo *a = v_a, *b = v_b;
42         return SLAP_PTRCMP(a->ai_desc, b->ai_desc);
43 }
44
45 void
46 bdb_attr_mask(
47         struct bdb_info *bdb,
48         AttributeDescription *desc,
49         slap_mask_t *indexmask )
50 {
51         AttrInfo        *a;
52
53         a = (AttrInfo *) avl_find( bdb->bi_attrs, desc, ainfo_type_cmp );
54         
55         *indexmask = a != NULL ? a->ai_indexmask : 0;
56 }
57
58 int
59 bdb_attr_index_config(
60         struct bdb_info *bdb,
61         const char              *fname,
62         int                     lineno,
63         int                     argc,
64         char            **argv )
65 {
66         int rc;
67         int     i;
68         slap_mask_t mask;
69         char **attrs;
70         char **indexes = NULL;
71
72         attrs = ldap_str2charray( argv[0], "," );
73
74         if( attrs == NULL ) {
75                 fprintf( stderr, "%s: line %d: "
76                         "no attributes specified: %s\n",
77                         fname, lineno, argv[0] );
78                 return LDAP_PARAM_ERROR;
79         }
80
81         if ( argc > 1 ) {
82                 indexes = ldap_str2charray( argv[1], "," );
83
84                 if( indexes == NULL ) {
85                         fprintf( stderr, "%s: line %d: "
86                                 "no indexes specified: %s\n",
87                                 fname, lineno, argv[1] );
88                         return LDAP_PARAM_ERROR;
89                 }
90         }
91
92         if( indexes == NULL ) {
93                 mask = bdb->bi_defaultmask;
94
95         } else {
96                 mask = 0;
97
98                 for ( i = 0; indexes[i] != NULL; i++ ) {
99                         slap_mask_t index;
100                         rc = slap_str2index( indexes[i], &index );
101
102                         if( rc != LDAP_SUCCESS ) {
103                                 fprintf( stderr, "%s: line %d: "
104                                         "index type \"%s\" undefined\n",
105                                         fname, lineno, indexes[i] );
106                                 return LDAP_PARAM_ERROR;
107                         }
108
109                         mask |= index;
110                 }
111         }
112
113         if( !mask ) {
114                 fprintf( stderr, "%s: line %d: "
115                         "no indexes selected\n",
116                         fname, lineno );
117                 return LDAP_PARAM_ERROR;
118         }
119
120         for ( i = 0; attrs[i] != NULL; i++ ) {
121                 AttrInfo        *a;
122                 AttributeDescription *ad;
123                 const char *text;
124
125                 if( strcasecmp( attrs[i], "default" ) == 0 ) {
126                         bdb->bi_defaultmask = mask;
127                         continue;
128                 }
129
130                 a = (AttrInfo *) ch_malloc( sizeof(AttrInfo) );
131
132                 ad = NULL;
133                 rc = slap_str2ad( attrs[i], &ad, &text );
134
135                 if( rc != LDAP_SUCCESS ) {
136                         fprintf( stderr, "%s: line %d: "
137                                 "index attribute \"%s\" undefined\n",
138                                 fname, lineno, attrs[i] );
139                         return rc;
140                 }
141
142                 if( slap_ad_is_binary( ad ) ) {
143                         fprintf( stderr, "%s: line %d: "
144                                 "index of attribute \"%s\" disallowed\n",
145                                 fname, lineno, attrs[i] );
146                         return LDAP_UNWILLING_TO_PERFORM;
147                 }
148
149                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) && !(
150                         ( ad->ad_type->sat_approx
151                                 && ad->ad_type->sat_approx->smr_indexer
152                                 && ad->ad_type->sat_approx->smr_filter )
153                         && ( ad->ad_type->sat_equality
154                                 && ad->ad_type->sat_equality->smr_indexer
155                                 && ad->ad_type->sat_equality->smr_filter ) ) )
156                 {
157                         fprintf( stderr, "%s: line %d: "
158                                 "approx index of attribute \"%s\" disallowed\n",
159                                 fname, lineno, attrs[i] );
160                         return LDAP_INAPPROPRIATE_MATCHING;
161                 }
162
163                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) && !(
164                         ad->ad_type->sat_equality
165                                 && ad->ad_type->sat_equality->smr_indexer
166                                 && ad->ad_type->sat_equality->smr_filter ) )
167                 {
168                         fprintf( stderr, "%s: line %d: "
169                                 "equality index of attribute \"%s\" disallowed\n",
170                                 fname, lineno, attrs[i] );
171                         return LDAP_INAPPROPRIATE_MATCHING;
172                 }
173
174                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) && !(
175                         ad->ad_type->sat_substr
176                                 && ad->ad_type->sat_substr->smr_indexer
177                                 && ad->ad_type->sat_substr->smr_filter ) )
178                 {
179                         fprintf( stderr, "%s: line %d: "
180                                 "substr index of attribute \"%s\" disallowed\n",
181                                 fname, lineno, attrs[i] );
182                         return LDAP_INAPPROPRIATE_MATCHING;
183                 }
184
185 #ifdef NEW_LOGGING
186                 LDAP_LOG( BACK_BDB, DETAIL1, 
187                         "attr_index_config: index %s 0x%04lx\n",
188                         ad->ad_cname.bv_val, mask, 0 );
189 #else
190                 Debug( LDAP_DEBUG_CONFIG, "index %s 0x%04lx\n",
191                         ad->ad_cname.bv_val, mask, 0 ); 
192 #endif
193
194
195                 a->ai_desc = ad;
196                 a->ai_indexmask = mask;
197
198                 rc = avl_insert( &bdb->bi_attrs, (caddr_t) a,
199                                  ainfo_cmp, avl_dup_error );
200
201                 if( rc ) {
202                         fprintf( stderr, "%s: line %d: duplicate index definition "
203                                 "for attr \"%s\" (ignored)\n",
204                                 fname, lineno, attrs[i] );
205
206                         return LDAP_PARAM_ERROR;
207                 }
208         }
209
210         ldap_charray_free( attrs );
211         if ( indexes != NULL ) ldap_charray_free( indexes );
212
213         return LDAP_SUCCESS;
214 }
215
216 void
217 bdb_attr_index_destroy( Avlnode *tree )
218 {
219         avl_free( tree, free );
220 }
221