backover.c 16.7 KB
Newer Older
1
2
/* backover.c - backend overlay routines */
/* $OpenLDAP$ */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
3
4
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 *
Kurt Zeilenga's avatar
Kurt Zeilenga committed
5
 * Copyright 2003-2005 The OpenLDAP Foundation.
Kurt Zeilenga's avatar
Kurt Zeilenga committed
6
 * All rights reserved.
7
 *
Kurt Zeilenga's avatar
Kurt Zeilenga committed
8
9
10
11
12
13
14
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted only as authorized by the OpenLDAP
 * Public License.
 *
 * A copy of this license is available in the file LICENSE in the
 * top-level directory of the distribution or, alternatively, at
 * <http://www.OpenLDAP.org/license.html>.
15
16
 */

Kurt Zeilenga's avatar
Kurt Zeilenga committed
17
18
/* Functions to overlay other modules over a backend. */

19
20
21
22
23
24
25
26
27
#include "portable.h"

#include <stdio.h>

#include <ac/string.h>
#include <ac/socket.h>

#define SLAPD_TOOLS
#include "slap.h"
28
#include "config.h"
29

30
static slap_overinst *overlays;
31
32
33
34
35
36
37
38
39

enum db_which { db_open = 0, db_close, db_destroy };

static int
over_db_func(
	BackendDB *be,
	enum db_which which
)
{
40
	slap_overinfo *oi = be->bd_info->bi_private;
41
	slap_overinst *on = oi->oi_list;
42
	BackendInfo *bi_orig = be->bd_info;
43
44
45
	BI_db_open **func;
	int rc = 0;

46
	func = &oi->oi_orig->bi_db_open;
47
	if ( func[which] ) {
48
49
		be->bd_info = oi->oi_orig;
		rc = func[which]( be );
50
51
	}

52
53
	for (; on && rc == 0; on=on->on_next) {
		be->bd_info = &on->on_bi;
54
55
		func = &on->on_bi.bi_db_open;
		if (func[which]) {
56
			rc = func[which]( be );
57
58
		}
	}
59
	be->bd_info = bi_orig;
60
61
62
63
64
65
66
67
68
69
70
71
	return rc;
}

static int
over_db_config(
	BackendDB *be,
	const char *fname,
	int lineno,
	int argc,
	char **argv
)
{
72
	slap_overinfo *oi = be->bd_info->bi_private;
73
	slap_overinst *on = oi->oi_list;
74
	BackendInfo *bi_orig = be->bd_info;
75
	struct ConfigOCs *be_cf_ocs = be->be_cf_ocs;
76
77
	ConfigArgs ca = {0};
	ConfigTable *ct;
78
79
	int rc = 0;

80
81
	if ( oi->oi_orig->bi_db_config ) {
		be->bd_info = oi->oi_orig;
82
		be->be_cf_ocs = oi->oi_orig->bi_cf_ocs;
83
		rc = oi->oi_orig->bi_db_config( be, fname, lineno,
84
			argc, argv );
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

		if ( be->bd_info != oi->oi_orig ) {
			slap_overinfo	*oi2;
			slap_overinst	*on2, **onp;
			BackendDB	be2 = *be;
			int		i;

			/* a database added an overlay;
			 * work it around... */
			assert( overlay_is_over( be ) );
			
			oi2 = ( slap_overinfo * )be->bd_info->bi_private;
			on2 = oi2->oi_list;

			/* need to put a uniqueness check here as well;
			 * note that in principle there could be more than
			 * one overlay as a result of multiple calls to
			 * overlay_config() */
			be2.bd_info = (BackendInfo *)oi;

			for ( i = 0, onp = &on2; *onp; i++, onp = &(*onp)->on_next ) {
				if ( overlay_is_inst( &be2, (*onp)->on_bi.bi_type ) ) {
					Debug( LDAP_DEBUG_ANY, "over_db_config(): "
							"warning, freshly added "
							"overlay #%d \"%s\" is already in list\n",
							i, (*onp)->on_bi.bi_type, 0 );

					/* NOTE: if the overlay already exists,
					 * there is no way to merge the results
					 * of the configuration that may have 
					 * occurred during bi_db_config(); we
					 * just issue a warning, and the 
					 * administrator should deal with this */
				}
			}
			*onp = oi->oi_list;

			oi->oi_list = on2;

			ch_free( be->bd_info );
		}

127
		be->bd_info = (BackendInfo *)oi;
128
		if ( rc != SLAP_CONF_UNKNOWN ) return rc;
129
130
	}

131
132
133
134
135
	ca.argv = argv;
	ca.argc = argc;
	ca.fname = fname;
	ca.lineno = lineno;
	ca.be = be;
136
	for (; on; on=on->on_next) {
137
138
139
140
141
142
143
144
145
146
		rc = SLAP_CONF_UNKNOWN;
		if (on->on_bi.bi_cf_ocs) {
			ConfigTable *ct;
			ca.bi = &on->on_bi;
			ct = config_find_keyword( on->on_bi.bi_cf_ocs->co_table, &ca );
			if ( ct ) {
				rc = config_add_vals( ct, &ca );
			}
		}
		if (on->on_bi.bi_db_config && rc == SLAP_CONF_UNKNOWN) {
147
148
			be->bd_info = &on->on_bi;
			rc = on->on_bi.bi_db_config( be, fname, lineno,
149
				argc, argv );
150
			if ( rc != SLAP_CONF_UNKNOWN ) break;
151
152
		}
	}
153
	be->bd_info = bi_orig;
154
155
	be->be_cf_ocs = be_cf_ocs;
	
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
	return rc;
}

