]> git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/bind.c
Fixup bdb_entry_release now that entry_decode uses two memory blocks
[openldap] / servers / slapd / back-meta / bind.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/socket.h>
72 #include <ac/string.h>
73
74
75 #define AVL_INTERNAL
76 #include "slap.h"
77 #include "../back-ldap/back-ldap.h"
78 #include "back-meta.h"
79
80 int
81 meta_back_bind(
82                 Backend         *be,
83                 Connection      *conn,
84                 Operation       *op,
85                 const char      *dn,
86                 const char      *ndn,
87                 int             method,
88                 struct berval   *cred,
89                 char            **edn
90 )
91 {
92         struct metainfo *li = ( struct metainfo * )be->be_private;
93         struct metaconn *lc;
94
95         int rc = -1, i, gotit = 0, ndnlen, isroot = 0;
96         int op_type = META_OP_ALLOW_MULTIPLE;
97         int err = LDAP_SUCCESS;
98
99         char *realdn = (char *)dn;
100         char *realndn = (char *)ndn;
101         char *realcred = cred->bv_val;
102         int realmethod = method;
103
104 #ifdef NEW_LOGGING
105         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
106                         "meta_back_bind: dn: %s.\n", dn ));
107 #else /* !NEW_LOGGING */
108         Debug( LDAP_DEBUG_ARGS, "meta_back_bind: dn: %s.\n%s%s", dn, "", "" );
109 #endif /* !NEW_LOGGING */
110
111         *edn = NULL;
112
113         if ( method == LDAP_AUTH_SIMPLE 
114                         && be_isroot_pw( be, conn, ndn, cred ) ) {
115                 isroot = 1;
116                 *edn = ch_strdup( be_root_dn( be ) );
117                 op_type = META_OP_REQUIRE_ALL;
118         }
119         lc = meta_back_getconn( li, conn, op, op_type, ndn, NULL );
120         if ( !lc ) {
121 #ifdef NEW_LOGGING
122                 LDAP_LOG(( "backend", LDAP_LEVEL_NOTICE,
123                                 "meta_back_bind: no target for dn %s.\n",
124                                 dn ));
125 #else /* !NEW_LOGGING */
126                 Debug( LDAP_DEBUG_ANY,
127                                 "meta_back_bind: no target for dn %s.\n%s%s",
128                                 dn, "", "");
129 #endif /* !NEW_LOGGING */
130                 send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, 
131                                 NULL, NULL, NULL, NULL );
132                 return -1;
133         }
134
135         /*
136          * Each target is scanned ...
137          */
138         lc->bound_target = META_BOUND_NONE;
139         ndnlen = strlen( ndn );
140         for ( i = 0; i < li->ntargets; i++ ) {
141                 int lerr;
142
143                 /*
144                  * Skip non-candidates
145                  */
146                 if ( lc->conns[ i ]->candidate != META_CANDIDATE ) {
147                         continue;
148                 }
149
150                 if ( gotit == 0 ) {
151                         gotit = 1;
152                 } else {
153                         /*
154                          * A bind operation is expected to have
155                          * ONE CANDIDATE ONLY!
156                          */
157 #ifdef NEW_LOGGING
158                         LDAP_LOG(( "backend", LDAP_LEVEL_WARNING,
159                                         "==>meta_back_bind: more than one"
160                                         " candidate is attempting to bind"
161                                         " ...\n" ));
162 #else /* !NEW_LOGGING */
163                         Debug( LDAP_DEBUG_ANY,
164                                         "==>meta_back_bind: more than one"
165                                         " candidate is attempting to bind"
166                                         " ...\n%s%s%s", 
167                                         "", "", "" );
168 #endif /* !NEW_LOGGING */
169                 }
170
171                 if ( isroot && li->targets[ i ]->pseudorootdn != NULL ) {
172                         realdn = li->targets[ i ]->pseudorootdn;
173                         realndn = li->targets[ i ]->pseudorootdn;
174                         realcred = li->targets[ i ]->pseudorootpw;
175                         realmethod = LDAP_AUTH_SIMPLE;
176                 }
177                 
178                 lerr = meta_back_do_single_bind( li, lc,
179                                 realdn, realndn, realcred, realmethod, i );
180                 if ( lerr != LDAP_SUCCESS ) {
181                         err = lerr;
182                         ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
183                 } else {
184                         rc = LDAP_SUCCESS;
185                 }
186         }
187
188         if ( isroot ) {
189                 lc->bound_target = META_BOUND_ALL;
190         }
191
192         /*
193          * rc is LDAP_SUCCESS if at least one bind succeeded,
194          * err is the last error that occurred during a bind;
195          * if at least (and at most?) one bind succeedes, fine.
196          */
197         if ( rc != LDAP_SUCCESS /* && err != LDAP_SUCCESS */ ) {
198                 
199                 /*
200                  * deal with bind failure ...
201                  */
202                 err = ldap_back_map_result( err );
203                 send_ldap_result( conn, op, err, NULL, NULL, NULL, NULL );
204                 return -1;
205         }
206
207         return 0;
208 }
209
210 /*
211  * meta_back_do_single_bind
212  *
213  * attempts to perform a bind with creds
214  */
215 int
216 meta_back_do_single_bind(
217                 struct metainfo         *li,
218                 struct metaconn         *lc,
219                 const char              *dn,
220                 const char              *ndn,
221                 const char              *cred,
222                 int                     method,
223                 int                     candidate
224 )
225 {
226         char *mdn = NULL;
227         int rc;
228         
229         /*
230          * Rewrite the bind dn if needed
231          */
232         switch ( rewrite_session( li->targets[ candidate ]->rwinfo,
233                                 "bindDn", dn, lc->conn, &mdn ) ) {
234         case REWRITE_REGEXEC_OK:
235                 if ( mdn == NULL ) {
236                         mdn = ( char * )dn;
237                 }
238 #ifdef NEW_LOGGING
239                 LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
240                                 "[rw] bindDn: \"%s\" -> \"%s\"\n", dn, mdn ));
241 #else /* !NEW_LOGGING */
242                 Debug( LDAP_DEBUG_ARGS,
243                                 "rw> bindDn: \"%s\" -> \"%s\"\n%s",
244                                 dn, mdn, "" );
245 #endif /* !NEW_LOGGING */
246                 break;
247                 
248         case REWRITE_REGEXEC_UNWILLING:
249                 return LDAP_UNWILLING_TO_PERFORM;
250
251         case REWRITE_REGEXEC_ERR:
252                 return LDAP_OPERATIONS_ERROR;
253         }
254
255         rc = ldap_bind_s( lc->conns[ candidate ]->ld, mdn, cred, method );
256         if ( rc != LDAP_SUCCESS ) {
257                 rc = ldap_back_map_result( rc );
258         } else {
259                 lc->conns[ candidate ]->bound_dn = ch_strdup( dn );
260                 lc->conns[ candidate ]->bound = META_BOUND;
261                 lc->bound_target = candidate;
262
263                 if ( li->cache.ttl != META_DNCACHE_DISABLED
264                                 && ndn[ 0 ] != '\0' ) {
265                         ( void )meta_dncache_update_entry( &li->cache,
266                                         ch_strdup( ndn ), candidate );
267                 }
268         }
269         
270         if ( mdn != dn ) {
271                 free( mdn );
272         }
273
274         return rc;
275 }
276
277 /*
278  * meta_back_dobind
279  */
280 int
281 meta_back_dobind( struct metaconn *lc, Operation *op )
282 {
283         struct metasingleconn **lsc;
284         int bound = 0, i;
285
286         /*
287          * all the targets are bound as pseudoroot
288          */
289         if ( lc->bound_target == META_BOUND_ALL ) {
290                 return 1;
291         }
292
293         for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
294                 int rc;
295
296                 /*
297                  * Not a candidate or something wrong with this target ...
298                  */
299                 if ( lsc[ 0 ]->ld == NULL ) {
300                         continue;
301                 }
302
303                 /*
304                  * If the target is already bound it is skipped
305                  */
306                 if ( lsc[ 0 ]->bound == META_BOUND && lc->bound_target == i ) {
307                         ++bound;
308                         continue;
309                 }
310
311                 /*
312                  * Otherwise an anonymous bind is performed
313                  * (note: if the target was already bound, the anonymous
314                  * bind clears the previous bind).
315                  */
316                 rc = ldap_bind_s( lsc[ 0 ]->ld, lsc[ 0 ]->bound_dn,
317                                 NULL, LDAP_AUTH_SIMPLE );
318                 if ( rc != LDAP_SUCCESS ) {
319                         
320 #ifdef NEW_LOGGING
321                         LDAP_LOG(( "backend", LDAP_LEVEL_WARNING,
322                                         "meta_back_dobind: (anonymous)"
323                                         " bind as \"%s\" failed"
324                                         " with error \"%s\"\n",
325                                         lsc[ 0 ]->bound_dn,
326                                         ldap_err2string( rc ) ));
327 #else /* !NEW_LOGGING */
328                         Debug( LDAP_DEBUG_ANY,
329                                         "==>meta_back_dobind: (anonymous)"
330                                         " bind as \"%s\" failed"
331                                         " with error \"%s\"\n%s",
332                                         lsc[ 0 ]->bound_dn,
333                                         ldap_err2string( rc ), "" );
334 #endif /* !NEW_LOGGING */
335
336                         /*
337                          * null cred bind should always succeed
338                          * as anonymous, so a failure means
339                          * the target is no longer candidate possibly
340                          * due to technical reasons (remote host down?)
341                          * so better clear the handle
342                          */
343                         ( void )meta_clear_one_candidate( lsc[ 0 ], 1 );
344                         continue;
345                 } /* else */
346                 
347                 lsc[ 0 ]->bound = META_ANONYMOUS;
348                 ++bound;
349         }
350
351         return( bound > 0 );
352 }
353
354 /*
355  * FIXME: error return must be handled in a cleaner way ...
356  */
357 int
358 meta_back_op_result( struct metaconn *lc, Operation *op )
359 {
360         int i, rerr = LDAP_SUCCESS;
361         struct metasingleconn **lsc;
362         char *rmsg = NULL;
363         char *rmatch = NULL;
364
365         for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
366                 int err = LDAP_SUCCESS;
367                 char *msg = NULL;
368                 char *match = NULL;
369
370                 ldap_get_option( lsc[ 0 ]->ld, LDAP_OPT_ERROR_NUMBER, &err );
371                 if ( err != LDAP_SUCCESS ) {
372                         /*
373                          * better check the type of error. In some cases
374                          * (search ?) it might be better to return a
375                          * success if at least one of the targets gave
376                          * positive result ...
377                          */
378                         ldap_get_option( lsc[ 0 ]->ld,
379                                         LDAP_OPT_ERROR_STRING, &msg );
380                         ldap_get_option( lsc[ 0 ]->ld,
381                                         LDAP_OPT_MATCHED_DN, &match );
382                         err = ldap_back_map_result( err );
383
384 #ifdef NEW_LOGGING
385                         LDAP_LOG(( "backend", LDAP_DEBUG_NOTICE,
386                                         "meta_back_op_result: target"
387                                         " <%d> sending msg \"%s\""
388                                         " (matched \"%s\")\n",
389                                         i, ( msg ? msg : "" ),
390                                         ( match ? match : "" ) ));
391 #else /* !NEW_LOGGING */
392                         Debug(LDAP_DEBUG_ANY,
393                                         "==> meta_back_op_result: target"
394                                         " <%d> sending msg \"%s\""
395                                         " (matched \"%s\")\n", 
396                                         i, ( msg ? msg : "" ),
397                                         ( match ? match : "" ) );
398 #endif /* !NEW_LOGGING */
399
400                         /*
401                          * FIXME: need to rewrite "match" (need rwinfo)
402                          */
403                         switch ( err ) {
404                         default:
405                                 rerr = err;
406                                 rmsg = msg;
407                                 msg = NULL;
408                                 rmatch = match;
409                                 match = NULL;
410                                 break;
411                         }
412
413                         /* better test the pointers before freeing? */
414                         if ( match ) {
415                                 free( match );
416                         }
417                         if ( msg ) {
418                                 free( msg );
419                         }
420                 }
421         }
422
423         send_ldap_result( lc->conn, op, rerr, rmatch, rmsg, NULL, NULL );
424
425         return ( ( rerr == LDAP_SUCCESS ) ? 0 : -1 );
426 }
427