]> git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/compare.c
Fixup bdb_entry_release now that entry_decode uses two memory blocks
[openldap] / servers / slapd / back-meta / compare.c
1 /*
2  * Copyright 1998-2001 The OpenLDAP Foundation, All Rights Reserved.
3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
4  *
5  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
6  *
7  * This work has been developed to fulfill the requirements
8  * of SysNet s.n.c. <http:www.sys-net.it> and it has been donated
9  * to the OpenLDAP Foundation in the hope that it may be useful
10  * to the Open Source community, but WITHOUT ANY WARRANTY.
11  *
12  * Permission is granted to anyone to use this software for any purpose
13  * on any computer system, and to alter it and redistribute it, subject
14  * to the following restrictions:
15  *
16  * 1. The author and SysNet s.n.c. are not responsible for the consequences
17  *    of use of this software, no matter how awful, even if they arise from 
18  *    flaws in it.
19  *
20  * 2. The origin of this software must not be misrepresented, either by
21  *    explicit claim or by omission.  Since few users ever read sources,
22  *    credits should appear in the documentation.
23  *
24  * 3. Altered versions must be plainly marked as such, and must not be
25  *    misrepresented as being the original software.  Since few users
26  *    ever read sources, credits should appear in the documentation.
27  *    SysNet s.n.c. cannot be responsible for the consequences of the
28  *    alterations.
29  * 
30  * 4. This notice may not be removed or altered.
31  *
32  *
33  * This software is based on the backend back-ldap, implemented
34  * by Howard Chu <hyc@highlandsun.com>, and modified by Mark Valence
35  * <kurash@sassafras.com>, Pierangelo Masarati <ando@sys-net.it> and other
36  * contributors. The contribution of the original software to the present
37  * implementation is acknowledged in this copyright statement.
38  *
39  * A special acknowledgement goes to Howard for the overall architecture
40  * (and for borrowing large pieces of code), and to Mark, who implemented
41  * from scratch the attribute/objectclass mapping.
42  *
43  * The original copyright statement follows.
44  *
45  * Copyright 1999, Howard Chu, All rights reserved. <hyc@highlandsun.com>
46  *
47  * Permission is granted to anyone to use this software for any purpose
48  * on any computer system, and to alter it and redistribute it, subject
49  * to the following restrictions:
50  *
51  * 1. The author is not responsible for the consequences of use of this
52  *    software, no matter how awful, even if they arise from flaws in it.
53  *
54  * 2. The origin of this software must not be misrepresented, either by
55  *    explicit claim or by omission.  Since few users ever read sources,
56  *    credits should appear in the documentation.
57  *
58  * 3. Altered versions must be plainly marked as such, and must not be
59  *    misrepresented as being the original software.  Since few users
60  *    ever read sources, credits should appear in the
61  *    documentation.
62  *
63  * 4. This notice may not be removed or altered.
64  *
65  */
66
67 #include "portable.h"
68
69 #include <stdio.h>
70
71 #include <ac/string.h>
72 #include <ac/socket.h>
73
74 #include "slap.h"
75 #include "../back-ldap/back-ldap.h"
76 #include "back-meta.h"
77
78 int
79 meta_back_compare(
80                 Backend                 *be,
81                 Connection              *conn,
82                 Operation               *op,
83                 const char              *dn,
84                 const char              *ndn,
85                 AttributeAssertion      *ava
86 )
87 {
88         struct metainfo *li = ( struct metainfo * )be->be_private;
89         struct metaconn *lc;
90         struct metasingleconn **lsc;
91         char *match = NULL, *err = NULL, *mmatch = NULL;
92         int candidates = 0, last = 0, i, count, rc;
93         int cres = LDAP_SUCCESS, rres = LDAP_SUCCESS;
94         int *msgid;
95
96         lc = meta_back_getconn( li, conn, op, META_OP_ALLOW_MULTIPLE,
97                         ndn, NULL );
98         if ( !lc || !meta_back_dobind( lc, op ) ) {
99                 return -1;
100         }
101
102         msgid = ch_calloc( sizeof( int ), li->ntargets );
103         if ( msgid == NULL ) {
104                 return -1;
105         }
106
107         /*
108          * start an asynchronous compare for each candidate target
109          */
110         for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
111                 char *mdn = NULL;
112                 char *mapped_attr = ava->aa_desc->ad_cname.bv_val;
113                 char *mapped_value = ava->aa_value->bv_val;
114
115                 if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
116                         continue;
117                 }
118
119                 /*
120                  * Rewrite the compare dn, if needed
121                  */
122                 switch ( rewrite_session( li->targets[ i ]->rwinfo,
123                                         "compareDn", dn, conn, &mdn ) ) {
124                 case REWRITE_REGEXEC_OK:
125                         if ( mdn == NULL ) {
126                                 mdn = ( char * )dn;
127                         }
128 #ifdef NEW_LOGGING
129                         LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
130                                         "[rw] compareDn: \"%s\" -> \"%s\"\n",
131                                         dn, mdn ));
132 #else /* !NEW_LOGGING */
133                         Debug( LDAP_DEBUG_ARGS,
134                                         "rw> compareDn: \"%s\" -> \"%s\"\n%s",
135                                         dn, mdn, "" );
136 #endif /* !NEW_LOGGING */
137                         break;
138                 
139                 case REWRITE_REGEXEC_UNWILLING:
140                         send_ldap_result( conn, op, LDAP_UNWILLING_TO_PERFORM,
141                                         NULL, "Unwilling to perform",
142                                         NULL, NULL );
143                         return -1;
144                         
145                 case REWRITE_REGEXEC_ERR:
146                         send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR,
147                                         NULL, "Operations error",
148                                         NULL, NULL );
149                         return -1;
150                 }
151
152                 /*
153                  * if attr is objectClass, try to remap the value
154                  */
155                 if ( ava->aa_desc->ad_type->sat_oid 
156                         == slap_schema.si_ad_objectClass->ad_type->sat_oid ) {
157                         mapped_value = ldap_back_map( &li->targets[ i ]->oc_map,
158                                         ava->aa_value->bv_val, 0 );
159
160                         if ( mapped_value == NULL ) {
161                                 lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
162                                 continue;
163                         }
164                 /*
165                  * else try to remap the attribute
166                  */
167                 } else {
168                         mapped_attr = ldap_back_map( &li->targets[ i ]->at_map,
169                                 ava->aa_desc->ad_cname.bv_val, 0 );
170                         if ( mapped_attr == NULL ) {
171                                 lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
172                                 continue;
173                         }
174                 }
175                 
176                 /*
177                  * the compare op is spawned across the targets and the first
178                  * that returns determines the result; a constraint on unicity
179                  * of the result ought to be enforced
180                  */
181                 msgid[ i ] = ldap_compare( lc->conns[ i ]->ld, mdn,
182                                 mapped_attr, mapped_value );
183                 if ( msgid[ i ] == -1 ) {
184                         lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
185                         continue;
186                 }
187
188                 if ( mdn != dn ) {
189                         free( mdn );
190                 }
191                 if ( mapped_attr != ava->aa_desc->ad_cname.bv_val ) {
192                         free( mapped_attr );
193                 }
194                 if ( mapped_value != ava->aa_value->bv_val ) {
195                         free( mapped_value );
196                 }
197
198                 ++candidates;
199         }
200
201         /*
202          * wait for replies
203          */
204         for ( rc = 0, count = 0; candidates > 0; ) {
205
206                 /*
207                  * FIXME: should we check for abandon?
208                  */
209                 for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; lsc++, i++ ) {
210                         int lrc;
211                         LDAPMessage *res = NULL;
212
213                         if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
214                                 continue;
215                         }
216
217                         lrc = ldap_result( lsc[ 0 ]->ld, msgid[ i ],
218                                         0, NULL, &res );
219
220                         if ( lrc == 0 ) {
221                                 /*
222                                  * FIXME: should we yield?
223                                  */
224                                 if ( res ) {
225                                         ldap_msgfree( res );
226                                 }
227                                 continue;
228                         } else if ( lrc == LDAP_RES_COMPARE ) {
229                                 if ( count > 0 ) {
230                                         rres = LDAP_OPERATIONS_ERROR;
231                                         rc = -1;
232                                         goto finish;
233                                 }
234                                 
235                                 cres = ldap_result2error( lsc[ 0 ]->ld,
236                                                 res, 1 );
237                                 switch ( cres ) {
238                                 case LDAP_COMPARE_TRUE:
239                                 case LDAP_COMPARE_FALSE:
240
241                                         /*
242                                          * true or flase, got it;
243                                          * sending to cache ...
244                                          */
245                                         if ( li->cache.ttl != META_DNCACHE_DISABLED ) {
246                                                 ( void )meta_dncache_update_entry( &li->cache, ch_strdup( ndn ), i );
247                                         }
248
249                                         count++;
250                                         rc = 0;
251                                         break;
252
253                                 default:
254                                         rres = ldap_back_map_result( cres );
255
256                                         if ( err != NULL ) {
257                                                 free( err );
258                                         }
259                                         ldap_get_option( lsc[ 0 ]->ld,
260                                                 LDAP_OPT_ERROR_STRING, &err );
261
262                                         if ( match != NULL ) {
263                                                 free( match );
264                                         }
265                                         ldap_get_option( lsc[ 0 ]->ld,
266                                                 LDAP_OPT_MATCHED_DN, &match );
267                                         
268                                         last = i;
269                                         break;
270                                 }
271                                 lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
272                                 --candidates;
273                         } else {
274                                 lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
275                                 --candidates;
276                                 if ( res ) {
277                                         ldap_msgfree( res );
278                                 }
279                                 break;
280                         }
281                 }
282         }
283
284 finish:;
285
286         /*
287          * Rewrite the matched portion of the search base, if required
288          * 
289          * FIXME: only the last one gets caught!
290          */
291         if ( count == 1 ) {
292                 if ( match != NULL ) {
293                         free( match );
294                         match = NULL;
295                 }
296                 
297                 /*
298                  * the result of the compare is assigned to the res code
299                  * that will be returned
300                  */
301                 rres = cres;
302                 
303         } else if ( match != NULL ) {
304                 
305                 /*
306                  * At least one compare failed with matched portion,
307                  * and none was successful
308                  */
309                 switch ( rewrite_session( li->targets[ last ]->rwinfo,
310                                         "matchedDn", match, conn, &mmatch ) ) {
311                 case REWRITE_REGEXEC_OK:
312                         if ( mmatch == NULL ) {
313                                 mmatch = ( char * )match;
314                         }
315 #ifdef NEW_LOGGING
316                         LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
317                                         "[rw] matchedDn: \"%s\" -> \"%s\"\n",
318                                         match, mmatch ));
319 #else /* !NEW_LOGGING */
320                         Debug( LDAP_DEBUG_ARGS, "rw> matchedDn:"
321                                         " \"%s\" -> \"%s\"\n%s",
322                                         match, mmatch, "" );
323 #endif /* !NEW_LOGGING */
324                         break;
325                         
326                 
327                 case REWRITE_REGEXEC_UNWILLING:
328                         send_ldap_result( conn, op, LDAP_UNWILLING_TO_PERFORM,
329                                         NULL, "Unwilling to perform",
330                                         NULL, NULL );
331                         rc = -1;
332                         goto cleanup;
333                         
334                 case REWRITE_REGEXEC_ERR:
335                         send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR,
336                                         NULL, "Operations error",
337                                         NULL, NULL );
338                         rc = -1;
339                         goto cleanup;
340                 }
341         }
342
343         send_ldap_result( conn, op, rres, mmatch, err, NULL, NULL );
344
345 cleanup:;
346         if ( match != NULL ) {
347                 if ( mmatch != match ) {
348                         free( mmatch );
349                 }
350                 free( match );
351         }
352
353         if ( msgid ) {
354                 free( msgid );
355         }
356         
357         return rc;
358 }
359