X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Foverlays%2Ftranslucent.c;h=92d9a211517b2f9d65ac73a18a5624b37edee06c;hb=8bdfd2edbb7a09f5bfe96b2bca043680f731237a;hp=e0d8895aa7a0b1404c167087cb15d31df2d1cb0a;hpb=dba1b54b473141bb39ac61fbb00a61938fbd0a78;p=openldap diff --git a/servers/slapd/overlays/translucent.c b/servers/slapd/overlays/translucent.c index e0d8895aa7..92d9a21151 100644 --- a/servers/slapd/overlays/translucent.c +++ b/servers/slapd/overlays/translucent.c @@ -2,7 +2,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 2004-2007 The OpenLDAP Foundation. + * Copyright 2004-2009 The OpenLDAP Foundation. * Portions Copyright 2005 Symas Corporation. * All rights reserved. * @@ -36,14 +36,25 @@ /* config block */ typedef struct translucent_info { BackendDB db; /* captive backend */ + AttributeName *local; /* valid attrs for local filters */ + AttributeName *remote; /* valid attrs for remote filters */ int strict; int no_glue; int defer_db_open; + int bind_local; + int pwmod_local; } translucent_info; static ConfigLDAPadd translucent_ldadd; static ConfigCfAdd translucent_cfadd; +static ConfigDriver translucent_cf_gen; + +enum { + TRANS_LOCAL = 1, + TRANS_REMOTE +}; + static ConfigTable translucentcfg[] = { { "translucent_strict", "on|off", 1, 2, 0, ARG_ON_OFF|ARG_OFFSET, @@ -57,14 +68,30 @@ static ConfigTable translucentcfg[] = { "( OLcfgOvAt:14.2 NAME 'olcTranslucentNoGlue' " "DESC 'Disable automatic glue records for ADD and MODRDN' " "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL }, - { NULL, NULL, 0, 0, 0, ARG_IGNORED } -}; - -static ConfigTable transdummy[] = { - { "", "", 0, 0, 0, ARG_IGNORED, - NULL, "( OLcfgGlAt:13 NAME 'olcDatabase' " - "DESC 'The backend type for a database instance' " - "SUP olcBackend SINGLE-VALUE X-ORDERED 'SIBLINGS' )", NULL, NULL }, + { "translucent_local", "attr[,attr...]", 1, 2, 0, + ARG_MAGIC|TRANS_LOCAL, + translucent_cf_gen, + "( OLcfgOvAt:14.3 NAME 'olcTranslucentLocal' " + "DESC 'Attributes to use in local search filter' " + "SYNTAX OMsDirectoryString )", NULL, NULL }, + { "translucent_remote", "attr[,attr...]", 1, 2, 0, + ARG_MAGIC|TRANS_REMOTE, + translucent_cf_gen, + "( OLcfgOvAt:14.4 NAME 'olcTranslucentRemote' " + "DESC 'Attributes to use in remote search filter' " + "SYNTAX OMsDirectoryString )", NULL, NULL }, + { "translucent_bind_local", "on|off", 1, 2, 0, + ARG_ON_OFF|ARG_OFFSET, + (void *)offsetof(translucent_info, bind_local), + "( OLcfgOvAt:14.5 NAME 'olcTranslucentBindLocal' " + "DESC 'Enable local bind' " + "SYNTAX OMsBoolean SINGLE-VALUE)", NULL, NULL }, + { "translucent_pwmod_local", "on|off", 1, 2, 0, + ARG_ON_OFF|ARG_OFFSET, + (void *)offsetof(translucent_info, pwmod_local), + "( OLcfgOvAt:14.6 NAME 'olcTranslucentPwModLocal' " + "DESC 'Enable local RFC 3062 Password Modify extended operation' " + "SYNTAX OMsBoolean SINGLE-VALUE)", NULL, NULL }, { NULL, NULL, 0, 0, 0, ARG_IGNORED } }; @@ -73,12 +100,14 @@ static ConfigOCs translucentocs[] = { "NAME 'olcTranslucentConfig' " "DESC 'Translucent configuration' " "SUP olcOverlayConfig " - "MAY ( olcTranslucentStrict $ olcTranslucentNoGlue ) )", + "MAY ( olcTranslucentStrict $ olcTranslucentNoGlue $" + " olcTranslucentLocal $ olcTranslucentRemote $" + " olcTranslucentBindLocal $ olcTranslucentPwModLocal ) )", Cft_Overlay, translucentcfg, NULL, translucent_cfadd }, { "( OLcfgOvOc:14.2 " "NAME 'olcTranslucentDatabase' " "DESC 'Translucent target database configuration' " - "AUXILIARY )", Cft_Misc, transdummy, translucent_ldadd }, + "AUXILIARY )", Cft_Misc, olcDatabaseDummy, translucent_ldadd }, { NULL, 0, NULL } }; /* for translucent_init() */ @@ -86,7 +115,7 @@ static ConfigOCs translucentocs[] = { static int translucent_ldadd_cleanup( ConfigArgs *ca ) { - slap_overinst *on = ca->private; + slap_overinst *on = ca->ca_private; translucent_info *ov = on->on_bi.bi_private; ov->defer_db_open = 0; @@ -108,7 +137,7 @@ translucent_ldadd( CfEntryInfo *cei, Entry *e, ConfigArgs *ca ) on = (slap_overinst *)cei->ce_bi; ov = on->on_bi.bi_private; ca->be = &ov->db; - ca->private = on; + ca->ca_private = on; if ( CONFIG_ONLINE_ADD( ca )) ca->cleanup = translucent_ldadd_cleanup; else @@ -130,7 +159,7 @@ translucent_cfadd( Operation *op, SlapReply *rs, Entry *e, ConfigArgs *ca ) /* FIXME: should not hardcode "olcDatabase" here */ bv.bv_len = snprintf( ca->cr_msg, sizeof( ca->cr_msg ), "olcDatabase=%s", ov->db.bd_info->bi_type ); - if ( bv.bv_len < 0 || bv.bv_len >= sizeof( ca->cr_msg ) ) { + if ( bv.bv_len >= sizeof( ca->cr_msg ) ) { return -1; } bv.bv_val = ca->cr_msg; @@ -147,6 +176,51 @@ translucent_cfadd( Operation *op, SlapReply *rs, Entry *e, ConfigArgs *ca ) return 0; } +static int +translucent_cf_gen( ConfigArgs *c ) +{ + slap_overinst *on = (slap_overinst *)c->bi; + translucent_info *ov = on->on_bi.bi_private; + AttributeName **an, *a2; + int i; + + if ( c->type == TRANS_LOCAL ) + an = &ov->local; + else + an = &ov->remote; + + if ( c->op == SLAP_CONFIG_EMIT ) { + if ( !*an ) + return 1; + for ( i = 0; !BER_BVISNULL(&(*an)[i].an_name); i++ ) { + value_add_one( &c->rvalue_vals, &(*an)[i].an_name ); + } + return ( i < 1 ); + } else if ( c->op == LDAP_MOD_DELETE ) { + if ( c->valx < 0 ) { + anlist_free( *an, 1, NULL ); + *an = NULL; + } else { + i = c->valx; + ch_free( (*an)[i].an_name.bv_val ); + do { + (*an)[i] = (*an)[i+1]; + } while ( !BER_BVISNULL( &(*an)[i].an_name )); + } + return 0; + } + a2 = str2anlist( *an, c->argv[1], "," ); + if ( !a2 ) { + snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s unable to parse attribute %s", + c->argv[0], c->argv[1] ); + Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE, + "%s: %s\n", c->log, c->cr_msg, 0 ); + return ARG_BAD_CONF; + } + *an = a2; + return 0; +} + static slap_overinst translucent; /* @@ -358,6 +432,7 @@ static int translucent_modify(Operation *op, SlapReply *rs) { db = op->o_bd; op->o_bd = &ov->db; + ov->db.be_acl = op->o_bd->be_acl; rc = ov->db.bd_info->bi_entry_get_rw(op, &op->o_req_ndn, NULL, NULL, 0, &re); if(rc != LDAP_SUCCESS || re == NULL ) { send_ldap_error((op), rs, LDAP_NO_SUCH_OBJECT, @@ -516,6 +591,7 @@ release: rc = on->on_info->oi_orig->bi_op_add(op, &nrs); if ( op->ora_e == e ) entry_free( e ); + op->o_callback = cb.sc_next; return(rc); } @@ -537,7 +613,7 @@ static int translucent_compare(Operation *op, SlapReply *rs) { ** */ rc = overlay_entry_get_ov(op, &op->o_req_ndn, NULL, ava->aa_desc, 0, &e, on); - if(e && rc == LDAP_SUCCESS) { + if(rc == LDAP_SUCCESS && e) { overlay_entry_release_ov(op, e, 0, on); return(SLAP_CB_CONTINUE); } @@ -554,24 +630,178 @@ static int translucent_compare(Operation *op, SlapReply *rs) { */ db = op->o_bd; op->o_bd = &ov->db; + ov->db.be_acl = op->o_bd->be_acl; rc = ov->db.bd_info->bi_op_compare(op, rs); op->o_bd = db; return(rc); } +static int translucent_pwmod(Operation *op, SlapReply *rs) { + SlapReply nrs = { REP_RESULT }; + Operation nop; + + slap_overinst *on = (slap_overinst *) op->o_bd->bd_info; + translucent_info *ov = on->on_bi.bi_private; + const struct berval bv_exop_pwmod = BER_BVC(LDAP_EXOP_MODIFY_PASSWD); + Entry *e = NULL, *re = NULL; + BackendDB *db; + int rc = 0; + slap_callback cb = { 0 }; + + if (!ov->pwmod_local) { + rs->sr_err = LDAP_CONSTRAINT_VIOLATION, + rs->sr_text = "attempt to modify password in local database"; + return rs->sr_err; + } + +/* +** fetch entry from the captive backend; +** if it did not exist, fail; +** release it, if captive backend supports this; +** +*/ + db = op->o_bd; + op->o_bd = &ov->db; + ov->db.be_acl = op->o_bd->be_acl; + rc = ov->db.bd_info->bi_entry_get_rw(op, &op->o_req_ndn, NULL, NULL, 0, &re); + if(rc != LDAP_SUCCESS || re == NULL ) { + send_ldap_error((op), rs, LDAP_NO_SUCH_OBJECT, + "attempt to modify nonexistent local record"); + return(rs->sr_err); + } + op->o_bd = db; +/* +** fetch entry from local backend; +** if it exists: +** return CONTINUE; +*/ + + op->o_bd->bd_info = (BackendInfo *) on->on_info; + rc = be_entry_get_rw(op, &op->o_req_ndn, NULL, NULL, 0, &e); + op->o_bd->bd_info = (BackendInfo *) on; + + if(e && rc == LDAP_SUCCESS) { + if(re) { + if(ov->db.bd_info->bi_entry_release_rw) { + op->o_bd = &ov->db; + ov->db.bd_info->bi_entry_release_rw(op, re, 0); + op->o_bd = db; + } else { + entry_free(re); + } + } + op->o_bd->bd_info = (BackendInfo *) on->on_info; + be_entry_release_r(op, e); + op->o_bd->bd_info = (BackendInfo *) on; + return SLAP_CB_CONTINUE; + } + + /* don't leak remote entry copy */ + if(re) { + if(ov->db.bd_info->bi_entry_release_rw) { + op->o_bd = &ov->db; + ov->db.bd_info->bi_entry_release_rw(op, re, 0); + op->o_bd = db; + } else { + entry_free(re); + } + } +/* +** glue_parent() for this Entry; +** call bi_op_add() in local backend; +** +*/ + e = entry_alloc(); + ber_dupbv( &e->e_name, &op->o_req_dn ); + ber_dupbv( &e->e_nname, &op->o_req_ndn ); + e->e_attrs = NULL; + + nop = *op; + nop.o_tag = LDAP_REQ_ADD; + cb.sc_response = slap_null_cb; + nop.oq_add.rs_e = e; + + glue_parent(&nop); + + nop.o_callback = &cb; + rc = on->on_info->oi_orig->bi_op_add(&nop, &nrs); + if ( nop.ora_e == e ) { + entry_free( e ); + } + + if ( rc == LDAP_SUCCESS ) { + return SLAP_CB_CONTINUE; + } + + return rc; +} + +static int translucent_exop(Operation *op, SlapReply *rs) { + SlapReply nrs = { REP_RESULT }; + + slap_overinst *on = (slap_overinst *) op->o_bd->bd_info; + translucent_info *ov = on->on_bi.bi_private; + const struct berval bv_exop_pwmod = BER_BVC(LDAP_EXOP_MODIFY_PASSWD); + + Debug(LDAP_DEBUG_TRACE, "==> translucent_exop: %s\n", + op->o_req_dn.bv_val, 0, 0); + + if(ov->defer_db_open) { + send_ldap_error(op, rs, LDAP_UNAVAILABLE, + "remote DB not available"); + return(rs->sr_err); + } + + if ( bvmatch( &bv_exop_pwmod, &op->ore_reqoid ) ) { + return translucent_pwmod( op, rs ); + } + + return SLAP_CB_CONTINUE; +} + /* ** translucent_search_cb() -** merge local data with the search result +** merge local data with remote data ** +** Four cases: +** 1: remote search, no local filter +** merge data and send immediately +** 2: remote search, with local filter +** merge data and save +** 3: local search, no remote filter +** merge data and send immediately +** 4: local search, with remote filter +** check list, merge, send, delete */ +#define RMT_SIDE 0 +#define LCL_SIDE 1 +#define USE_LIST 2 + +typedef struct trans_ctx { + BackendDB *db; + slap_overinst *on; + Filter *orig; + Avlnode *list; + int step; +} trans_ctx; + static int translucent_search_cb(Operation *op, SlapReply *rs) { + trans_ctx *tc; BackendDB *db; slap_overinst *on; - Entry *e, *re = NULL; + translucent_info *ov; + Entry *le, *re; Attribute *a, *ax, *an, *as = NULL; int rc; + int test_f = 0; + + tc = op->o_callback->sc_private; + + /* Don't let the op complete while we're gathering data */ + if ( rs->sr_type == REP_RESULT && ( tc->step & USE_LIST )) + return 0; if(!op || !rs || rs->sr_type != REP_SEARCH || !rs->sr_entry) return(SLAP_CB_CONTINUE); @@ -579,29 +809,78 @@ static int translucent_search_cb(Operation *op, SlapReply *rs) { Debug(LDAP_DEBUG_TRACE, "==> translucent_search_cb: %s\n", rs->sr_entry->e_name.bv_val, 0, 0); - db = op->o_bd; - op->o_bd = op->o_callback->sc_private; - on = (slap_overinst *) op->o_bd->bd_info; + on = tc->on; + ov = on->on_bi.bi_private; - rc = overlay_entry_get_ov(op, &rs->sr_entry->e_nname, NULL, NULL, 0, &e, on); + db = op->o_bd; + re = NULL; + + /* If we have local, get remote */ + if ( tc->step & LCL_SIDE ) { + le = rs->sr_entry; + /* If entry is already on list, use it */ + if ( tc->step & USE_LIST ) { + re = tavl_delete( &tc->list, le, entry_dn_cmp ); + if ( re ) { + if ( rs->sr_flags & REP_ENTRY_MUSTRELEASE ) { + rs->sr_flags ^= REP_ENTRY_MUSTRELEASE; + overlay_entry_release_ov( op, rs->sr_entry, 0, on ); + } + if ( rs->sr_flags & REP_ENTRY_MUSTBEFREED ) { + rs->sr_flags ^= REP_ENTRY_MUSTBEFREED; + entry_free( rs->sr_entry ); + } + rc = test_filter( op, re, tc->orig ); + if ( rc == LDAP_COMPARE_TRUE ) { + rs->sr_flags |= REP_ENTRY_MUSTBEFREED; + rs->sr_entry = re; + return SLAP_CB_CONTINUE; + } else { + entry_free( re ); + rs->sr_entry = NULL; + return 0; + } + } + } + op->o_bd = &ov->db; + rc = be_entry_get_rw( op, &rs->sr_entry->e_nname, NULL, NULL, 0, &re ); + if ( rc == LDAP_SUCCESS && re ) { + Entry *tmp = entry_dup( re ); + be_entry_release_r( op, re ); + re = tmp; + test_f = 1; + } + } else { + /* Else we have remote, get local */ + op->o_bd = tc->db; + rc = overlay_entry_get_ov(op, &rs->sr_entry->e_nname, NULL, NULL, 0, &le, on); + if ( rc == LDAP_SUCCESS && le ) { + re = entry_dup( rs->sr_entry ); + if ( rs->sr_flags & REP_ENTRY_MUSTRELEASE ) { + rs->sr_flags ^= REP_ENTRY_MUSTRELEASE; + overlay_entry_release_ov( op, rs->sr_entry, 0, on ); + } + if ( rs->sr_flags & REP_ENTRY_MUSTBEFREED ) { + rs->sr_flags ^= REP_ENTRY_MUSTBEFREED; + entry_free( rs->sr_entry ); + } + } else { + le = NULL; + } + } /* -** if we got an entry from local backend: -** make a copy of this search result; +** if we got remote and local entry: ** foreach local attr: -** foreach search result attr: -** if match, result attr with local attr; +** foreach remote attr: +** if match, remote attr with local attr; ** if new local, add to list; -** append new local attrs to search result; +** append new local attrs to remote; ** */ - if(e && rc == LDAP_SUCCESS) { - re = entry_dup(rs->sr_entry); - for(ax = e->e_attrs; ax; ax = ax->a_next) { -#if 0 - if(is_at_operational(ax->a_desc->ad_type)) continue; -#endif + if ( re && le ) { + for(ax = le->e_attrs; ax; ax = ax->a_next) { for(a = re->e_attrs; a; a = a->a_next) { if(a->a_desc == ax->a_desc) { if(a->a_vals != a->a_nvals) @@ -618,7 +897,19 @@ static int translucent_search_cb(Operation *op, SlapReply *rs) { an->a_next = as; as = an; } - overlay_entry_release_ov(op, e, 0, on); + /* Dispose of local entry */ + if ( tc->step & LCL_SIDE ) { + if ( rs->sr_flags & REP_ENTRY_MUSTRELEASE ) { + rs->sr_flags ^= REP_ENTRY_MUSTRELEASE; + overlay_entry_release_ov( op, rs->sr_entry, 0, on ); + } + if ( rs->sr_flags & REP_ENTRY_MUSTBEFREED ) { + rs->sr_flags ^= REP_ENTRY_MUSTBEFREED; + entry_free( rs->sr_entry ); + } + } else { + overlay_entry_release_ov(op, le, 0, on); + } /* literally append, so locals are always last */ if(as) { @@ -629,12 +920,152 @@ static int translucent_search_cb(Operation *op, SlapReply *rs) { re->e_attrs = as; } } - rs->sr_entry = re; - rs->sr_flags |= REP_ENTRY_MUSTBEFREED; + /* If both filters, save entry for later */ + if ( tc->step == (USE_LIST|RMT_SIDE) ) { + tavl_insert( &tc->list, re, entry_dn_cmp, avl_dup_error ); + rs->sr_entry = NULL; + rc = 0; + } else { + /* send it now */ + rs->sr_entry = re; + rs->sr_flags |= REP_ENTRY_MUSTBEFREED; + if ( test_f ) { + rc = test_filter( op, rs->sr_entry, tc->orig ); + if ( rc == LDAP_COMPARE_TRUE ) { + rc = SLAP_CB_CONTINUE; + } else { + rc = 0; + } + } else { + rc = SLAP_CB_CONTINUE; + } + } + } else if ( le ) { + /* Only a local entry: remote was deleted + * Ought to delete the local too... + */ + rc = 0; + } else if ( tc->step & USE_LIST ) { + /* Only a remote entry, but both filters: + * Test the complete filter + */ + rc = test_filter( op, rs->sr_entry, tc->orig ); + if ( rc == LDAP_COMPARE_TRUE ) { + rc = SLAP_CB_CONTINUE; + } else { + rc = 0; + } + } else { + /* Only a remote entry, only remote filter: + * just pass thru + */ + rc = SLAP_CB_CONTINUE; } op->o_bd = db; - return(SLAP_CB_CONTINUE); + return rc; +} + +/* Dup the filter, excluding invalid elements */ +static Filter * +trans_filter_dup(Operation *op, Filter *f, AttributeName *an) +{ + Filter *n = NULL; + + if ( !f ) + return NULL; + + switch( f->f_choice & SLAPD_FILTER_MASK ) { + case SLAPD_FILTER_COMPUTED: + n = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx ); + n->f_choice = f->f_choice; + n->f_result = f->f_result; + n->f_next = NULL; + break; + + case LDAP_FILTER_PRESENT: + if ( ad_inlist( f->f_desc, an )) { + n = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx ); + n->f_choice = f->f_choice; + n->f_desc = f->f_desc; + n->f_next = NULL; + } + break; + + case LDAP_FILTER_EQUALITY: + case LDAP_FILTER_GE: + case LDAP_FILTER_LE: + case LDAP_FILTER_APPROX: + case LDAP_FILTER_SUBSTRINGS: + case LDAP_FILTER_EXT: + if ( !f->f_av_desc || ad_inlist( f->f_av_desc, an )) { + n = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx ); + n->f_choice = f->f_choice; + n->f_ava = f->f_ava; + n->f_next = NULL; + } + break; + + case LDAP_FILTER_AND: + case LDAP_FILTER_OR: + case LDAP_FILTER_NOT: { + Filter **p; + + n = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx ); + n->f_choice = f->f_choice; + n->f_next = NULL; + + for ( p = &n->f_list, f = f->f_list; f; f = f->f_next ) { + *p = trans_filter_dup( op, f, an ); + if ( !*p ) + continue; + p = &(*p)->f_next; + } + /* nothing valid in this list */ + if ( !n->f_list ) { + op->o_tmpfree( n, op->o_tmpmemctx ); + return NULL; + } + /* Only 1 element in this list */ + if ((n->f_choice & SLAPD_FILTER_MASK) != LDAP_FILTER_NOT && + !n->f_list->f_next ) { + f = n->f_list; + *n = *f; + op->o_tmpfree( f, op->o_tmpmemctx ); + } + break; + } + } + return n; +} + +static void +trans_filter_free( Operation *op, Filter *f ) +{ + Filter *n, *p, *next; + + f->f_choice &= SLAPD_FILTER_MASK; + + switch( f->f_choice ) { + case LDAP_FILTER_AND: + case LDAP_FILTER_OR: + case LDAP_FILTER_NOT: + /* Free in reverse order */ + n = NULL; + for ( p = f->f_list; p; p = next ) { + next = p->f_next; + p->f_next = n; + n = p; + } + for ( p = n; p; p = next ) { + next = p->f_next; + trans_filter_free( op, p ); + } + break; + default: + break; + } + op->o_tmpfree( f, op->o_tmpmemctx ); } /* @@ -648,7 +1079,10 @@ static int translucent_search(Operation *op, SlapReply *rs) { slap_overinst *on = (slap_overinst *) op->o_bd->bd_info; translucent_info *ov = on->on_bi.bi_private; slap_callback cb = { NULL, NULL, NULL, NULL }; - int rc; + trans_ctx tc; + Filter *fl, *fr; + struct berval fbv; + int rc = 0; Debug(LDAP_DEBUG_TRACE, "==> translucent_search: <%s> %s\n", op->o_req_dn.bv_val, op->ors_filterstr.bv_val, 0); @@ -658,14 +1092,76 @@ static int translucent_search(Operation *op, SlapReply *rs) { "remote DB not available"); return(rs->sr_err); } + + fr = ov->remote ? trans_filter_dup( op, op->ors_filter, ov->remote ) : NULL; + fl = ov->local ? trans_filter_dup( op, op->ors_filter, ov->local ) : NULL; cb.sc_response = (slap_response *) translucent_search_cb; - cb.sc_private = op->o_bd; + cb.sc_private = &tc; cb.sc_next = op->o_callback; + ov->db.be_acl = op->o_bd->be_acl; + tc.db = op->o_bd; + tc.on = on; + tc.orig = op->ors_filter; + tc.list = NULL; + tc.step = 0; + fbv = op->ors_filterstr; + op->o_callback = &cb; - op->o_bd = &ov->db; - rc = ov->db.bd_info->bi_op_search(op, rs); - op->o_bd = cb.sc_private; + + if ( fr || !fl ) { + op->o_bd = &ov->db; + tc.step |= RMT_SIDE; + if ( fl ) { + tc.step |= USE_LIST; + op->ors_filter = fr; + filter2bv_x( op, fr, &op->ors_filterstr ); + } + rc = ov->db.bd_info->bi_op_search(op, rs); + op->o_bd = tc.db; + if ( fl ) { + op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); + } + } + if ( fl && !rc ) { + tc.step |= LCL_SIDE; + op->ors_filter = fl; + filter2bv_x( op, fl, &op->ors_filterstr ); + rc = overlay_op_walk( op, rs, op_search, on->on_info, on->on_next ); + op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); + } + op->ors_filterstr = fbv; + op->ors_filter = tc.orig; + op->o_callback = cb.sc_next; + /* Send out anything remaining on the list and finish */ + if ( tc.step & USE_LIST ) { + if ( tc.list ) { + Avlnode *av; + + av = tavl_end( tc.list, TAVL_DIR_LEFT ); + while ( av ) { + rs->sr_entry = av->avl_data; + rc = test_filter( op, rs->sr_entry, op->ors_filter ); + if ( rc == LDAP_COMPARE_TRUE ) { + rs->sr_flags = REP_ENTRY_MUSTBEFREED; + rc = send_search_entry( op, rs ); + if ( rc ) break; + } else { + entry_free( rs->sr_entry ); + } + av = tavl_next( av, TAVL_DIR_RIGHT ); + } + tavl_free( tc.list, NULL ); + rs->sr_entry = NULL; + } + send_ldap_result( op, rs ); + } + + /* Free in reverse order */ + if ( fl ) + trans_filter_free( op, fl ); + if ( fr ) + trans_filter_free( op, fr ); return rc; } @@ -681,6 +1177,7 @@ static int translucent_bind(Operation *op, SlapReply *rs) { slap_overinst *on = (slap_overinst *) op->o_bd->bd_info; translucent_info *ov = on->on_bi.bi_private; BackendDB *db; + slap_callback sc = { 0 }, *save_cb; int rc; Debug(LDAP_DEBUG_TRACE, "translucent_bind: <%s> method %d\n", @@ -691,10 +1188,26 @@ static int translucent_bind(Operation *op, SlapReply *rs) { "remote DB not available"); return(rs->sr_err); } + + if (ov->bind_local) { + sc.sc_response = slap_null_cb; + save_cb = op->o_callback; + op->o_callback = ≻ + } + db = op->o_bd; op->o_bd = &ov->db; + ov->db.be_acl = op->o_bd->be_acl; rc = ov->db.bd_info->bi_op_bind(op, rs); op->o_bd = db; + + if (ov->bind_local) { + op->o_callback = save_cb; + if (rc != LDAP_SUCCESS) { + rc = SLAP_CB_CONTINUE; + } + } + return rc; } @@ -760,7 +1273,6 @@ static int translucent_db_init(BackendDB *be, ConfigReply *cr) { on->on_bi.bi_private = ov; ov->db = *be; ov->db.be_private = NULL; - ov->db.be_pcl_mutexp = &ov->db.be_pcl_mutex; ov->defer_db_open = 1; if ( !backend_db_init( "ldap", &ov->db, -1, NULL )) { @@ -795,7 +1307,7 @@ static int translucent_db_open(BackendDB *be, ConfigReply *cr) { if ( ov->defer_db_open ) return 0; - rc = backend_startup_one( &ov->db, NULL ); + rc = backend_startup_one( &ov->db, cr ); if(rc) Debug(LDAP_DEBUG_TRACE, "translucent: bi_db_open() returned error %d\n", rc, 0, 0); @@ -805,8 +1317,7 @@ static int translucent_db_open(BackendDB *be, ConfigReply *cr) { /* ** translucent_db_close() -** if the captive backend has a close() method, call it; -** free any config data; +** if the captive backend has a close() method, call it ** */ @@ -828,7 +1339,8 @@ translucent_db_close( BackendDB *be, ConfigReply *cr ) /* ** translucent_db_destroy() -** if the captive backend has a db_destroy() method, call it +** if the captive backend has a db_destroy() method, call it; +** free any config data ** */ @@ -842,6 +1354,10 @@ translucent_db_destroy( BackendDB *be, ConfigReply *cr ) Debug(LDAP_DEBUG_TRACE, "==> translucent_db_destroy\n", 0, 0, 0); if ( ov ) { + if ( ov->remote ) + anlist_free( ov->remote, 1, NULL ); + if ( ov->local ) + anlist_free( ov->local, 1, NULL ); if ( ov->db.be_private != NULL ) { backend_stopdown_one( &ov->db ); } @@ -879,6 +1395,7 @@ int translucent_initialize() { translucent.on_bi.bi_op_search = translucent_search; translucent.on_bi.bi_op_compare = translucent_compare; translucent.on_bi.bi_connection_destroy = translucent_connection_destroy; + translucent.on_bi.bi_extended = translucent_exop; translucent.on_bi.bi_cf_ocs = translucentocs; rc = config_register_schema ( translucentcfg, translucentocs );