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