static int
over_db_open(
	BackendDB *be
)
{
	return over_db_func( be, db_open );
}

static int
over_db_close(
	BackendDB *be
)
{
172
173
174
175
176
177
178
179
180
181
182
183
	slap_overinfo *oi = be->bd_info->bi_private;
	slap_overinst *on = oi->oi_list;
	BackendInfo *bi_orig = be->bd_info;
	int rc = 0;

	for (; on && rc == 0; on=on->on_next) {
		be->bd_info = &on->on_bi;
		if ( be->bd_info->bi_db_close ) {
			rc = be->bd_info->bi_db_close( be );
		}
	}

Howard Chu's avatar
Howard Chu committed
184
	if ( oi->oi_orig->bi_db_close ) {
185
186
187
188
189
190
		be->bd_info = oi->oi_orig;
		rc = be->bd_info->bi_db_close( be );
	}

	be->bd_info = bi_orig;
	return rc;
191
192
193
194
195
196
197
}

static int
over_db_destroy(
	BackendDB *be
)
{
198
	slap_overinfo *oi = be->bd_info->bi_private;
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
	slap_overinst *on = oi->oi_list, *next;
	int rc;

	rc = over_db_func( be, db_destroy );

	for (next = on->on_next; on; on=next) {
		next = on->on_next;
		free( on );
	}
	free( oi );
	return rc;
}

static int
over_back_response ( Operation *op, SlapReply *rs )
{
215
	slap_overinfo *oi = op->o_callback->sc_private;
216
	slap_overinst *on = oi->oi_list;
217
	int rc = SLAP_CB_CONTINUE;
218
219
	BackendDB *be = op->o_bd, db = *op->o_bd;

Howard Chu's avatar
Howard Chu committed
220
	db.be_flags |= SLAP_DBFLAG_OVERLAY;
221
222
223
224
225
	op->o_bd = &db;
	for (; on; on=on->on_next ) {
		if ( on->on_response ) {
			db.bd_info = (BackendInfo *)on;
			rc = on->on_response( op, rs );
226
			if ( rc != SLAP_CB_CONTINUE ) break;
227
228
229
230
231
232
		}
	}
	op->o_bd = be;
	return rc;
}

233
234
235
236
237
238
239
240
241
242
243
244
enum op_which {
	op_bind = 0,
	op_unbind,
	op_search,
	op_compare,
	op_modify,
	op_modrdn,
	op_add,
	op_delete,
	op_abandon,
	op_cancel,
	op_extended,
245
	op_aux_operational,
246
	op_aux_chk_referrals,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
247
	op_aux_chk_controls,
248
249
	op_last
};
250

251
252
253
254
255
256
257
258
/*
 * default return code in case of missing backend function
 * and overlay stack returning SLAP_CB_CONTINUE
 */
