]> git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/conn.c
unifdef -UNEW_LOGGING
[openldap] / servers / slapd / back-meta / conn.c
1 /* $OpenLDAP$ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  *
4  * Copyright 1999-2004 The OpenLDAP Foundation.
5  * Portions Copyright 2001-2003 Pierangelo Masarati.
6  * Portions Copyright 1999-2003 Howard Chu.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted only as authorized by the OpenLDAP
11  * Public License.
12  *
13  * A copy of this license is available in the file LICENSE in the
14  * top-level directory of the distribution or, alternatively, at
15  * <http://www.OpenLDAP.org/license.html>.
16  */
17 /* ACKNOWLEDGEMENTS:
18  * This work was initially developed by the Howard Chu for inclusion
19  * in OpenLDAP Software and subsequently enhanced by Pierangelo
20  * Masarati.
21  */
22
23 #include "portable.h"
24
25 #include <stdio.h>
26
27 #include <ac/socket.h>
28 #include <ac/string.h>
29
30
31 #define AVL_INTERNAL
32 #include "slap.h"
33 #include "../back-ldap/back-ldap.h"
34 #include "back-meta.h"
35
36 /*
37  * Set PRINT_CONNTREE larger than 0 to dump the connection tree (debug only)
38  */
39 #define PRINT_CONNTREE 0
40
41 /*
42  * meta_back_conn_cmp
43  *
44  * compares two struct metaconn based on the value of the conn pointer;
45  * used by avl stuff
46  */
47 int
48 meta_back_conn_cmp(
49         const void *c1,
50         const void *c2
51         )
52 {
53         struct metaconn *lc1 = ( struct metaconn * )c1;
54         struct metaconn *lc2 = ( struct metaconn * )c2;
55         
56         return SLAP_PTRCMP( lc1->conn, lc2->conn );
57 }
58
59 /*
60  * meta_back_conn_dup
61  *
62  * returns -1 in case a duplicate struct metaconn has been inserted;
63  * used by avl stuff
64  */
65 int
66 meta_back_conn_dup(
67         void *c1,
68         void *c2
69         )
70 {
71         struct metaconn *lc1 = ( struct metaconn * )c1;
72         struct metaconn *lc2 = ( struct metaconn * )c2;
73
74         return( ( lc1->conn == lc2->conn ) ? -1 : 0 );
75 }
76
77 /*
78  * Debug stuff (got it from libavl)
79  */
80 #if PRINT_CONNTREE > 0
81 static void
82 ravl_print( Avlnode *root, int depth )
83 {
84         int     i;
85         
86         if ( root == 0 ) {
87                 return;
88         }
89         
90         ravl_print( root->avl_right, depth+1 );
91         
92         for ( i = 0; i < depth; i++ ) {
93                 printf( "    " );
94         }
95
96         printf( "c(%d) %d\n", ( ( struct metaconn * )root->avl_data )->conn->c_connid, root->avl_bf );
97         
98         ravl_print( root->avl_left, depth+1 );
99 }
100
101 static void
102 myprint( Avlnode *root )
103 {
104         printf( "********\n" );
105         
106         if ( root == 0 ) {
107                 printf( "\tNULL\n" );
108         } else {
109                 ravl_print( root, 0 );
110         }
111         
112         printf( "********\n" );
113 }
114 #endif /* PRINT_CONNTREE */
115 /*
116  * End of debug stuff
117  */
118
119 /*
120  * metaconn_alloc
121  * 
122  * Allocates a connection structure, making room for all the referenced targets
123  */
124 static struct metaconn *
125 metaconn_alloc( int ntargets )
126 {
127         struct metaconn *lc;
128
129         assert( ntargets > 0 );
130
131         lc = ch_calloc( sizeof( struct metaconn ), 1 );
132         if ( lc == NULL ) {
133                 return NULL;
134         }
135         
136         /*
137          * make it a null-terminated array ...
138          */
139         lc->conns = ch_calloc( sizeof( struct metasingleconn ), ntargets+1 );
140         if ( lc->conns == NULL ) {
141                 free( lc );
142                 return NULL;
143         }
144         lc->conns[ ntargets ].candidate = META_LAST_CONN;
145
146         for ( ; ntargets-- > 0; ) {
147                 lc->conns[ ntargets ].ld = NULL;
148                 lc->conns[ ntargets ].bound_dn.bv_val = NULL;
149                 lc->conns[ ntargets ].bound_dn.bv_len = 0;
150                 lc->conns[ ntargets ].cred.bv_val = NULL;
151                 lc->conns[ ntargets ].cred.bv_len = 0;
152                 lc->conns[ ntargets ].bound = META_UNBOUND;
153         }
154
155         lc->bound_target = META_BOUND_NONE;
156
157         return lc;
158 }
159
160 /*
161  * metaconn_free
162  *
163  * clears a metaconn
164  */
165 static void
166 metaconn_free(
167                 struct metaconn *lc
168 )
169 {
170         if ( !lc ) {
171                 return;
172         }
173         
174         if ( lc->conns ) {
175                 ch_free( lc->conns );
176         }
177
178         free( lc );
179 }
180
181 /*
182  * init_one_conn
183  * 
184  * Initializes one connection
185  */
186 static int
187 init_one_conn(
188                 Operation               *op,
189                 SlapReply               *rs,
190                 struct metatarget       *lt, 
191                 struct metasingleconn   *lsc
192                 )
193 {
194         struct metainfo *li = ( struct metainfo * )op->o_bd->be_private;
195         int             vers;
196         dncookie        dc;
197
198         /*
199          * Already init'ed
200          */
201         if ( lsc->ld != NULL ) {
202                 return LDAP_SUCCESS;
203         }
204        
205         /*
206          * Attempts to initialize the connection to the target ds
207          */
208         rs->sr_err = ldap_initialize( &lsc->ld, lt->uri );
209         if ( rs->sr_err != LDAP_SUCCESS ) {
210                 return slap_map_api2result( rs );
211         }
212
213         /*
214          * Set LDAP version. This will always succeed: If the client
215          * bound with a particular version, then so can we.
216          */
217         vers = op->o_conn->c_protocol;
218         ldap_set_option( lsc->ld, LDAP_OPT_PROTOCOL_VERSION, &vers );
219         /* FIXME: configurable? */
220         ldap_set_option(lsc->ld, LDAP_OPT_REFERRALS, LDAP_OPT_ON);
221
222         /*
223          * Set the network timeout if set
224          */
225         if (li->network_timeout != 0){
226                 struct timeval network_timeout;
227
228                 network_timeout.tv_usec = 0;
229                 network_timeout.tv_sec = li->network_timeout;
230
231                 ldap_set_option( lsc->ld, LDAP_OPT_NETWORK_TIMEOUT, (void *) &network_timeout);
232         }
233
234         /*
235          * Sets a cookie for the rewrite session
236          */
237         ( void )rewrite_session_init( lt->rwmap.rwm_rw, op->o_conn );
238
239         /*
240          * If the connection dn is not null, an attempt to rewrite it is made
241          */
242         if ( op->o_conn->c_dn.bv_len != 0 ) {
243                 dc.rwmap = &lt->rwmap;
244                 dc.conn = op->o_conn;
245                 dc.rs = rs;
246                 dc.ctx = "bindDN";
247                 
248                 /*
249                  * Rewrite the bind dn if needed
250                  */
251                 if ( ldap_back_dn_massage( &dc, &op->o_conn->c_dn,
252                                         &lsc->bound_dn) ) {
253                         send_ldap_result( op, rs );
254                         return rs->sr_err;
255                 }
256
257                 /* copy the DN idf needed */
258                 if ( lsc->bound_dn.bv_val == op->o_conn->c_dn.bv_val ) {
259                         ber_dupbv( &lsc->bound_dn, &op->o_conn->c_dn );
260                 }
261
262                 assert( lsc->bound_dn.bv_val );
263
264         } else {
265                 ber_str2bv( "", 0, 1, &lsc->bound_dn );
266         }
267
268         lsc->bound = META_UNBOUND;
269
270         /*
271          * The candidate is activated
272          */
273         lsc->candidate = META_CANDIDATE;
274         return LDAP_SUCCESS;
275 }
276
277 /*
278  * meta_back_getconn
279  * 
280  * Prepares the connection structure
281  * 
282  * FIXME: This function needs to receive some info on the type of operation
283  * it is invoked by, so that only the correct pool of candidate targets
284  * is initialized in case no connection was available yet.
285  * 
286  * At present a flag that says whether the candidate target must be unique
287  * is passed; eventually an operation agent will be used.
288  */
289 struct metaconn *
290 meta_back_getconn(
291                 Operation       *op,
292                 SlapReply       *rs,
293                 int             op_type,
294                 struct berval   *ndn,
295                 int             *candidate )
296 {
297         struct metainfo *li = ( struct metainfo * )op->o_bd->be_private;
298         struct metaconn *lc, lc_curr;
299         int cached = -1, i = -1, err = LDAP_SUCCESS;
300         int new_conn = 0;
301
302         /* Searches for a metaconn in the avl tree */
303         lc_curr.conn = op->o_conn;
304         ldap_pvt_thread_mutex_lock( &li->conn_mutex );
305         lc = (struct metaconn *)avl_find( li->conntree, 
306                 (caddr_t)&lc_curr, meta_back_conn_cmp );
307         ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
308
309         /* Looks like we didn't get a bind. Open a new session... */
310         if ( !lc ) {
311                 lc = metaconn_alloc( li->ntargets );
312                 lc->conn = op->o_conn;
313                 new_conn = 1;
314         }
315
316         /*
317          * looks in cache, if any
318          */
319         if ( li->cache.ttl != META_DNCACHE_DISABLED ) {
320                 cached = i = meta_dncache_get_target( &li->cache, ndn );
321         }
322
323         if ( op_type == META_OP_REQUIRE_SINGLE ) {
324
325                 /*
326                  * tries to get a unique candidate
327                  * (takes care of default target 
328                  */
329                 if ( i < 0 ) {
330                         i = meta_back_select_unique_candidate( li, ndn );
331                 }
332
333                 /*
334                  * if any is found, inits the connection
335                  */
336                 if ( i < 0 ) {
337                         if ( new_conn ) {
338                                 metaconn_free( lc );
339                         }
340
341                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
342                         return NULL;
343                 }
344                                 
345                 Debug( LDAP_DEBUG_CACHE,
346         "==>meta_back_getconn: got target %d for ndn=\"%s\" from cache\n%s",
347                                 i, ndn->bv_val, "" );
348
349                 /*
350                  * Clear all other candidates
351                  */
352                 ( void )meta_clear_unused_candidates( li, lc, i, 0 );
353
354                 /*
355                  * The target is activated; if needed, it is
356                  * also init'd. In case of error, init_one_conn
357                  * sends the appropriate result.
358                  */
359                 err = init_one_conn( op, rs, li->targets[ i ],
360                                 &lc->conns[ i ] );
361                 if ( err != LDAP_SUCCESS ) {
362                 
363                         /*
364                          * FIXME: in case one target cannot
365                          * be init'd, should the other ones
366                          * be tried?
367                          */
368                         ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
369                         if ( new_conn ) {
370                                 metaconn_free( lc );
371                         }
372                         return NULL;
373                 }
374
375                 if ( candidate ) {
376                         *candidate = i;
377                 }
378
379         /*
380          * require all connections ...
381          */
382         } else if (op_type == META_OP_REQUIRE_ALL) {
383                 for ( i = 0; i < li->ntargets; i++ ) {
384
385                         /*
386                          * The target is activated; if needed, it is
387                          * also init'd
388                          */
389                         int lerr = init_one_conn( op, rs, li->targets[ i ],
390                                         &lc->conns[ i ] );
391                         if ( lerr != LDAP_SUCCESS ) {
392                                 
393                                 /*
394                                  * FIXME: in case one target cannot
395                                  * be init'd, should the other ones
396                                  * be tried?
397                                  */
398                                 ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
399                                 err = lerr;
400                                 continue;
401                         }
402                 }
403
404         /*
405          * if no unique candidate ...
406          */
407         } else {
408                 for ( i = 0; i < li->ntargets; i++ ) {
409                         if ( i == cached 
410                 || meta_back_is_candidate( &li->targets[ i ]->suffix, ndn ) ) {
411
412                                 /*
413                                  * The target is activated; if needed, it is
414                                  * also init'd
415                                  */
416                                 int lerr = init_one_conn( op, rs,
417                                                 li->targets[ i ],
418                                                 &lc->conns[ i ] );
419                                 if ( lerr != LDAP_SUCCESS ) {
420                                 
421                                         /*
422                                          * FIXME: in case one target cannot
423                                          * be init'd, should the other ones
424                                          * be tried?
425                                          */
426                                         ( void )meta_clear_one_candidate( &lc->conns[ i ], 1 );
427                                         err = lerr;
428                                         continue;
429                                 }
430                         }
431                 }
432         }
433
434         /* clear out init_one_conn non-fatal errors */
435         rs->sr_err = LDAP_SUCCESS;
436         rs->sr_text = NULL;
437
438         if ( new_conn ) {
439                 
440                 /*
441                  * Inserts the newly created metaconn in the avl tree
442                  */
443                 ldap_pvt_thread_mutex_lock( &li->conn_mutex );
444                 err = avl_insert( &li->conntree, ( caddr_t )lc,
445                                 meta_back_conn_cmp, meta_back_conn_dup );
446
447 #if PRINT_CONNTREE > 0
448                 myprint( li->conntree );
449 #endif /* PRINT_CONNTREE */
450                 
451                 ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
452
453                 Debug( LDAP_DEBUG_TRACE,
454                         "=>meta_back_getconn: conn %ld inserted\n%s%s",
455                         lc->conn->c_connid, "", "" );
456                 
457                 /*
458                  * Err could be -1 in case a duplicate metaconn is inserted
459                  */
460                 if ( err != 0 ) {
461                         rs->sr_err = LDAP_OTHER;
462                         rs->sr_text = "Internal server error";
463                         metaconn_free( lc );
464                         return NULL;
465                 }
466         } else {
467                 Debug( LDAP_DEBUG_TRACE,
468                         "=>meta_back_getconn: conn %ld fetched\n%s%s",
469                         lc->conn->c_connid, "", "" );
470         }
471         
472         return lc;
473 }
474