init.c revision 1.1 
1/* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/init.c,v 1.58.2.8 2008/04/14 22:46:48 quanah Exp $ */
2/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3 *
4 * Copyright 1999-2008 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
18#include "portable.h"
19
20#include <stdio.h>
21
22#include <ac/string.h>
23#include <ac/socket.h>
24
25#include "slap.h"
26#include "config.h"
27#include "../back-ldap/back-ldap.h"
28#include "back-meta.h"
29
30int
31meta_back_open(
32	BackendInfo	*bi )
33{
34	/* FIXME: need to remove the pagedResults, and likely more... */
35	bi->bi_controls = slap_known_controls;
36
37	return 0;
38}
39
40int
41meta_back_initialize(
42	BackendInfo	*bi )
43{
44	bi->bi_flags =
45#if 0
46	/* this is not (yet) set essentially because back-meta does not
47	 * directly support extended operations... */
48#ifdef LDAP_DYNAMIC_OBJECTS
49		/* this is set because all the support a proxy has to provide
50		 * is the capability to forward the refresh exop, and to
51		 * pass thru entries that contain the dynamicObject class
52		 * and the entryTtl attribute */
53		SLAP_BFLAG_DYNAMIC |
54#endif /* LDAP_DYNAMIC_OBJECTS */
55#endif
56		0;
57
58	bi->bi_open = meta_back_open;
59	bi->bi_config = 0;
60	bi->bi_close = 0;
61	bi->bi_destroy = 0;
62
63	bi->bi_db_init = meta_back_db_init;
64	bi->bi_db_config = meta_back_db_config;
65	bi->bi_db_open = meta_back_db_open;
66	bi->bi_db_close = 0;
67	bi->bi_db_destroy = meta_back_db_destroy;
68
69	bi->bi_op_bind = meta_back_bind;
70	bi->bi_op_unbind = 0;
71	bi->bi_op_search = meta_back_search;
72	bi->bi_op_compare = meta_back_compare;
73	bi->bi_op_modify = meta_back_modify;
74	bi->bi_op_modrdn = meta_back_modrdn;
75	bi->bi_op_add = meta_back_add;
76	bi->bi_op_delete = meta_back_delete;
77	bi->bi_op_abandon = 0;
78
79	bi->bi_extended = 0;
80
81	bi->bi_chk_referrals = 0;
82
83	bi->bi_connection_init = 0;
84	bi->bi_connection_destroy = meta_back_conn_destroy;
85
86	return 0;
87}
88
89int
90meta_back_db_init(
91	Backend		*be,
92	ConfigReply	*cr)
93{
94	metainfo_t	*mi;
95	int		i;
96
97	mi = ch_calloc( 1, sizeof( metainfo_t ) );
98	if ( mi == NULL ) {
99 		return -1;
100 	}
101
102	/* set default flags */
103	mi->mi_flags =
104		META_BACK_F_DEFER_ROOTDN_BIND;
105
106	/*
107	 * At present the default is no default target;
108	 * this may change
109	 */
110	mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
111	mi->mi_bind_timeout.tv_sec = 0;
112	mi->mi_bind_timeout.tv_usec = META_BIND_TIMEOUT;
113
114	mi->mi_rebind_f = meta_back_default_rebind;
115	mi->mi_urllist_f = meta_back_default_urllist;
116
117	ldap_pvt_thread_mutex_init( &mi->mi_conninfo.lai_mutex );
118	ldap_pvt_thread_mutex_init( &mi->mi_cache.mutex );
119
120	/* safe default */
121	mi->mi_nretries = META_RETRY_DEFAULT;
122	mi->mi_version = LDAP_VERSION3;
123
124	for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
125		mi->mi_conn_priv[ i ].mic_num = 0;
126		LDAP_TAILQ_INIT( &mi->mi_conn_priv[ i ].mic_priv );
127	}
128	mi->mi_conn_priv_max = LDAP_BACK_CONN_PRIV_DEFAULT;
129
130	be->be_private = mi;
131
132	return 0;
133}
134
135int
136meta_back_db_open(
137	Backend		*be,
138	ConfigReply	*cr )
139{
140	metainfo_t	*mi = (metainfo_t *)be->be_private;
141	BackendInfo *bi;
142
143	int		i,
144			not_always = 0,
145			not_always_anon_proxyauthz = 0,
146			not_always_anon_non_prescriptive = 0,
147			rc;
148
149	if ( mi->mi_ntargets == 0 ) {
150		Debug( LDAP_DEBUG_ANY,
151			"meta_back_db_open: no targets defined\n",
152			0, 0, 0 );
153		return 1;
154	}
155
156	bi = backend_info( "ldap" );
157	if ( !bi || !bi->bi_extra ) {
158		Debug( LDAP_DEBUG_ANY,
159			"meta_back_db_open: needs back-ldap\n",
160			0, 0, 0 );
161		return 1;
162	}
163	mi->mi_ldap_extra = (ldap_extra_t *)bi->bi_extra;
164
165	for ( i = 0; i < mi->mi_ntargets; i++ ) {
166		slap_bindconf	sb = { BER_BVNULL };
167		metatarget_t	*mt = mi->mi_targets[ i ];
168
169		ber_str2bv( mt->mt_uri, 0, 0, &sb.sb_uri );
170		sb.sb_version = mt->mt_version;
171		sb.sb_method = LDAP_AUTH_SIMPLE;
172		BER_BVSTR( &sb.sb_binddn, "" );
173
174		if ( META_BACK_TGT_T_F_DISCOVER( mt ) ) {
175			rc = slap_discover_feature( &sb,
176					slap_schema.si_ad_supportedFeatures->ad_cname.bv_val,
177					LDAP_FEATURE_ABSOLUTE_FILTERS );
178			if ( rc == LDAP_COMPARE_TRUE ) {
179				mt->mt_flags |= LDAP_BACK_F_T_F;
180			}
181		}
182
183		if ( META_BACK_TGT_CANCEL_DISCOVER( mt ) ) {
184			rc = slap_discover_feature( &sb,
185					slap_schema.si_ad_supportedExtension->ad_cname.bv_val,
186					LDAP_EXOP_CANCEL );
187			if ( rc == LDAP_COMPARE_TRUE ) {
188				mt->mt_flags |= LDAP_BACK_F_CANCEL_EXOP;
189			}
190		}
191
192		if ( not_always == 0 ) {
193			if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_OVERRIDE )
194				|| mt->mt_idassert_authz != NULL )
195			{
196				not_always = 1;
197			}
198		}
199
200		if ( ( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL )
201			&& !( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) )
202		{
203			Debug( LDAP_DEBUG_ANY, "meta_back_db_open(%s): "
204				"target #%d inconsistent idassert configuration "
205				"(likely authz=\"*\" used with \"non-prescriptive\" flag)\n",
206				be->be_suffix[ 0 ].bv_val, i, 0 );
207			return 1;
208		}
209
210		if ( not_always_anon_proxyauthz == 0 ) {
211			if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL ) )
212			{
213				not_always_anon_proxyauthz = 1;
214			}
215		}
216
217		if ( not_always_anon_non_prescriptive == 0 ) {
218			if ( ( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) )
219			{
220				not_always_anon_non_prescriptive = 1;
221			}
222		}
223	}
224
225	if ( not_always == 0 ) {
226		mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ALWAYS;
227	}
228
229	if ( not_always_anon_proxyauthz == 0 ) {
230		mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ANON;
231
232	} else if ( not_always_anon_non_prescriptive == 0 ) {
233		mi->mi_flags |= META_BACK_F_PROXYAUTHZ_NOANON;
234	}
235
236	return 0;
237}
238
239/*
240 * meta_back_conn_free()
241 *
242 * actually frees a connection; the reference count must be 0,
243 * and it must not (or no longer) be in the cache.
244 */
245void
246meta_back_conn_free(
247	void 		*v_mc )
248{
249	metaconn_t		*mc = v_mc;
250	int			ntargets;
251
252	assert( mc != NULL );
253	assert( mc->mc_refcnt == 0 );
254
255	/* at least one must be present... */
256	ntargets = mc->mc_info->mi_ntargets;
257	assert( ntargets > 0 );
258
259	for ( ; ntargets--; ) {
260		(void)meta_clear_one_candidate( NULL, mc, ntargets );
261	}
262
263	if ( !BER_BVISNULL( &mc->mc_local_ndn ) ) {
264		free( mc->mc_local_ndn.bv_val );
265	}
266
267	free( mc );
268}
269
270static void
271mapping_free(
272	void		*v_mapping )
273{
274	struct ldapmapping *mapping = v_mapping;
275	ch_free( mapping->src.bv_val );
276	ch_free( mapping->dst.bv_val );
277	ch_free( mapping );
278}
279
280static void
281mapping_dst_free(
282	void		*v_mapping )
283{
284	struct ldapmapping *mapping = v_mapping;
285
286	if ( BER_BVISEMPTY( &mapping->dst ) ) {
287		mapping_free( &mapping[ -1 ] );
288	}
289}
290
291static void
292target_free(
293	metatarget_t	*mt )
294{
295	if ( mt->mt_uri ) {
296		free( mt->mt_uri );
297		ldap_pvt_thread_mutex_destroy( &mt->mt_uri_mutex );
298	}
299	if ( mt->mt_subtree_exclude ) {
300		ber_bvarray_free( mt->mt_subtree_exclude );
301	}
302	if ( !BER_BVISNULL( &mt->mt_psuffix ) ) {
303		free( mt->mt_psuffix.bv_val );
304	}
305	if ( !BER_BVISNULL( &mt->mt_nsuffix ) ) {
306		free( mt->mt_nsuffix.bv_val );
307	}
308	if ( !BER_BVISNULL( &mt->mt_binddn ) ) {
309		free( mt->mt_binddn.bv_val );
310	}
311	if ( !BER_BVISNULL( &mt->mt_bindpw ) ) {
312		free( mt->mt_bindpw.bv_val );
313	}
314	if ( !BER_BVISNULL( &mt->mt_idassert_authcID ) ) {
315		ch_free( mt->mt_idassert_authcID.bv_val );
316	}
317	if ( !BER_BVISNULL( &mt->mt_idassert_authcDN ) ) {
318		ch_free( mt->mt_idassert_authcDN.bv_val );
319	}
320	if ( !BER_BVISNULL( &mt->mt_idassert_passwd ) ) {
321		ch_free( mt->mt_idassert_passwd.bv_val );
322	}
323	if ( !BER_BVISNULL( &mt->mt_idassert_authzID ) ) {
324		ch_free( mt->mt_idassert_authzID.bv_val );
325	}
326	if ( !BER_BVISNULL( &mt->mt_idassert_sasl_mech ) ) {
327		ch_free( mt->mt_idassert_sasl_mech.bv_val );
328	}
329	if ( !BER_BVISNULL( &mt->mt_idassert_sasl_realm ) ) {
330		ch_free( mt->mt_idassert_sasl_realm.bv_val );
331	}
332	if ( mt->mt_idassert_authz != NULL ) {
333		ber_bvarray_free( mt->mt_idassert_authz );
334	}
335	if ( mt->mt_rwmap.rwm_rw ) {
336		rewrite_info_delete( &mt->mt_rwmap.rwm_rw );
337	}
338	avl_free( mt->mt_rwmap.rwm_oc.remap, mapping_dst_free );
339	avl_free( mt->mt_rwmap.rwm_oc.map, mapping_free );
340	avl_free( mt->mt_rwmap.rwm_at.remap, mapping_dst_free );
341	avl_free( mt->mt_rwmap.rwm_at.map, mapping_free );
342
343	free( mt );
344}
345
346int
347meta_back_db_destroy(
348	Backend		*be,
349	ConfigReply	*cr )
350{
351	metainfo_t	*mi;
352
353	if ( be->be_private ) {
354		int i;
355
356		mi = ( metainfo_t * )be->be_private;
357
358		/*
359		 * Destroy the connection tree
360		 */
361		ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
362
363		if ( mi->mi_conninfo.lai_tree ) {
364			avl_free( mi->mi_conninfo.lai_tree, meta_back_conn_free );
365		}
366		for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
367			while ( !LDAP_TAILQ_EMPTY( &mi->mi_conn_priv[ i ].mic_priv ) ) {
368				metaconn_t	*mc = LDAP_TAILQ_FIRST( &mi->mi_conn_priv[ i ].mic_priv );
369
370				LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ i ].mic_priv, mc, mc_q );
371				meta_back_conn_free( mc );
372			}
373		}
374
375		/*
376		 * Destroy the per-target stuff (assuming there's at
377		 * least one ...)
378		 */
379		if ( mi->mi_targets != NULL ) {
380			for ( i = 0; i < mi->mi_ntargets; i++ ) {
381				metatarget_t	*mt = mi->mi_targets[ i ];
382
383				if ( META_BACK_TGT_QUARANTINE( mt ) ) {
384					if ( mt->mt_quarantine.ri_num != mi->mi_quarantine.ri_num )
385					{
386						slap_retry_info_destroy( &mt->mt_quarantine );
387					}
388
389					ldap_pvt_thread_mutex_destroy( &mt->mt_quarantine_mutex );
390				}
391
392				target_free( mt );
393			}
394
395			free( mi->mi_targets );
396		}
397
398		ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex );
399		if ( mi->mi_cache.tree ) {
400			avl_free( mi->mi_cache.tree, meta_dncache_free );
401		}
402
403		ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex );
404		ldap_pvt_thread_mutex_destroy( &mi->mi_cache.mutex );
405
406		ldap_pvt_thread_mutex_unlock( &mi->mi_conninfo.lai_mutex );
407		ldap_pvt_thread_mutex_destroy( &mi->mi_conninfo.lai_mutex );
408
409		if ( mi->mi_candidates != NULL ) {
410			ber_memfree_x( mi->mi_candidates, NULL );
411		}
412
413		if ( META_BACK_QUARANTINE( mi ) ) {
414			slap_retry_info_destroy( &mi->mi_quarantine );
415		}
416	}
417
418	free( be->be_private );
419	return 0;
420}
421
422#if SLAPD_META == SLAPD_MOD_DYNAMIC
423
424/* conditionally define the init_module() function */
425SLAP_BACKEND_INIT_MODULE( meta )
426
427#endif /* SLAPD_META == SLAPD_MOD_DYNAMIC */
428
429
430