static int op_rc[] = {
	LDAP_UNWILLING_TO_PERFORM,	/* bind */
	LDAP_UNWILLING_TO_PERFORM,	/* unbind */
	LDAP_UNWILLING_TO_PERFORM,	/* search */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
259
	SLAP_CB_CONTINUE,		/* compare; pass to frontend */
260
261
262
263
264
265
266
	LDAP_UNWILLING_TO_PERFORM,	/* modify */
	LDAP_UNWILLING_TO_PERFORM,	/* modrdn */
	LDAP_UNWILLING_TO_PERFORM,	/* add */
	LDAP_UNWILLING_TO_PERFORM,	/* delete */
	LDAP_UNWILLING_TO_PERFORM,	/* abandon */
	LDAP_UNWILLING_TO_PERFORM,	/* cancel */
	LDAP_UNWILLING_TO_PERFORM,	/* extended */
267
	LDAP_SUCCESS,			/* aux_operational */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
268
269
	LDAP_SUCCESS,			/* aux_chk_referrals */
	SLAP_CB_CONTINUE		/* aux_chk_controls; pass to frontend */
270
271
};

272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
#ifdef SLAP_OVERLAY_ACCESS
static int
over_access_allowed(
	Operation		*op,
	Entry			*e,
	AttributeDescription	*desc,
	struct berval		*val,
	slap_access_t		access,
	AccessControlState	*state,
	slap_mask_t		*maskp )
{
	slap_overinfo *oi;
	slap_overinst *on;
	BackendInfo *bi = op->o_bd->bd_info;
	BackendDB *be = op->o_bd, db;
	int rc = SLAP_CB_CONTINUE;

	/* FIXME: used to happen for instance during abandon
	 * when global overlays are used... */
	assert( op->o_bd != NULL );

	oi = op->o_bd->bd_info->bi_private;
	on = oi->oi_list;

	for ( ; on; on = on->on_next ) {
		if ( on->on_bi.bi_access_allowed ) {
			/* NOTE: do not copy the structure until required */
		 	if ( !SLAP_ISOVERLAY( op->o_bd ) ) {
 				db = *op->o_bd;
				db.be_flags |= SLAP_DBFLAG_OVERLAY;
				op->o_bd = &db;
			}

			op->o_bd->bd_info = (BackendInfo *)on;
			rc = on->on_bi.bi_access_allowed( op, e,
				desc, val, access, state, maskp );
			if ( rc != SLAP_CB_CONTINUE ) break;
		}
	}

	if ( rc == SLAP_CB_CONTINUE ) {
		BI_access_allowed	*bi_access_allowed;

		/* if the database structure was changed, o_bd points to a
		 * copy of the structure; put the original bd_info in place */
		if ( SLAP_ISOVERLAY( op->o_bd ) ) {
			op->o_bd->bd_info = oi->oi_orig;
		}

		if ( oi->oi_orig->bi_access_allowed ) {
			bi_access_allowed = oi->oi_orig->bi_access_allowed;
		} else {
			bi_access_allowed = slap_access_allowed;
		}

		rc = bi_access_allowed( op, e,
			desc, val, access, state, maskp );
	}
	/* should not fall thru this far without anything happening... */
	if ( rc == SLAP_CB_CONTINUE ) {
		/* access not allowed */
		rc = 0;
	}

	op->o_bd = be;
	op->o_bd->bd_info = bi;

	return rc;
}
#endif /* SLAP_OVERLAY_ACCESS */

