]> git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/conn.c
Fixup bdb_entry_release now that entry_decode uses two memory blocks
[openldap] / servers / slapd / back-meta / conn.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 /*
81  * Set PRINT_CONNTREE larger than 0 to dump the connection tree (debug only)
82  */
83 #define PRINT_CONNTREE 0
84
85 /*
86  * meta_back_conn_cmp
87  *
88  * compares two struct metaconn based on the value of the conn pointer;
89  * used by avl stuff
90  */
91 int
92 meta_back_conn_cmp(
93         const void *c1,
94         const void *c2
95         )
96 {
97         struct metaconn *lc1 = ( struct metaconn * )c1;
98         struct metaconn *lc2 = ( struct metaconn * )c2;
99         
100         return ( ( lc1->conn < lc2->conn ) ? -1 :
101                         ( ( lc1->conn > lc2-> conn ) ? 1 : 0 ) );
102 }
103
104 /*
105  * meta_back_conn_dup
106  *
107  * returns -1 in case a duplicate struct metaconn has been inserted;
108  * used by avl stuff
109  */
110 int
111 meta_back_conn_dup(
112         void *c1,
113         void *c2
114         )
115 {
116         struct metaconn *lc1 = ( struct metaconn * )c1;
117         struct metaconn *lc2 = ( struct metaconn * )c2;
118
119         return( ( lc1->conn == lc2->conn ) ? -1 : 0 );
120 }
121
122 /*
123  * Debug stuff (got it from libavl)
124  */
125 #if PRINT_CONNTREE > 0
126 static void
127 ravl_print( Avlnode *root, int depth )
128 {
129         int     i;
130         
131         if ( root == 0 ) {
132                 return;
133         }
134         
135         ravl_print( root->avl_right, depth+1 );
136         
137         for ( i = 0; i < depth; i++ ) {
138                 printf( "    " );
139         }
140
141         printf( "c(%d) %d\n", ( ( struct metaconn * )root->avl_data )->conn->c_connid, root->avl_bf );
142         
143         ravl_print( root->avl_left, depth+1 );
144 }
145
146 static void
147 myprint( Avlnode *root )
148 {
149         printf( "********\n" );
150         
151         if ( root == 0 ) {
152                 printf( "\tNULL\n" );
153         } else {
154                 ravl_print( root, 0 );
155         }
156         
157         printf( "********\n" );
158 }
159 #endif /* PRINT_CONNTREE */
160 /*
161  * End of debug stuff
162  */
163
164 /*
165  * metaconn_alloc
166  * 
167  * Allocates a connection structure, making room for all the referenced targets
168  */
169 static struct metaconn *
170 metaconn_alloc( int ntargets )
171 {
172         struct metaconn *lc;
173         int i;
174
175         assert( ntargets > 0 );
176
177         lc = ch_calloc( sizeof( struct metaconn ), 1 );
178         if ( lc == NULL ) {
179                 return NULL;
180         }
181         
182         /*
183          * make it a null-terminated array ...
184          */
185         lc->conns = ch_calloc( sizeof( struct metasingleconn * ), ntargets+1 );
186         if ( lc->conns == NULL ) {
187                 free( lc );
188                 return NULL;
189         }
190
191         for ( i = 0; i < ntargets; i++ ) {
192                 lc->conns[ i ] =
193                         ch_calloc( sizeof( struct metasingleconn ), 1 );
194                 if ( lc->conns[ i ] == NULL ) {
195                         charray_free( ( char ** )lc->conns );
196                         free( lc->conns );
197                         free( lc );
198                         return NULL;
199                 }
200         }
201
202         lc->bound_target = META_BOUND_NONE;
203
204         return lc;
205 }
206
207 /*
208  * metaconn_free
209  *
210  * clears a metaconn
211  */
212 static void
213 metaconn_free(
214                 struct metaconn *lc
215 )
216 {
217         if ( !lc ) {
218                 return;
219         }
220         
221         if ( lc->conns ) {
222                 int i;
223
224                 for ( i = 0; lc->conns[ i ] != NULL; ++i ) {
225                         free( lc->conns[ i ] );
226                 }
227                 charray_free( ( char ** )lc->conns );
228         }
229
230         free( lc );
231 }
232
233 /*
234  * init_one_conn
235  * 
236  * Initializes one connection
237  */
238 static int
239 init_one_conn(
240                 Connection *conn, 
241                 Operation *op, 
242                 struct metatarget *lt, 
243                 int vers,
244                 struct metasingleconn *lsc
245                 )
246 {
247         int err;
248
249         /*
250          * Already init'ed
251          */
252         if ( lsc->ld != NULL ) {
253                 return LDAP_SUCCESS;
254         }
255        
256         /*
257          * Attempts to initialize the connection to the target ds
258          */
259         err = ldap_initialize( &lsc->ld, lt->uri );
260         if ( err != LDAP_SUCCESS ) {
261                 return ldap_back_map_result( err );
262         }
263         
264         /*
265          * Set LDAP version. This will always succeed: If the client
266          * bound with a particular version, then so can we.
267          */
268         ldap_set_option( lsc->ld, LDAP_OPT_PROTOCOL_VERSION, &vers );
269
270         /*
271          * Sets a cookie for the rewrite session
272          */
273         ( void )rewrite_session_init( lt->rwinfo, conn );
274
275         /*
276          * If the connection dn is not null, an attempt to rewrite it is made
277          */
278         if ( conn->c_cdn != NULL && conn->c_cdn[ 0 ] != '\0' ) {
279                 /*
280                  * Rewrite the bind dn if needed
281                  */
282                 lsc->bound_dn = NULL;
283                 switch ( rewrite_session( lt->rwinfo, "bindDn",
284                                         conn->c_cdn, conn,
285                                         &lsc->bound_dn ) ) {
286                 case REWRITE_REGEXEC_OK:
287                         if ( lsc->bound_dn == NULL ) {
288                                 lsc->bound_dn = ch_strdup( conn->c_cdn );
289                         }
290 #ifdef NEW_LOGGING
291                         LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
292                                         "[rw] bindDn: \"%s\" -> \"%s\"\n",
293                                         conn->c_cdn, lsc->bound_dn ));
294 #else /* !NEW_LOGGING */
295                         Debug( LDAP_DEBUG_ARGS,
296                                         "rw> bindDn: \"%s\" -> \"%s\"\n%s",
297                                         conn->c_cdn, lsc->bound_dn, "" );
298 #endif /* !NEW_LOGGING */
299                         break;
300                         
301                 case REWRITE_REGEXEC_UNWILLING:
302                         send_ldap_result( conn, op,
303                                         LDAP_UNWILLING_TO_PERFORM,
304                                         NULL, "Unwilling to perform",
305                                         NULL, NULL );
306                         return LDAP_UNWILLING_TO_PERFORM;
307                         
308                 case REWRITE_REGEXEC_ERR:
309                         send_ldap_result( conn, op,
310                                         LDAP_OPERATIONS_ERROR,
311                                         NULL, "Operations error",
312                                         NULL, NULL );
313                         return LDAP_OPERATIONS_ERROR;
314                 }
315         } else {
316                 lsc->bound_dn = NULL;
317         }
318
319         lsc->bound = META_UNBOUND;
320
321         /*
322          * The candidate is activated
323          */
324         lsc->candidate = META_CANDIDATE;
325         return LDAP_SUCCESS;
326 }
327
328 /*
329  * meta_back_getconn
330  * 
331  * Prepares the connection structure
332  * 
333  * FIXME: This function needs to receive some info on the type of operation
334  * it is invoked by, so that only the correct pool of candidate targets
335  * is initialized in case no connection was available yet.
336  * 
337  * At present a flag that says whether the candidate target must be unique
338  * is passed; eventually an operation agent will be used.
339  */
340 struct metaconn *
341 meta_back_getconn(
342                 struct metainfo *li,
343                 Connection *conn,
344                 Operation *op,
345                 int op_type,
346                 const char *ndn,
347                 int *candidate
348                 )
349 {
350         struct metaconn *lc, lc_curr;
351         int vers, cached = -1, i = -1, err = LDAP_SUCCESS;
352         int new_conn = 0;
353
354         /* Searches for a metaconn in the avl tree */
355         lc_curr.conn = conn;
356         ldap_pvt_thread_mutex_lock( &li->conn_mutex );
357         lc = (struct metaconn *)avl_find( li->conntree, 
358                 (caddr_t)&lc_curr, meta_back_conn_cmp );
359         ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
360
361         /* Looks like we didn't get a bind. Open a new session... */
362         if ( !lc ) {
363                 lc = metaconn_alloc( li->ntargets );
364                 lc->conn = conn;
365                 new_conn = 1;
366         }
367
368         vers = conn->c_protocol;
369
370         /*
371          * looks in cache, if any
372          */
373         if ( li->cache.ttl != META_DNCACHE_DISABLED ) {
374                 cached = i = meta_dncache_get_target( &li->cache, ndn );
375         }
376
377         if ( op_type == META_OP_REQUIRE_SINGLE ) {
378
379                 /*
380                  * tries to get a unique candidate
381                  * (takes care of default target 
382                  */
383                 if ( i < 0 ) {
384                         i = meta_back_select_unique_candidate( li, ndn );
385                 }
386
387                 /*
388                  * if any is found, inits the connection
389                  */
390                 if ( i < 0 ) {
391                         if ( new_conn ) {
392                                 metaconn_free( lc );
393                         }
394
395                         send_ldap_result( conn, op, LDAP_NO_SUCH_OBJECT,
396                                 NULL, "", NULL, NULL );
397
398                         return NULL;
399                 }
400                                 
401 #ifdef NEW_LOGGING
402                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
403                                 "meta_back_getconn: got target %d"
404                                 " for ndn=\"%s\" from cache\n", i, ndn ));
405 #else /* !NEW_LOGGING */
406                 Debug( LDAP_DEBUG_CACHE,
407         "==>meta_back_getconn: got target %d for ndn=\"%s\" from cache\n%s",
408                                 i, ndn, "" );
409 #endif /* !NEW_LOGGING */
410
411                 /*
412                  * Clear all other candidates
413                  */
414                 ( void )meta_clear_unused_candidates( li, lc, i, 0 );
415
416                 /*
417                  * The target is activated; if needed, it is
418                  * also init'd. In case of error, init_one_conn
419                  * sends the appropriate result.
420                  */
421                 err = init_one_conn( conn, op, li->targets[ i ],
422                                 vers, lc->conns[ i ] );
423                 if ( err != LDAP_SUCCESS ) {
424                 
425                         /*
426                          * FIXME: in case one target cannot
427                          * be init'd, should the other ones
428                          * be tried?
429                          */
430                         ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
431                         if ( new_conn ) {
432                                 metaconn_free( lc );
433                         }
434                         return NULL;
435                 }
436
437                 if ( candidate ) {
438                         *candidate = i;
439                 }
440
441         /*
442          * require all connections ...
443          */
444         } else if (op_type == META_OP_REQUIRE_ALL) {
445                 for ( i = 0; i < li->ntargets; i++ ) {
446
447                         /*
448                          * The target is activated; if needed, it is
449                          * also init'd
450                          */
451                         int lerr = init_one_conn( conn, op, li->targets[ i ],
452                                         vers, lc->conns[ i ] );
453                         if ( lerr != LDAP_SUCCESS ) {
454                                 
455                                 /*
456                                  * FIXME: in case one target cannot
457                                  * be init'd, should the other ones
458                                  * be tried?
459                                  */
460                                 ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
461                                 err = lerr;
462                                 continue;
463                         }
464                 }
465
466         /*
467          * if no unique candidate ...
468          */
469         } else {
470                 int ndnlen = strlen( ndn );     
471                 for ( i = 0; i < li->ntargets; i++ ) {
472                         if ( i == cached 
473                 || meta_back_is_candidate( li->targets[ i ]->suffix,
474                                         ndn, ndnlen ) ) {
475
476                                 /*
477                                  * The target is activated; if needed, it is
478                                  * also init'd
479                                  */
480                                 int lerr = init_one_conn( conn, op,
481                                                 li->targets[ i ],
482                                                 vers, lc->conns[ i ] );
483                                 if ( lerr != LDAP_SUCCESS ) {
484                                 
485                                         /*
486                                          * FIXME: in case one target cannot
487                                          * be init'd, should the other ones
488                                          * be tried?
489                                          */
490                                         ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
491                                         err = lerr;
492                                         continue;
493                                 }
494                         }
495                 }
496         }
497
498         if ( new_conn ) {
499                 
500                 /*
501                  * Inserts the newly created metaconn in the avl tree
502                  */
503                 ldap_pvt_thread_mutex_lock( &li->conn_mutex );
504                 err = avl_insert( &li->conntree, ( caddr_t )lc,
505                                 meta_back_conn_cmp, meta_back_conn_dup );
506
507 #if PRINT_CONNTREE > 0
508                 myprint( li->conntree );
509 #endif /* PRINT_CONNTREE */
510                 
511                 ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
512
513 #ifdef NEW_LOGGING
514                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
515                                 "meta_back_getconn: conn %ld inserted\n",
516                                 lc->conn->c_connid ));
517 #else /* !NEW_LOGGING */
518                 Debug( LDAP_DEBUG_TRACE,
519                         "=>meta_back_getconn: conn %ld inserted\n%s%s",
520                         lc->conn->c_connid, "", "" );
521 #endif /* !NEW_LOGGING */
522                 
523                 /*
524                  * Err could be -1 in case a duplicate metaconn is inserted
525                  */
526                 if ( err != 0 ) {
527                         send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR,
528                         NULL, "Internal server error", NULL, NULL );
529                         metaconn_free( lc );
530                         return NULL;
531                 }
532         } else {
533 #ifdef NEW_LOGGING
534                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
535                                 "meta_back_getconn: conn %ld fetched\n",
536                                 lc->conn->c_connid ));
537 #else /* !NEW_LOGGING */
538                 Debug( LDAP_DEBUG_TRACE,
539                         "=>meta_back_getconn: conn %ld fetched\n%s%s",
540                         lc->conn->c_connid, "", "" );
541 #endif /* !NEW_LOGGING */
542         }
543         
544         return lc;
545 }
546