]> git.sur5r.net Git - openldap/blob - servers/slapd/matchedValues.c
vrFilter -> o_vrFilter
[openldap] / servers / slapd / matchedValues.c
1 /* $OpenLDAP$ */
2 /* 
3  * Copyright 1999-2003 The OpenLDAP Foundation.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms are permitted only
7  * as authorized by the OpenLDAP Public License.  A copy of this
8  * license is available at http://www.OpenLDAP.org/license.html or
9  * in file LICENSE in the top-level directory of the distribution.
10  */
11 #include "portable.h"
12
13 #include <stdio.h>
14
15 #include <ac/string.h>
16 #include <ac/socket.h>
17
18 #include "slap.h"
19
20 static int
21 test_mra_vrFilter(
22         Operation       *op,
23         Attribute       *a,
24         MatchingRuleAssertion *mra,
25         char            ***e_flags
26 );
27
28 static int
29 test_substrings_vrFilter(
30         Operation       *op,
31         Attribute       *a,
32         ValuesReturnFilter *f,
33         char            ***e_flags
34 );
35
36 static int
37 test_presence_vrFilter(
38         Operation       *op,
39         Attribute       *a,
40         AttributeDescription *desc,
41         char            ***e_flags
42 );
43
44 static int
45 test_ava_vrFilter(
46         Operation       *op,
47         Attribute       *a,
48         AttributeAssertion *ava,
49         int             type,
50         char            ***e_flags
51 );
52
53
54 int
55 filter_matched_values( 
56         Operation       *op,
57         Attribute       *a,
58         char            ***e_flags
59 )
60 {
61         ValuesReturnFilter *vrf;
62         int             rc = LDAP_SUCCESS;
63
64 #ifdef NEW_LOGGING
65         LDAP_LOG( FILTER, ENTRY, "filter_matched_values: begin\n", 0, 0, 0 );
66 #else
67         Debug( LDAP_DEBUG_FILTER, "=> filter_matched_values\n", 0, 0, 0 );
68 #endif
69
70         for ( vrf = op->o_vrFilter; vrf != NULL; vrf = vrf->vrf_next ) {
71                 switch ( vrf->vrf_choice ) {
72                 case SLAPD_FILTER_COMPUTED:
73 #ifdef NEW_LOGGING
74                         LDAP_LOG( FILTER, DETAIL1, 
75                                 "test_vrFilter: COMPUTED %s (%d)\n",
76                                 vrf->vrf_result == LDAP_COMPARE_FALSE ? "false" :
77                                 vrf->vrf_result == LDAP_COMPARE_TRUE     ? "true"  :
78                                 vrf->vrf_result == SLAPD_COMPARE_UNDEFINED ? "undefined" :
79                                 "error", vrf->vrf_result, 0 );
80 #else
81                         Debug( LDAP_DEBUG_FILTER, "     COMPUTED %s (%d)\n",
82                                 vrf->vrf_result == LDAP_COMPARE_FALSE ? "false" :
83                                 vrf->vrf_result == LDAP_COMPARE_TRUE ? "true" :
84                                 vrf->vrf_result == SLAPD_COMPARE_UNDEFINED ? "undefined" : "error",
85                                 vrf->vrf_result, 0 );
86 #endif
87                         /*This type of filter does not affect the result */
88                         rc = LDAP_SUCCESS;
89                 break;
90
91                 case LDAP_FILTER_EQUALITY:
92 #ifdef NEW_LOGGING
93                         LDAP_LOG( FILTER, DETAIL1, "test_vrFilter: EQUALITY\n", 0, 0, 0 );
94 #else
95                         Debug( LDAP_DEBUG_FILTER, "     EQUALITY\n", 0, 0, 0 );
96 #endif
97                         rc = test_ava_vrFilter( op, a, vrf->vrf_ava,
98                                 LDAP_FILTER_EQUALITY, e_flags );
99                         if( rc == -1 ) {
100                                 return rc;
101                         }
102                         break;
103
104                 case LDAP_FILTER_SUBSTRINGS:
105 #ifdef NEW_LOGGING
106                         LDAP_LOG( FILTER, DETAIL1, "test_vrFilter  SUBSTRINGS\n", 0, 0, 0 );
107 #else
108                         Debug( LDAP_DEBUG_FILTER, "     SUBSTRINGS\n", 0, 0, 0 );
109 #endif
110
111                         rc = test_substrings_vrFilter( op, a,
112                                 vrf, e_flags );
113                         if( rc == -1 ) {
114                                 return rc;
115                         }
116                         break;
117
118                 case LDAP_FILTER_PRESENT:
119 #ifdef NEW_LOGGING
120                         LDAP_LOG( FILTER, DETAIL1, "test_vrFilter:      PRESENT\n", 0, 0, 0 );
121 #else
122                         Debug( LDAP_DEBUG_FILTER, "     PRESENT\n", 0, 0, 0 );
123 #endif
124                         rc = test_presence_vrFilter( op, a,
125                                 vrf->vrf_desc, e_flags );
126                         if( rc == -1 ) {
127                                 return rc;
128                         }
129                         break;
130
131                 case LDAP_FILTER_GE:
132                         rc = test_ava_vrFilter( op, a, vrf->vrf_ava,
133                                 LDAP_FILTER_GE, e_flags );
134                         if( rc == -1 ) {
135                                 return rc;
136                         }
137                         break;
138
139                 case LDAP_FILTER_LE:
140                         rc = test_ava_vrFilter( op, a, vrf->vrf_ava,
141                                 LDAP_FILTER_LE, e_flags );
142                         if( rc == -1 ) {
143                                 return rc;
144                         }
145                         break;
146
147                 case LDAP_FILTER_EXT:
148 #ifdef NEW_LOGGING
149                         LDAP_LOG( FILTER, DETAIL1, "test_vrFilter:      EXT\n", 0, 0, 0 );
150 #else
151                         Debug( LDAP_DEBUG_FILTER, "     EXT\n", 0, 0, 0 );
152 #endif
153                         rc = test_mra_vrFilter( op, a,
154                                 vrf->vrf_mra, e_flags );
155                         if( rc == -1 ) {
156                                 return rc;
157                         }
158                         break;
159
160                 default:
161 #ifdef NEW_LOGGING
162                         LDAP_LOG( FILTER, INFO, 
163                                 "test_vrFilter:  unknown filter type %lu\n", vrf->vrf_choice, 0, 0 );
164 #else
165                         Debug( LDAP_DEBUG_ANY, "        unknown filter type %lu\n",
166                                 vrf->vrf_choice, 0, 0 );
167 #endif
168                         rc = LDAP_PROTOCOL_ERROR;
169                 } 
170         }
171
172 #ifdef NEW_LOGGING
173         LDAP_LOG( FILTER, ENTRY, "filter_matched_values:  return=%d\n", rc, 0, 0 );
174 #else
175         Debug( LDAP_DEBUG_FILTER, "<= filter_matched_values %d\n", rc, 0, 0 );
176 #endif
177         return( rc );
178 }
179
180 static int
181 test_ava_vrFilter(
182         Operation       *op,
183         Attribute       *a,
184         AttributeAssertion *ava,
185         int             type,
186         char            ***e_flags
187 )
188 {
189         int             i, j;
190
191         for ( i=0; a != NULL; a = a->a_next, i++ ) {
192
193                 MatchingRule *mr;
194                 struct berval *bv;
195         
196                 if ( !is_ad_subtype( a->a_desc, ava->aa_desc ) ) {
197                         continue;
198                 }
199
200                 switch ( type ) {
201                 case LDAP_FILTER_APPROX:
202                         mr = a->a_desc->ad_type->sat_approx;
203                         if( mr != NULL ) break;
204
205                 /* use EQUALITY matching rule if no APPROX rule */
206                 case LDAP_FILTER_EQUALITY:
207                         mr = a->a_desc->ad_type->sat_equality;
208                         break;
209                 
210                 case LDAP_FILTER_GE:
211                 case LDAP_FILTER_LE:
212                         mr = a->a_desc->ad_type->sat_ordering;
213                         break;
214
215                 default:
216                         mr = NULL;
217                 }
218
219                 if( mr == NULL ) {
220                         continue;
221
222                 }
223
224                 bv = a->a_nvals;
225                 for ( j=0; bv->bv_val != NULL; bv++, j++ ) {
226                         int ret;
227                         int rc;
228                         const char *text;
229
230                         rc = value_match( &ret, a->a_desc, mr, 0,
231                                 bv, &ava->aa_value, &text );
232                         if( rc != LDAP_SUCCESS ) {
233                                 return rc;
234                         }
235
236                         switch ( type ) {
237                         case LDAP_FILTER_EQUALITY:
238                         case LDAP_FILTER_APPROX:
239                                 if ( ret == 0 ) {
240                                         (*e_flags)[i][j] = 1;
241                                 }
242                                 break;
243         
244                         case LDAP_FILTER_GE:
245                                 if ( ret >= 0 ) {
246                                         (*e_flags)[i][j] = 1;
247                                 }
248                                 break;
249         
250                         case LDAP_FILTER_LE:
251                                 if ( ret <= 0 ) {
252                                         (*e_flags)[i][j] = 1;
253                                 }
254                                 break;
255                         }
256                 }
257         }
258         return( LDAP_SUCCESS );
259 }
260
261 static int
262 test_presence_vrFilter(
263         Operation       *op,
264         Attribute       *a,
265         AttributeDescription *desc,
266         char            ***e_flags
267 )
268 {
269         int i, j;
270
271         for ( i=0; a != NULL; a = a->a_next, i++ ) {
272                 struct berval *bv;
273
274                 if ( !is_ad_subtype( a->a_desc, desc ) ) {
275                         continue;
276                 }
277
278                 for ( bv = a->a_vals, j=0; bv->bv_val != NULL; bv++, j++ );
279                 memset( (*e_flags)[i], 1, j);
280         }
281
282         return( LDAP_SUCCESS );
283 }
284
285 static int
286 test_substrings_vrFilter(
287         Operation       *op,
288         Attribute       *a,
289         ValuesReturnFilter *vrf,
290         char            ***e_flags
291 )
292 {
293         int i, j;
294
295         for ( i=0; a != NULL; a = a->a_next, i++ ) {
296                 MatchingRule *mr = a->a_desc->ad_type->sat_substr;
297                 struct berval *bv;
298
299                 if ( !is_ad_subtype( a->a_desc, vrf->vrf_sub_desc ) ) {
300                         continue;
301                 }
302
303                 if( mr == NULL ) {
304                         continue;
305                 }
306
307                 bv = a->a_nvals;
308                 for ( j = 0; bv->bv_val != NULL; bv++, j++ ) {
309                         int ret;
310                         int rc;
311                         const char *text;
312
313                         rc = value_match( &ret, a->a_desc, mr, 0,
314                                 bv, vrf->vrf_sub, &text );
315
316                         if( rc != LDAP_SUCCESS ) {
317                                 return rc;
318                         }
319
320                         if ( ret == 0 ) {
321                                 (*e_flags)[i][j] = 1;
322                         }
323                 }
324         }
325
326         return LDAP_SUCCESS;
327 }
328
329 static int
330 test_mra_vrFilter(
331         Operation       *op,
332         Attribute       *a,
333         MatchingRuleAssertion *mra,
334         char            ***e_flags
335 )
336 {
337         int i, j;
338
339         for ( i=0; a != NULL; a = a->a_next, i++ ) {
340                 struct berval *bv, value;
341
342                 if ( mra->ma_desc ) {
343                         if ( !is_ad_subtype( a->a_desc, mra->ma_desc ) ) {
344                                 continue;
345                         }
346                         value = mra->ma_value;
347
348                 } else {
349                         int rc;
350                         const char      *text = NULL;
351
352                         /* check if matching is appropriate */
353                         if ( strcmp( mra->ma_rule->smr_syntax->ssyn_oid,
354                                 a->a_desc->ad_type->sat_syntax->ssyn_oid ) != 0 ) {
355                                 continue;
356                         }
357
358                         rc = asserted_value_validate_normalize( a->a_desc, mra->ma_rule,
359                                 SLAP_MR_EXT|SLAP_MR_VALUE_OF_ASSERTION_SYNTAX,
360                                 &mra->ma_value, &value, &text, op->o_tmpmemctx );
361
362                         if( rc != LDAP_SUCCESS ) continue;
363                 }
364
365                 bv = a->a_nvals;
366                 for ( j = 0; bv->bv_val != NULL; bv++, j++ ) {
367                         int ret;
368                         int rc;
369                         const char *text;
370
371                         rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
372                                 bv, &value, &text );
373                         if( rc != LDAP_SUCCESS ) {
374                                 return rc;
375                         }
376
377                         if ( ret == 0 ) {
378                                 (*e_flags)[i][j] = 1;
379                         }
380                 }
381         }
382
383         return LDAP_SUCCESS;
384 }