343
344
345
346
347
348
349
static int
over_op_func(
	Operation *op,
	SlapReply *rs,
	enum op_which which
)
{
350
351
	slap_overinfo *oi;
	slap_overinst *on;
352
	BI_op_bind **func;
353
	BackendDB *be = op->o_bd, db;
354
	slap_callback cb = {NULL, over_back_response, NULL, NULL};
Howard Chu's avatar
Howard Chu committed
355
	int rc = SLAP_CB_CONTINUE;
356

Pierangelo Masarati's avatar
Pierangelo Masarati committed
357
358
359
	/* FIXME: used to happen for instance during abandon
	 * when global overlays are used... */
	assert( op->o_bd != NULL );
360
361
362
363

	oi = op->o_bd->bd_info->bi_private;
	on = oi->oi_list;

364
365
366
367
368
 	if ( !SLAP_ISOVERLAY( op->o_bd )) {
 		db = *op->o_bd;
		db.be_flags |= SLAP_DBFLAG_OVERLAY;
		op->o_bd = &db;
	}
369
	cb.sc_next = op->o_callback;
370
	cb.sc_private = oi;
Howard Chu's avatar
Howard Chu committed
371
372
	op->o_callback = &cb;

373
374
375
	for (; on; on=on->on_next ) {
		func = &on->on_bi.bi_op_bind;
		if ( func[which] ) {
Kurt Zeilenga's avatar
Kurt Zeilenga committed
376
			op->o_bd->bd_info = (BackendInfo *)on;
377
			rc = func[which]( op, rs );
Howard Chu's avatar
Howard Chu committed
378
			if ( rc != SLAP_CB_CONTINUE ) break;
379
380
		}
	}
Howard Chu's avatar
Howard Chu committed
381

382
	func = &oi->oi_orig->bi_op_bind;
Howard Chu's avatar
Howard Chu committed
383
	if ( func[which] && rc == SLAP_CB_CONTINUE ) {
Kurt Zeilenga's avatar
Kurt Zeilenga committed
384
		op->o_bd->bd_info = oi->oi_orig;
385
386
		rc = func[which]( op, rs );
	}
Howard Chu's avatar
Howard Chu committed
387
388
	/* should not fall thru this far without anything happening... */
	if ( rc == SLAP_CB_CONTINUE ) {
389
		rc = op_rc[ which ];
Howard Chu's avatar
Howard Chu committed
390
	}
Kurt Zeilenga's avatar
Kurt Zeilenga committed
391
392
393
394
395
396
397
398
399
400
401
402
403
404

	/* The underlying backend didn't handle the request, make sure
	 * overlay cleanup is processed.
	 */
	if ( rc == LDAP_UNWILLING_TO_PERFORM ) {
		slap_callback *sc_next;
		for ( ; op->o_callback && op->o_callback != cb.sc_next; 
			op->o_callback = sc_next ) {
			sc_next = op->o_callback->sc_next;
			if ( op->o_callback->sc_cleanup ) {
				op->o_callback->sc_cleanup( op, rs );
			}
		}
	}
405
	op->o_bd = be;
406
	op->o_callback = cb.sc_next;
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
	return rc;
}

static int
over_op_bind( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_bind );
}

static int
over_op_unbind( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_unbind );
}

static int
over_op_search( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_search );
}

static int
over_op_compare( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_compare );
}

static int
over_op_modify( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_modify );
}

static int
over_op_modrdn( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_modrdn );
}

static int
over_op_add( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_add );
}

static int
over_op_delete( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_delete );
}

static int
over_op_abandon( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_abandon );
}

static int
over_op_cancel( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_cancel );
}

static int
over_op_extended( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_extended );
}

476
static int
477
478
479
480
481
482
483
over_aux_operational( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_aux_operational );
}

static int
over_aux_chk_referrals( Operation *op, SlapReply *rs )
484
485
486
487
{
	return over_op_func( op, rs, op_aux_chk_referrals );
}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
static int
over_aux_chk_controls( Operation *op, SlapReply *rs )
{
	return over_op_func( op, rs, op_aux_chk_controls );
}

static int
over_connection_destroy(
	BackendDB	*bd,
	Connection	*conn
)
{
	slap_overinfo *oi;
	slap_overinst *on;
	BackendDB db;
	int rc = SLAP_CB_CONTINUE;

	/* FIXME: used to happen for instance during abandon
	 * when global overlays are used... */
	assert( bd != NULL );

	oi = bd->bd_info->bi_private;
	on = oi->oi_list;

 	if ( !SLAP_ISOVERLAY( bd )) {
 		db = *bd;
		db.be_flags |= SLAP_DBFLAG_OVERLAY;
		bd = &db;
	}

	for (; on; on=on->on_next ) {
		if ( on->on_bi.bi_connection_destroy ) {
			bd->bd_info = (BackendInfo *)on;
			rc = on->on_bi.bi_connection_destroy( bd, conn );
			if ( rc != SLAP_CB_CONTINUE ) break;
		}
	}

	if ( oi->oi_orig->bi_connection_destroy && rc == SLAP_CB_CONTINUE ) {
		bd->bd_info = oi->oi_orig;
		rc = oi->oi_orig->bi_connection_destroy( bd, conn );
	}
	/* should not fall thru this far without anything happening... */
	if ( rc == SLAP_CB_CONTINUE ) {
		rc = LDAP_UNWILLING_TO_PERFORM;
	}

	return rc;
}

