X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fbackover.c;h=047af4497b5d5ade70ad2360068873c0adb91ccb;hb=60339c7f774099c3e497ad18efcd8304324c30c6;hp=ee3ecafe6eea9daf57cd6d1e0fc2dc807aced0ad;hpb=5b193c218fcc45a909169a18500e49185fb71d52;p=openldap diff --git a/servers/slapd/backover.c b/servers/slapd/backover.c index ee3ecafe6e..047af4497b 100644 --- a/servers/slapd/backover.c +++ b/servers/slapd/backover.c @@ -25,6 +25,7 @@ #define SLAPD_TOOLS #include "slap.h" +#include "config.h" static slap_overinst *overlays; @@ -71,10 +72,14 @@ over_db_config( slap_overinfo *oi = be->bd_info->bi_private; slap_overinst *on = oi->oi_list; BackendInfo *bi_orig = be->bd_info; + struct ConfigOCs *be_cf_ocs = be->be_cf_ocs; + ConfigArgs ca = {0}; + ConfigTable *ct; int rc = 0; if ( oi->oi_orig->bi_db_config ) { be->bd_info = oi->oi_orig; + be->be_cf_ocs = oi->oi_orig->bi_cf_ocs; rc = oi->oi_orig->bi_db_config( be, fname, lineno, argc, argv ); @@ -123,8 +128,22 @@ over_db_config( if ( rc != SLAP_CONF_UNKNOWN ) return rc; } + ca.argv = argv; + ca.argc = argc; + ca.fname = fname; + ca.lineno = lineno; + ca.be = be; for (; on; on=on->on_next) { - if (on->on_bi.bi_db_config) { + 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) { be->bd_info = &on->on_bi; rc = on->on_bi.bi_db_config( be, fname, lineno, argc, argv ); @@ -132,6 +151,8 @@ over_db_config( } } be->bd_info = bi_orig; + be->be_cf_ocs = be_cf_ocs; + return rc; } @@ -223,6 +244,7 @@ enum op_which { op_extended, op_aux_operational, op_aux_chk_referrals, + op_aux_chk_controls, op_last }; @@ -234,7 +256,7 @@ static int op_rc[] = { LDAP_UNWILLING_TO_PERFORM, /* bind */ LDAP_UNWILLING_TO_PERFORM, /* unbind */ LDAP_UNWILLING_TO_PERFORM, /* search */ - LDAP_UNWILLING_TO_PERFORM, /* compare */ + SLAP_CB_CONTINUE, /* compare; pass to frontend */ LDAP_UNWILLING_TO_PERFORM, /* modify */ LDAP_UNWILLING_TO_PERFORM, /* modrdn */ LDAP_UNWILLING_TO_PERFORM, /* add */ @@ -243,9 +265,81 @@ static int op_rc[] = { LDAP_UNWILLING_TO_PERFORM, /* cancel */ LDAP_UNWILLING_TO_PERFORM, /* extended */ LDAP_SUCCESS, /* aux_operational */ - LDAP_SUCCESS /* aux_chk_referrals */ + LDAP_SUCCESS, /* aux_chk_referrals */ + SLAP_CB_CONTINUE /* aux_chk_controls; pass to frontend */ }; +#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 */ + static int over_op_func( Operation *op, @@ -294,6 +388,20 @@ over_op_func( if ( rc == SLAP_CB_CONTINUE ) { rc = op_rc[ which ]; } + + /* 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 ); + } + } + } op->o_bd = be; op->o_callback = cb.sc_next; return rc; @@ -377,6 +485,56 @@ over_aux_chk_referrals( Operation *op, SlapReply *rs ) return over_op_func( op, rs, op_aux_chk_referrals ); } +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; +} + int overlay_register( slap_overinst *on @@ -467,66 +625,61 @@ overlay_is_inst( BackendDB *be, const char *over_type ) return 0; } -#if 0 -int -overlay_is_global( BackendDB *be ) -{ - BackendInfo *frontendBI; - - if ( !overlay_is_over( be ) ) { - return 0; - } - - frontendBI = frontendDB->bd_info; - if ( overlay_is_over( frontendDB ) ) { - frontendBI = ((slap_overinfo *)frontendBI->bi_private)->oi_orig; - } - - return ((slap_overinfo *)be->bd_info->bi_private)->oi_orig == frontendBI; -} -#endif - int overlay_register_control( BackendDB *be, const char *oid ) { int rc = 0; int gotit = 0; + int cid; + + if ( slap_find_control_id( oid, &cid ) == LDAP_CONTROL_NOT_FOUND ) { + return -1; + } -#if 0 - if ( overlay_is_global( be ) ) { - int i; + if ( SLAP_DBFLAGS( be ) & SLAP_DBFLAG_GLOBAL_OVERLAY ) { + BackendDB *bd; /* add to all backends... */ - for ( i = 0; i < nBackendDB; i++ ) { - BackendDB *bd = &backendDB[i]; - + LDAP_STAILQ_FOREACH( bd, &backendDB, be_next ) { if ( be == bd ) { gotit = 1; } - if ( bd->be_controls == NULL || - !ldap_charray_inlist( bd->be_controls, oid ) ) - { - rc = ldap_charray_add( &be->be_controls, oid ); - if ( rc ) { - break; - } - } + bd->be_ctrls[ cid ] = 1; + bd->be_ctrls[ SLAP_MAX_CIDS ] = 1; } } -#endif - if ( rc == 0 && !gotit && !ldap_charray_inlist( be->be_controls, oid ) ) { - rc = ldap_charray_add( &be->be_controls, oid ); - if ( rc ) { - return rc; - } + if ( rc == 0 && !gotit ) { + be->be_ctrls[ cid ] = 1; + be->be_ctrls[ SLAP_MAX_CIDS ] = 1; } return rc; } +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; + } + } +} + /* add an overlay to a particular backend. */ int overlay_config( BackendDB *be, const char *ov ) @@ -549,6 +702,13 @@ overlay_config( BackendDB *be, const char *ov ) oi->oi_orig = be->bd_info; oi->oi_bi = *be->bd_info; + /* 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; + } + /* Save a pointer to ourself in bi_private. */ oi->oi_bi.bi_private = oi; @@ -583,6 +743,14 @@ overlay_config( BackendDB *be, const char *ov ) */ bi->bi_operational = over_aux_operational; bi->bi_chk_referrals = over_aux_chk_referrals; + bi->bi_chk_controls = over_aux_chk_controls; + +#ifdef SLAP_OVERLAY_ACCESS + /* this has a specific arglist */ + bi->bi_access_allowed = over_access_allowed; +#endif /* SLAP_OVERLAY_ACCESS */ + + bi->bi_connection_destroy = over_connection_destroy; be->bd_info = bi; @@ -607,9 +775,11 @@ overlay_config( BackendDB *be, const char *ov ) /* Any initialization needed? */ if ( on->on_bi.bi_db_init ) { + int rc; be->bd_info = (BackendInfo *)on2; - on2->on_bi.bi_db_init( be ); + rc = on2->on_bi.bi_db_init( be ); be->bd_info = (BackendInfo *)oi; + if ( rc ) return rc; } return 0;