538
539
540
541
542
543
544
545
546
547
int
overlay_register(
	slap_overinst *on
)
{
	on->on_next = overlays;
	overlays = on;
	return 0;
}

Pierangelo Masarati's avatar
Pierangelo Masarati committed
548
549
550
551
552
553
554
/*
 * iterator on registered overlays; overlay_next( NULL ) returns the first
 * overlay; * subsequent calls with the previously returned value allow to 
 * iterate * over the entire list; returns NULL when no more overlays are 
 * registered.
 */

555
556
557
558
559
560
561
562
563
564
565
566
slap_overinst *
overlay_next(
	slap_overinst *on
)
{
	if ( on == NULL ) {
		return overlays;
	}

	return on->on_next;
}

Pierangelo Masarati's avatar
Pierangelo Masarati committed
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
/*
 * returns a specific registered overlay based on the type; NULL if not
 * registered.
 */

slap_overinst *
overlay_find( const char *over_type )
{
	slap_overinst *on = overlays;

	assert( over_type );

	for ( ; on; on = on->on_next ) {
		if ( strcmp( on->on_bi.bi_type, over_type ) == 0 ) {
			break;
		}
	}

	return on;
}

588
589
static const char overtype[] = "over";

Pierangelo Masarati's avatar
Pierangelo Masarati committed
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
/*
 * returns TRUE (1) if the database is actually an overlay instance;
 * FALSE (0) otherwise.
 */

int
overlay_is_over( BackendDB *be )
{
	return be->bd_info->bi_type == overtype;
}

/*
 * returns TRUE (1) if the given database is actually an overlay
 * instance and, somewhere in the list, contains the requested overlay;
 * FALSE (0) otherwise.
 */

int
overlay_is_inst( BackendDB *be, const char *over_type )
{
	slap_overinst	*on;

	assert( be );

	if ( !overlay_is_over( be ) ) {
		return 0;
	}
	
	on = ((slap_overinfo *)be->bd_info->bi_private)->oi_list;
	for ( ; on; on = on->on_next ) {
		if ( strcmp( on->on_bi.bi_type, over_type ) == 0 ) {
			return 1;
		}
	}

	return 0;
}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
628
629
630
631
632
int
overlay_register_control( BackendDB *be, const char *oid )
{
	int		rc = 0;
	int		gotit = 0;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
633
634
635
636
637
	int		cid;

	if ( slap_find_control_id( oid, &cid ) == LDAP_CONTROL_NOT_FOUND ) {
		return -1;
	}
Kurt Zeilenga's avatar
Kurt Zeilenga committed
638
639

	if ( SLAP_DBFLAGS( be ) & SLAP_DBFLAG_GLOBAL_OVERLAY ) {
640
		BackendDB *bd;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
641
642
		
		/* add to all backends... */
643
		LDAP_STAILQ_FOREACH( bd, &backendDB, be_next ) {
Kurt Zeilenga's avatar
Kurt Zeilenga committed
644
645
646
647
			if ( be == bd ) {
				gotit = 1;
			}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
648
649
			bd->be_ctrls[ cid ] = 1;
			bd->be_ctrls[ SLAP_MAX_CIDS ] = 1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
650
651
652
653
		}

	}
	
Kurt Zeilenga's avatar
Kurt Zeilenga committed
654
655
656
	if ( rc == 0 && !gotit ) {
		be->be_ctrls[ cid ] = 1;
		be->be_ctrls[ SLAP_MAX_CIDS ] = 1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
657
658
659
660
661
	}

	return rc;
}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
void
overlay_destroy_one( BackendDB *be, slap_overinst *on )
{
	slap_overinfo *oi = on->on_info;
	slap_overinst **oidx;

	for ( oidx = &oi->oi_list; *oidx; oidx = &(*oidx)->on_next ) {
		if ( *oidx == on ) {
			*oidx = on->on_next;
			if ( on->on_bi.bi_db_destroy ) {
				BackendInfo *bi_orig = be->bd_info;
				be->bd_info = (BackendInfo *)on;
				on->on_bi.bi_db_destroy( be );
				be->bd_info = bi_orig;
			}
			free( on );
			break;
		}
	}
}

683
684
685
686
/* add an overlay to a particular backend. */
int
overlay_config( BackendDB *be, const char *ov )
{
687
	slap_overinst *on = NULL, *on2 = NULL;
688
689
	slap_overinfo *oi = NULL;
	BackendInfo *bi = NULL;
690

Pierangelo Masarati's avatar
Pierangelo Masarati committed
691
	on = overlay_find( ov );
692
693
	if ( !on ) {
		Debug( LDAP_DEBUG_ANY, "overlay \"%s\" not found\n", ov, 0, 0 );
694
695
696
		return 1;
	}

697
698
699
	/* If this is the first overlay on this backend, set up the
	 * overlay info structure
	 */
Pierangelo Masarati's avatar
Pierangelo Masarati committed
700
	if ( !overlay_is_over( be ) ) {
701
		oi = ch_malloc( sizeof( slap_overinfo ) );
702
		oi->oi_orig = be->bd_info;
703
		oi->oi_bi = *be->bd_info;
704

Kurt Zeilenga's avatar
Kurt Zeilenga committed
705
706
707
708
709
710
711
		/* NOTE: the first time a global overlay is configured,
		 * frontendDB gets this flag; it is used later by overlays
		 * to determine if they're stacked on top of the frontendDB */
		if ( oi->oi_orig == frontendDB->bd_info ) {
			SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_GLOBAL_OVERLAY;
		}

712
713
714
		/* Save a pointer to ourself in bi_private.
		 */
		oi->oi_bi.bi_private = oi;
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
		oi->oi_list = NULL;
		bi = (BackendInfo *)oi;

		bi->bi_type = (char *)overtype;

		bi->bi_db_config = over_db_config;
		bi->bi_db_open = over_db_open;
		bi->bi_db_close = over_db_close;
		bi->bi_db_destroy = over_db_destroy;

		bi->bi_op_bind = over_op_bind;
		bi->bi_op_unbind = over_op_unbind;
		bi->bi_op_search = over_op_search;
		bi->bi_op_compare = over_op_compare;
		bi->bi_op_modify = over_op_modify;
		bi->bi_op_modrdn = over_op_modrdn;
		bi->bi_op_add = over_op_add;
		bi->bi_op_delete = over_op_delete;
		bi->bi_op_abandon = over_op_abandon;
		bi->bi_op_cancel = over_op_cancel;
735

736
737
		bi->bi_extended = over_op_extended;

738
739
740
741
742
743
		/*
		 * this is fine because it has the same
		 * args of the operations; we need to rework
		 * all the hooks to share the same args
		 * of the operations...
		 */
744
745
		bi->bi_operational = over_aux_operational;
		bi->bi_chk_referrals = over_aux_chk_referrals;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
746
		bi->bi_chk_controls = over_aux_chk_controls;
747
748
749
750
751

#ifdef SLAP_OVERLAY_ACCESS
		/* this has a specific arglist */
		bi->bi_access_allowed = over_access_allowed;
#endif /* SLAP_OVERLAY_ACCESS */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
752
753
		
		bi->bi_connection_destroy = over_connection_destroy;
754

755
		be->bd_info = bi;
756
757

	} else {
758
759
760
761
762
763
		if ( overlay_is_inst( be, ov ) ) {
			Debug( LDAP_DEBUG_ANY, "overlay_config(): "
					"warning, overlay \"%s\" "
					"already in list\n", ov, 0, 0 );
		}

764
		oi = be->bd_info->bi_private;
765
766
	}

767
768
769
770
771
772
773
774
	/* Insert new overlay on head of list. Overlays are executed
	 * in reverse of config order...
	 */
	on2 = ch_calloc( 1, sizeof(slap_overinst) );
	*on2 = *on;
	on2->on_info = oi;
	on2->on_next = oi->oi_list;
	oi->oi_list = on2;
775

776
777
	/* Any initialization needed? */
	if ( on->on_bi.bi_db_init ) {
Kurt Zeilenga's avatar
Kurt Zeilenga committed
778
		int rc;
779
		be->bd_info = (BackendInfo *)on2;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
780
		rc = on2->on_bi.bi_db_init( be );
781
		be->bd_info = (BackendInfo *)oi;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
782
		if ( rc ) return rc;
783
784
	}

785
786
787
	return 0;
}