From: Kurt Zeilenga Date: Tue, 29 Oct 2002 02:24:18 +0000 (+0000) Subject: LCUP and hasSubordinates, both behind #ifdefs X-Git-Tag: OPENLDAP_REL_ENG_2_1_9~49 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=eb1eab502268cdb6d04e8985a6e4bb9e4d292a5e;p=openldap LCUP and hasSubordinates, both behind #ifdefs modrdn newSuperior fix --- diff --git a/servers/slapd/back-bdb/Makefile.in b/servers/slapd/back-bdb/Makefile.in index e7ecee8691..3644280e08 100644 --- a/servers/slapd/back-bdb/Makefile.in +++ b/servers/slapd/back-bdb/Makefile.in @@ -4,12 +4,12 @@ SRCS = init.c tools.c config.c \ add.c bind.c compare.c delete.c modify.c modrdn.c search.c \ extended.c passwd.c referral.c attribute.c group.c operational.c \ attr.c index.c key.c dbcache.c filterindex.c \ - dn2entry.c dn2id.c error.c id2entry.c idl.c nextid.c cache.c + dn2entry.c dn2id.c error.c id2entry.c idl.c nextid.c cache.c lcup.c OBJS = init.lo tools.lo config.lo \ add.lo bind.lo compare.lo delete.lo modify.lo modrdn.lo search.lo \ extended.lo passwd.lo referral.lo attribute.lo group.lo operational.lo \ attr.lo index.lo key.lo dbcache.lo filterindex.lo \ - dn2entry.lo dn2id.lo error.lo id2entry.lo idl.lo nextid.lo cache.lo + dn2entry.lo dn2id.lo error.lo id2entry.lo idl.lo nextid.lo cache.lo lcup.lo LDAP_INCDIR= ../../../include LDAP_LIBDIR= ../../../libraries diff --git a/servers/slapd/back-bdb/add.c b/servers/slapd/back-bdb/add.c index 76fac90435..286c44f864 100644 --- a/servers/slapd/back-bdb/add.c +++ b/servers/slapd/back-bdb/add.c @@ -42,6 +42,10 @@ bdb_add( #endif int noop = 0; +#ifdef LDAP_CLIENT_UPDATE + Operation* ps_list; +#endif + #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, ARGS, "==> bdb_add: %s\n", e->e_dn, 0, 0 ); #else @@ -458,6 +462,7 @@ retry: /* transaction retry */ goto return_results; } + if( op->o_noop ) { if (( rc=TXN_ABORT( ltid )) != 0 ) { text = "txn_abort (no-op) failed"; @@ -542,6 +547,14 @@ return_results: send_ldap_result( conn, op, rc, NULL, text, NULL, NULL ); +#ifdef LDAP_CLIENT_UPDATE + if ( rc == LDAP_SUCCESS && !noop ) { + LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) { + bdb_psearch( be, conn, op, ps_list, e, LCUP_PSEARCH_BY_ADD ); + } + } +#endif /* LDAP_CLIENT_UPDATE */ + if( rc == LDAP_SUCCESS && bdb->bi_txn_cp ) { ldap_pvt_thread_yield(); TXN_CHECKPOINT( bdb->bi_dbenv, @@ -557,3 +570,4 @@ done: return ( ( rc == LDAP_SUCCESS ) ? noop : rc ); } + diff --git a/servers/slapd/back-bdb/back-bdb.h b/servers/slapd/back-bdb/back-bdb.h index 56b4150330..7fea91c851 100644 --- a/servers/slapd/back-bdb/back-bdb.h +++ b/servers/slapd/back-bdb/back-bdb.h @@ -114,6 +114,9 @@ struct bdb_info { ID bi_lastid; ldap_pvt_thread_mutex_t bi_lastid_mutex; +#ifdef LDAP_CLIENT_UPDATE + LDAP_LIST_HEAD(pl, slap_op) psearch_list; +#endif }; #define bi_id2entry bi_databases[BDB_ID2ENTRY] diff --git a/servers/slapd/back-bdb/delete.c b/servers/slapd/back-bdb/delete.c index 5a19eb1e59..8d4c14e9c7 100644 --- a/servers/slapd/back-bdb/delete.c +++ b/servers/slapd/back-bdb/delete.c @@ -44,6 +44,10 @@ bdb_delete( int noop = 0; +#ifdef LDAP_CLIENT_UPDATE + Operation* ps_list; +#endif + #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, ARGS, "==> bdb_delete: %s\n", dn->bv_val, 0, 0 ); #else @@ -489,6 +493,14 @@ retry: /* transaction retry */ return_results: send_ldap_result( conn, op, rc, NULL, text, NULL, NULL ); +#ifdef LDAP_CLIENT_UPDATE + if ( rc == LDAP_SUCCESS && !noop ) { + LDAP_LIST_FOREACH( ps_list, &bdb->psearch_list, link ) { + bdb_psearch( be, conn, op, ps_list, e, LCUP_PSEARCH_BY_DELETE ); + } + } +#endif /* LDAP_CLIENT_UPDATE */ + if(rc == LDAP_SUCCESS && bdb->bi_txn_cp ) { ldap_pvt_thread_yield(); TXN_CHECKPOINT( bdb->bi_dbenv, diff --git a/servers/slapd/back-bdb/external.h b/servers/slapd/back-bdb/external.h index f7c285a808..9e595ef9ff 100644 --- a/servers/slapd/back-bdb/external.h +++ b/servers/slapd/back-bdb/external.h @@ -33,6 +33,10 @@ extern BI_chk_referrals bdb_referrals; extern BI_operational bdb_operational; +#ifdef SLAP_X_FILTER_HASSUBORDINATES +extern BI_has_subordinates bdb_hasSubordinates; +#endif /* SLAP_X_FILTER_HASSUBORDINATES */ + /* tools.c */ extern BI_tool_entry_open bdb_tool_entry_open; extern BI_tool_entry_close bdb_tool_entry_close; diff --git a/servers/slapd/back-bdb/init.c b/servers/slapd/back-bdb/init.c index 7bd08c6726..aa956d2b1e 100644 --- a/servers/slapd/back-bdb/init.c +++ b/servers/slapd/back-bdb/init.c @@ -93,6 +93,10 @@ bdb_db_init( BackendDB *be ) bdb->bi_lock_detect = DB_LOCK_DEFAULT; +#ifdef LDAP_CLIENT_UPDATE + LDAP_LIST_INIT (&bdb->psearch_list); +#endif + ldap_pvt_thread_mutex_init( &bdb->bi_database_mutex ); ldap_pvt_thread_mutex_init( &bdb->bi_lastid_mutex ); ldap_pvt_thread_mutex_init( &bdb->bi_cache.lru_mutex ); @@ -611,6 +615,9 @@ bdb_initialize( bi->bi_chk_referrals = bdb_referrals; bi->bi_operational = bdb_operational; +#ifdef SLAP_X_FILTER_HASSUBORDINATES + bi->bi_has_subordinates = bdb_hasSubordinates; +#endif /* SLAP_X_FILTER_HASSUBORDINATES */ bi->bi_entry_release_rw = bdb_entry_release; /* diff --git a/servers/slapd/back-bdb/lcup.c b/servers/slapd/back-bdb/lcup.c new file mode 100644 index 0000000000..4897f4e2c4 --- /dev/null +++ b/servers/slapd/back-bdb/lcup.c @@ -0,0 +1,850 @@ +/* lcup.c - lcup operations */ +/* $OpenLDAP$ */ +/* + * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "portable.h" + +#include + +#include "back-bdb.h" +#include "idl.h" +#include "external.h" + +#ifdef LDAP_CLIENT_UPDATE + +int +bdb_abandon( + BackendDB *be, + Connection *conn, + ber_int_t id ) +{ + Operation *ps_list; + struct bdb_info *bdb = (struct bdb_info *) be->be_private; + + LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) { + if ( ps_list->o_connid == conn->c_connid ) { + if ( ps_list->o_msgid == id ) { + ps_list->o_abandon = 1; + LDAP_LIST_REMOVE( ps_list, link ); + slap_op_free ( ps_list ); + return LDAP_SUCCESS; + } + } + } + return LDAP_UNAVAILABLE; +} + +int +bdb_add_psearch_spec( + BackendDB *be, + Connection *conn, + Operation *op, + struct berval *base, + struct berval *nbase, + int scope, + int deref, + int slimit, + int tlimit, + Filter *filter, + struct berval *fstr, + AttributeName *attrs, + int attrsonly ) +{ + struct bdb_info *bdb = (struct bdb_info *) be->be_private; + + LDAP_LIST_FIRST(&op->psearch_spec) = (struct lcup_search_spec *) + calloc ( 1, sizeof ( struct lcup_search_spec ) ); + + LDAP_LIST_FIRST(&op->psearch_spec)->op = op; + + LDAP_LIST_FIRST(&op->psearch_spec)->base = ber_dupbv(NULL, base); + LDAP_LIST_FIRST(&op->psearch_spec)->nbase = ber_dupbv(NULL, nbase); + + LDAP_LIST_FIRST(&op->psearch_spec)->scope = scope; + LDAP_LIST_FIRST(&op->psearch_spec)->deref = deref; + LDAP_LIST_FIRST(&op->psearch_spec)->slimit = slimit; + LDAP_LIST_FIRST(&op->psearch_spec)->tlimit = tlimit; + + LDAP_LIST_FIRST(&op->psearch_spec)->filter = filter; + LDAP_LIST_FIRST(&op->psearch_spec)->filterstr = ber_dupbv(NULL, fstr); + LDAP_LIST_FIRST(&op->psearch_spec)->attrs = attrs; + + LDAP_LIST_FIRST(&op->psearch_spec)->attrsonly = attrsonly; + + LDAP_LIST_FIRST(&op->psearch_spec)->entry_count = 0; + + LDAP_LIST_INSERT_HEAD( &bdb->psearch_list, op, link ); +} + +int +bdb_psearch( + BackendDB *be, + Connection *conn, + Operation *op, + Operation *ps_op, + Entry *entry, + int psearch_type ) +{ + struct bdb_info *bdb = (struct bdb_info *) be->be_private; + int rc; + const char *text = NULL; + time_t stoptime; + unsigned cursor; + ID id; + ID candidates[BDB_IDL_UM_SIZE]; + Entry *e = NULL; + BerVarray v2refs = NULL; + Entry *matched = NULL; + struct berval realbase = { 0, NULL }; + int nentries = 0; + int manageDSAit; + + Filter lcupf, csnfnot, csnfeq, csnfand, csnfge; + AttributeAssertion aa_ge, aa_eq; + struct berval entrycsn_bv = { 0, NULL }; + struct berval latest_entrycsn_bv = { 0, NULL }; + + struct slap_limits_set *limit = NULL; + int isroot = 0; + int scopeok = 0; + + u_int32_t locker; + DB_LOCK lock; + + Connection *ps_conn = ps_op->o_conn; + struct berval *base = LDAP_LIST_FIRST(&ps_op->psearch_spec)->base; + struct berval *nbase = LDAP_LIST_FIRST(&ps_op->psearch_spec)->nbase; + int scope = LDAP_LIST_FIRST(&ps_op->psearch_spec)->scope; + int deref = LDAP_LIST_FIRST(&ps_op->psearch_spec)->deref; + int slimit = LDAP_LIST_FIRST(&ps_op->psearch_spec)->slimit; + int tlimit = LDAP_LIST_FIRST(&ps_op->psearch_spec)->tlimit; + Filter *filter = LDAP_LIST_FIRST(&ps_op->psearch_spec)->filter; + struct berval *filterstr = LDAP_LIST_FIRST(&ps_op->psearch_spec)->filterstr; + int attrsonly = LDAP_LIST_FIRST(&ps_op->psearch_spec)->attrsonly; + AttributeName uuid_attr[2]; + AttributeName *attrs = uuid_attr; + + if ( psearch_type != LCUP_PSEARCH_BY_DELETE && + psearch_type != LCUP_PSEARCH_BY_SCOPEOUT ) + { + attrs = LDAP_LIST_FIRST(&ps_op->psearch_spec)->attrs; + } else { + attrs[0].an_desc = slap_schema.si_ad_entryUUID; + attrs[0].an_oc = NULL; + ber_dupbv( &attrs[0].an_name, &attrs[0].an_desc->ad_cname ); + attrs[1].an_desc = NULL; + attrs[1].an_oc = NULL; + attrs[1].an_name.bv_len = 0; + attrs[1].an_name.bv_val = NULL; + } + +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "bdb_back_search\n", 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "=> bdb_back_search\n", + 0, 0, 0); +#endif + + manageDSAit = get_manageDSAit( ps_op ); + + rc = LOCK_ID (bdb->bi_dbenv, &locker ); + switch(rc) { + case 0: + break; + default: + send_ldap_result( ps_conn, ps_op, rc=LDAP_OTHER, + NULL, "internal error", NULL, NULL ); + if ( psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + ch_free( attrs[0].an_name.bv_val ); + return rc; + } + + if ( nbase->bv_len == 0 ) { + /* DIT root special case */ + e = (Entry *) &slap_entry_root; + rc = 0; + } else +#ifdef BDB_ALIASES + /* get entry with reader lock */ + if ( deref & LDAP_DEREF_FINDING ) { + e = deref_dn_r( be, nbase-, &err, &matched, &text ); + + } else +#endif + { +dn2entry_retry: + rc = bdb_dn2entry_r( be, NULL, nbase, &e, &matched, 0, locker, &lock ); + } + + switch(rc) { + case DB_NOTFOUND: + case 0: + break; + case LDAP_BUSY: + if (e != NULL) { + bdb_cache_return_entry_r(bdb->bi_dbenv, &bdb->bi_cache, + e, &lock); + } + if (matched != NULL) { + bdb_cache_return_entry_r(bdb->bi_dbenv, &bdb->bi_cache, + matched, &lock); + } + send_ldap_result( ps_conn, ps_op, LDAP_BUSY, + NULL, "ldap server busy", NULL, NULL ); + LOCK_ID_FREE( bdb->bi_dbenv, locker ); + if ( psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + ch_free( attrs[0].an_name.bv_val ); + return LDAP_BUSY; + case DB_LOCK_DEADLOCK: + case DB_LOCK_NOTGRANTED: + goto dn2entry_retry; + default: + if (e != NULL) { + bdb_cache_return_entry_r(bdb->bi_dbenv, &bdb->bi_cache, + e, &lock); + } + if (matched != NULL) { + bdb_cache_return_entry_r(bdb->bi_dbenv, &bdb->bi_cache, + matched, &lock); + } + send_ldap_result( ps_conn, ps_op, rc=LDAP_OTHER, + NULL, "internal error", NULL, NULL ); + LOCK_ID_FREE( bdb->bi_dbenv, locker ); + if ( psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + ch_free( attrs[0].an_name.bv_val ); + return rc; + } + + if ( e == NULL ) { + struct berval matched_dn = { 0, NULL }; + BerVarray refs = NULL; + + if ( matched != NULL ) { + BerVarray erefs; + ber_dupbv( &matched_dn, &matched->e_name ); + + erefs = is_entry_referral( matched ) + ? get_entry_referrals( be, ps_conn, ps_op, matched ) + : NULL; + + bdb_cache_return_entry_r(bdb->bi_dbenv, &bdb->bi_cache, + matched, &lock); + matched = NULL; + + if( erefs ) { + refs = referral_rewrite( erefs, &matched_dn, + base, scope ); + ber_bvarray_free( erefs ); + } + + } else { + refs = referral_rewrite( default_referral, + NULL, base, scope ); + } + + send_ldap_result( ps_conn, ps_op, rc=LDAP_REFERRAL , + matched_dn.bv_val, text, refs, NULL ); + + LOCK_ID_FREE( bdb->bi_dbenv, locker ); + if ( refs ) ber_bvarray_free( refs ); + if ( matched_dn.bv_val ) ber_memfree( matched_dn.bv_val ); + if ( psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + ch_free( attrs[0].an_name.bv_val ); + return rc; + } + + if (!manageDSAit && e != &slap_entry_root && is_entry_referral( e ) ) { + /* entry is a referral, don't allow add */ + struct berval matched_dn; + BerVarray erefs, refs; + + ber_dupbv( &matched_dn, &e->e_name ); + erefs = get_entry_referrals( be, ps_conn, ps_op, e ); + refs = NULL; + + bdb_cache_return_entry_r( bdb->bi_dbenv, &bdb->bi_cache, e, &lock ); + e = NULL; + + if( erefs ) { + refs = referral_rewrite( erefs, &matched_dn, + base, scope ); + ber_bvarray_free( erefs ); + } + +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, RESULTS, + "bdb_search: entry is referral\n", 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "bdb_search: entry is referral\n", + 0, 0, 0 ); +#endif + + send_ldap_result( ps_conn, ps_op, LDAP_REFERRAL, + matched_dn.bv_val, + refs ? NULL : "bad referral object", + refs, NULL ); + + LOCK_ID_FREE( bdb->bi_dbenv, locker ); + ber_bvarray_free( refs ); + ber_memfree( matched_dn.bv_val ); + if ( psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + ch_free( attrs[0].an_name.bv_val ); + return 1; + } + + /* if not root, get appropriate limits */ + if ( be_isroot( be, &ps_op->o_ndn ) ) { + isroot = 1; + } else { + ( void ) get_limits( be, &ps_op->o_ndn, &limit ); + } + + /* The time/size limits come first because they require very little + * effort, so there's no chance the candidates are selected and then + * the request is not honored only because of time/size constraints */ + + /* if no time limit requested, use soft limit (unless root!) */ + if ( isroot ) { + if ( tlimit == 0 ) { + tlimit = -1; /* allow root to set no limit */ + } + + if ( slimit == 0 ) { + slimit = -1; + } + + } else { + /* if no limit is required, use soft limit */ + if ( tlimit <= 0 ) { + tlimit = limit->lms_t_soft; + + /* if requested limit higher than hard limit, abort */ + } else if ( tlimit > limit->lms_t_hard ) { + /* no hard limit means use soft instead */ + if ( limit->lms_t_hard == 0 && tlimit > limit->lms_t_soft ) { + tlimit = limit->lms_t_soft; + + /* positive hard limit means abort */ + } else if ( limit->lms_t_hard > 0 ) { + send_search_result( ps_conn, ps_op, + LDAP_UNWILLING_TO_PERFORM, + NULL, NULL, NULL, NULL, 0 ); + rc = 0; + goto done; + } + + /* negative hard limit means no limit */ + } + + /* if no limit is required, use soft limit */ + if ( slimit <= 0 ) { + slimit = limit->lms_s_soft; + + /* if requested limit higher than hard limit, abort */ + } else if ( slimit > limit->lms_s_hard ) { + /* no hard limit means use soft instead */ + if ( limit->lms_s_hard == 0 && slimit > limit->lms_s_soft ) { + slimit = limit->lms_s_soft; + + /* positive hard limit means abort */ + } else if ( limit->lms_s_hard > 0 ) { + send_search_result( ps_conn, ps_op, + LDAP_UNWILLING_TO_PERFORM, + NULL, NULL, NULL, NULL, 0 ); + rc = 0; + goto done; + } + + /* negative hard limit means no limit */ + } + } + + /* compute it anyway; root does not use it */ + stoptime = ps_op->o_time + tlimit; + + /* candidates = { e } */ + candidates[0] = 1; + candidates[1] = entry->e_id; + + /* need normalized dn below */ + ber_dupbv( &realbase, &e->e_nname ); + + if ( e != &slap_entry_root ) { + bdb_cache_return_entry_r(bdb->bi_dbenv, &bdb->bi_cache, e, &lock); + } + e = NULL; + + if ( candidates[0] == 0 ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: no candidates\n", 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "bdb_search: no candidates\n", + 0, 0, 0 ); +#endif + + send_search_result( ps_conn, ps_op, + LDAP_SUCCESS, + NULL, NULL, NULL, NULL, 0 ); + + rc = 1; + goto done; + } + + /* if not root and candidates exceed to-be-checked entries, abort */ + if ( !isroot && limit->lms_s_unchecked != -1 ) { + if ( BDB_IDL_N(candidates) > (unsigned) limit->lms_s_unchecked ) { + send_search_result( ps_conn, ps_op, LDAP_ADMINLIMIT_EXCEEDED, + NULL, NULL, NULL, NULL, 0 ); + rc = 1; + goto done; + } + } + + lcupf.f_choice = LDAP_FILTER_AND; + lcupf.f_and = &csnfnot; + lcupf.f_next = NULL; + + csnfnot.f_choice = LDAP_FILTER_NOT; + csnfnot.f_not = &csnfeq; + csnfnot.f_next = &csnfand; + + csnfeq.f_choice = LDAP_FILTER_EQUALITY; + csnfeq.f_ava = &aa_eq; + csnfeq.f_av_desc = slap_schema.si_ad_entryCSN; + ber_dupbv( &csnfeq.f_av_value, &ps_op->o_clientupdate_state ); + + csnfand.f_choice = LDAP_FILTER_AND; + csnfand.f_and = &csnfge; + csnfand.f_next = NULL; + + csnfge.f_choice = LDAP_FILTER_GE; + csnfge.f_ava = &aa_ge; + csnfge.f_av_desc = slap_schema.si_ad_entryCSN; + ber_dupbv( &csnfge.f_av_value, &ps_op->o_clientupdate_state ); + csnfge.f_next = filter; + + if ( !BDB_IDL_IS_RANGE( candidates ) ) { + cursor = bdb_idl_search( candidates, entry->e_id ); + if ( candidates[cursor] != entry->e_id ) { + rc = LDAP_SUCCESS; + goto done; + } + } else { + if ( entry->e_id < BDB_IDL_RANGE_FIRST(candidates) && + entry->e_id > BDB_IDL_RANGE_LAST(candidates) ) + { + rc = LDAP_SUCCESS; + goto done; + } + } + + id = entry->e_id; + + /* check for abandon */ + if ( ps_op->o_abandon ) { + rc = 0; + goto done; + } + + /* check time limit */ + if ( tlimit != -1 && slap_get_time() > stoptime ) { + send_search_result( ps_conn, ps_op, rc = LDAP_TIMELIMIT_EXCEEDED, + NULL, NULL, v2refs, NULL, nentries ); + goto done; + } + + e = entry; + +#ifdef BDB_SUBENTRIES + if ( is_entry_subentry( e ) ) { + if( scope != LDAP_SCOPE_BASE ) { + if(!get_subentries_visibility( ps_op )) { + /* only subentries are visible */ + goto test_done; + } + + } else if ( get_subentries( ps_op ) && + !get_subentries_visibility( ps_op )) + { + /* only subentries are visible */ + goto test_done; + } + + } else if ( get_subentries_visibility( ps_op )) { + /* only subentries are visible */ + goto test_done; + } +#endif + +#ifdef BDB_ALIASES + if ( deref & LDAP_DEREF_SEARCHING && is_entry_alias( e ) ) { + Entry *matched; + int err; + const char *text; + + e = deref_entry_r( be, e, &err, &matched, &text ); + + if( e == NULL ) { + e = matched; + goto test_done; + } + + if( e->e_id == id ) { + /* circular loop */ + goto test_done; + } + + /* need to skip alias which deref into scope */ + if( scope & LDAP_SCOPE_ONELEVEL ) { + struct berval pdn; + + dnParent( &e->e_nname, &pdn ): + if ( ber_bvcmp( pdn, &realbase ) ) { + goto test_done; + } + + } else if ( dnIsSuffix( &e->e_nname, &realbase ) ) { + /* alias is within scope */ +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: \"%s\" in subtree\n", e->edn, 0, 0); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: \"%s\" in subtree\n", + e->e_dn, 0, 0 ); +#endif + goto test_done; + } + + scopeok = 1; + } +#endif + + /* + * if it's a referral, add it to the list of referrals. only do + * this for non-base searches, and don't check the filter + * explicitly here since it's only a candidate anyway. + */ + if ( !manageDSAit && scope != LDAP_SCOPE_BASE && + is_entry_referral( e ) ) + { + struct berval dn; + + /* check scope */ + if ( !scopeok && scope == LDAP_SCOPE_ONELEVEL ) { + if ( !be_issuffix( be, &e->e_nname ) ) { + dnParent( &e->e_nname, &dn ); + scopeok = dn_match( &dn, &realbase ); + } else { + scopeok = (realbase.bv_len == 0); + } + + } else if ( !scopeok && scope == LDAP_SCOPE_SUBTREE ) { + scopeok = dnIsSuffix( &e->e_nname, &realbase ); + + } else { + scopeok = 1; + } + + if( scopeok ) { + BerVarray erefs = get_entry_referrals( + be, ps_conn, ps_op, e ); + BerVarray refs = referral_rewrite( erefs, + &e->e_name, NULL, + scope == LDAP_SCOPE_SUBTREE + ? LDAP_SCOPE_SUBTREE + : LDAP_SCOPE_BASE ); + + send_search_reference( be, ps_conn, ps_op, + e, refs, NULL, &v2refs ); + + ber_bvarray_free( refs ); + + } else { +#ifdef NEW_LOGGING + LDAP_LOG(OPERATION, DETAIL2, + "bdb_search: candidate referral %ld scope not okay\n", + id, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: candidate referral %ld scope not okay\n", + id, 0, 0 ); +#endif + } + + goto test_done; + } + + if ( psearch_type != LCUP_PSEARCH_BY_SCOPEOUT ) { + rc = test_filter( be, ps_conn, ps_op, e, &lcupf ); + } else { + rc = LDAP_COMPARE_TRUE; + } + + if ( rc == LDAP_COMPARE_TRUE ) { + struct berval dn; + + /* check scope */ + if ( !scopeok && scope == LDAP_SCOPE_ONELEVEL ) { + if ( be_issuffix( be, &e->e_nname ) ) { + scopeok = (realbase.bv_len == 0); + } else { + dnParent( &e->e_nname, &dn ); + scopeok = dn_match( &dn, &realbase ); + } + + } else if ( !scopeok && scope == LDAP_SCOPE_SUBTREE ) { + scopeok = dnIsSuffix( &e->e_nname, &realbase ); + + } else { + scopeok = 1; + } + + if ( scopeok ) { + /* check size limit */ + if ( --slimit == -1 ) { + send_search_result( ps_conn, ps_op, + rc = LDAP_SIZELIMIT_EXCEEDED, NULL, NULL, + v2refs, NULL, nentries ); + goto done; + } + + if (e) { + int result; + +#if 0 /* noop is masked SLAP_CTRL_UPDATE */ + if( ps_op->o_noop ) { + result = 0; + } else +#endif + { + if ( psearch_type == LCUP_PSEARCH_BY_ADD || + psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_MODIFY || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + { + Attribute* a; + int ret; + int res; + const char *text = NULL; + LDAPControl *ctrls[2]; + struct berval *bv; + + BerElement *ber = ber_alloc_t( LBER_USE_DER ); + + if ( ber == NULL ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: ber_alloc_t failed\n", + 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: ber_alloc_t failed\n", + 0, 0, 0 ); +#endif + send_ldap_result( ps_conn, ps_op, rc=LDAP_OTHER, + NULL, "internal error", NULL, NULL ); + goto done; + } + + LDAP_LIST_FIRST(&ps_op->psearch_spec)->entry_count++; + + ctrls[0] = ch_malloc ( sizeof ( LDAPControl ) ); + ctrls[1] = NULL; + + if ( LDAP_LIST_FIRST( + &ps_op->psearch_spec)->entry_count % + ps_op->o_clientupdate_interval == 0 ) + { + /* Send cookie */ + for ( a = e->e_attrs; a != NULL; a = a->a_next ) { + AttributeDescription *desc = a->a_desc; + if ( desc == slap_schema.si_ad_entryCSN ) { + ber_dupbv( &entrycsn_bv, &a->a_vals[0] ); + if ( latest_entrycsn_bv.bv_val == NULL ) { + ber_dupbv( &latest_entrycsn_bv, + &entrycsn_bv ); + } else { + res = value_match( &ret, desc, + desc->ad_type->sat_ordering, + SLAP_MR_ASSERTION_SYNTAX_MATCH, + &entrycsn_bv, &latest_entrycsn_bv, + &text ); + if ( res != LDAP_SUCCESS ) { + ret = 0; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: " + "value_match failed\n", + 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: " + "value_match failed\n", + 0, 0, 0 ); +#endif + } + + if ( ret > 0 ) { + ch_free(latest_entrycsn_bv.bv_val); + latest_entrycsn_bv.bv_val = NULL; + ber_dupbv( &latest_entrycsn_bv, + &entrycsn_bv ); + } + } + } + } + + if ( psearch_type != LCUP_PSEARCH_BY_DELETE || + psearch_type != LCUP_PSEARCH_BY_SCOPEOUT ) + { + ber_printf( ber, "{bb{sON}N}", + SLAP_LCUP_STATE_UPDATE_FALSE, + SLAP_LCUP_ENTRY_DELETED_FALSE, + LCUP_COOKIE_OID, &entrycsn_bv ); + } else { + ber_printf( ber, "{bb{sON}N}", + SLAP_LCUP_STATE_UPDATE_FALSE, + SLAP_LCUP_ENTRY_DELETED_TRUE, + LCUP_COOKIE_OID, &entrycsn_bv ); + } + + ch_free( entrycsn_bv.bv_val ); + entrycsn_bv.bv_val = NULL; + + } else { + /* Do not send cookie */ + if ( psearch_type != LCUP_PSEARCH_BY_DELETE || + psearch_type != LCUP_PSEARCH_BY_SCOPEOUT ) + { + ber_printf( ber, "{bbN}", + SLAP_LCUP_STATE_UPDATE_FALSE, + SLAP_LCUP_ENTRY_DELETED_FALSE ); + } else { + ber_printf( ber, "{bbN}", + SLAP_LCUP_STATE_UPDATE_FALSE, + SLAP_LCUP_ENTRY_DELETED_TRUE ); + } + } + + ctrls[0]->ldctl_oid = LDAP_CONTROL_ENTRY_UPDATE; + ctrls[0]->ldctl_iscritical = ps_op->o_clientupdate; + ret = ber_flatten( ber, &bv ); + + if ( ret < 0 ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: ber_flatten failed\n", + 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: ber_flatten failed\n", + 0, 0, 0 ); +#endif + send_ldap_result( ps_conn, ps_op, rc=LDAP_OTHER, + NULL, "internal error", NULL, NULL ); + goto done; + } + + ber_dupbv( &ctrls[0]->ldctl_value, bv ); + + result = send_search_entry( be, ps_conn, ps_op, + e, attrs, attrsonly, ctrls); + + ch_free( ctrls[0]->ldctl_value.bv_val ); + ch_free( ctrls[0] ); + ber_free( ber, 1 ); + ber_bvfree( bv ); + + if ( psearch_type == LCUP_PSEARCH_BY_MODIFY ) { + struct psid_entry* psid_e; + LDAP_LIST_FOREACH( psid_e, &op->premodify_list, + link) + { + if( psid_e->ps == + LDAP_LIST_FIRST(&ps_op->psearch_spec)) + { + LDAP_LIST_REMOVE(psid_e, link); + break; + } + } + if (psid_e != NULL) free (psid_e); + } + + } else if ( psearch_type == LCUP_PSEARCH_BY_PREMODIFY ) { + struct psid_entry* psid_e; + psid_e = (struct psid_entry *) calloc (1, + sizeof(struct psid_entry)); + psid_e->ps = LDAP_LIST_FIRST(&ps_op->psearch_spec); + LDAP_LIST_INSERT_HEAD( &op->premodify_list, + psid_e, link ); + + } else { + printf("Error !\n"); + } + } + + switch (result) { + case 0: /* entry sent ok */ + nentries++; + break; + case 1: /* entry not sent */ + break; + case -1: /* connection closed */ + rc = LDAP_OTHER; + goto done; + } + } + } else { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: %ld scope not okay\n", (long) id, 0, 0); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: %ld scope not okay\n", (long) id, 0, 0 ); +#endif + } + } else { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "bdb_search: %ld does match filter\n", (long) id, 0, 0); +#else + Debug( LDAP_DEBUG_TRACE, + "bdb_search: %ld does match filter\n", + (long) id, 0, 0 ); +#endif + } + + test_done: + rc = LDAP_SUCCESS; + + done: + if ( csnfeq.f_ava != NULL && csnfeq.f_av_value.bv_val != NULL ) { + ch_free( csnfeq.f_av_value.bv_val ); + } + + if ( csnfge.f_ava != NULL && csnfge.f_av_value.bv_val != NULL ) { + ch_free( csnfge.f_av_value.bv_val ); + } + + LOCK_ID_FREE( bdb->bi_dbenv, locker ); + + if( v2refs ) ber_bvarray_free( v2refs ); + if( realbase.bv_val ) ch_free( realbase.bv_val ); + if ( psearch_type == LCUP_PSEARCH_BY_DELETE || + psearch_type == LCUP_PSEARCH_BY_SCOPEOUT ) + ch_free( attrs[0].an_name.bv_val ); + + return rc; +} + +#endif /* LDAP_CLIENT_UPDATE */ diff --git a/servers/slapd/back-bdb/modify.c b/servers/slapd/back-bdb/modify.c index 965bb0b098..3f267b0313 100644 --- a/servers/slapd/back-bdb/modify.c +++ b/servers/slapd/back-bdb/modify.c @@ -277,6 +277,12 @@ bdb_modify( int noop = 0; +#ifdef LDAP_CLIENT_UPDATE + Operation* ps_list; + struct psid_entry* pm_list; + struct psid_entry* pm_prev; +#endif + #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, ENTRY, "bdb_modify: %s\n", dn->bv_val, 0, 0 ); #else @@ -295,6 +301,17 @@ retry: /* transaction retry */ Debug(LDAP_DEBUG_TRACE, "bdb_modify: retrying...\n", 0, 0, 0); #endif + +#ifdef LDAP_CLIENT_UPDATE + pm_list = LDAP_LIST_FIRST(&op->premodify_list); + while ( pm_list != NULL ) { + LDAP_LIST_REMOVE ( pm_list, link ); + pm_prev = pm_list; + pm_list = LDAP_LIST_NEXT ( pm_list, link ); + free (pm_prev); + } +#endif + rc = TXN_ABORT( ltid ); ltid = NULL; op->o_private = NULL; @@ -405,6 +422,14 @@ retry: /* transaction retry */ ber_bvarray_free( refs ); goto done; } + +#ifdef LDAP_CLIENT_UPDATE + if ( rc == LDAP_SUCCESS && !op->o_noop ) { + LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) { + bdb_psearch(be, conn, op, ps_list, e, LCUP_PSEARCH_BY_PREMODIFY ); + } + } +#endif /* LDAP_CLIENT_UPDATE */ /* Modify the entry */ rc = bdb_modify_internal( be, conn, op, ltid, modlist, e, @@ -493,6 +518,24 @@ return_results: send_ldap_result( conn, op, rc, NULL, text, NULL, NULL ); +#ifdef LDAP_CLIENT_UPDATE + if ( rc == LDAP_SUCCESS && !op->o_noop ) { + /* Loop through in-scope entries for each psearch spec */ + LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) { + bdb_psearch( be, conn, op, ps_list, e, LCUP_PSEARCH_BY_MODIFY ); + } + pm_list = LDAP_LIST_FIRST(&op->premodify_list); + while ( pm_list != NULL ) { + bdb_psearch(be, conn, op, pm_list->ps->op, + e, LCUP_PSEARCH_BY_SCOPEOUT); + LDAP_LIST_REMOVE ( pm_list, link ); + pm_prev = pm_list; + pm_list = LDAP_LIST_NEXT ( pm_list, link ); + free (pm_prev); + } + } +#endif /* LDAP_CLIENT_UPDATE */ + if( rc == LDAP_SUCCESS && bdb->bi_txn_cp ) { ldap_pvt_thread_yield(); TXN_CHECKPOINT( bdb->bi_dbenv, @@ -501,6 +544,15 @@ return_results: done: if( ltid != NULL ) { +#ifdef LDAP_CLIENT_UPDATE + pm_list = LDAP_LIST_FIRST(&op->premodify_list); + while ( pm_list != NULL ) { + LDAP_LIST_REMOVE ( pm_list, link ); + pm_prev = pm_list; + pm_list = LDAP_LIST_NEXT ( pm_list, link ); + free (pm_prev); + } +#endif TXN_ABORT( ltid ); op->o_private = NULL; } diff --git a/servers/slapd/back-bdb/modrdn.c b/servers/slapd/back-bdb/modrdn.c index 6017044122..7d3613fba1 100644 --- a/servers/slapd/back-bdb/modrdn.c +++ b/servers/slapd/back-bdb/modrdn.c @@ -62,6 +62,12 @@ bdb_modrdn( int noop = 0; +#ifdef LDAP_CLIENT_UPDATE + Operation* ps_list; + struct psid_entry* pm_list; + struct psid_entry* pm_prev; +#endif + #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, ENTRY, "==>bdb_modrdn(%s,%s,%s)\n", dn->bv_val,newrdn->bv_val, newSuperior ? newSuperior->bv_val : "NULL" ); @@ -71,14 +77,6 @@ bdb_modrdn( newSuperior ? newSuperior->bv_val : "NULL" ); #endif -#if 0 - if( newSuperior != NULL ) { - rc = LDAP_UNWILLING_TO_PERFORM; - text = "newSuperior not implemented (yet)"; - goto return_results; - } -#endif - if( 0 ) { retry: /* transaction retry */ if (e != NULL) { @@ -96,6 +94,17 @@ retry: /* transaction retry */ #else Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn: retrying...\n", 0, 0, 0 ); #endif + +#ifdef LDAP_CLIENT_UPDATE + pm_list = LDAP_LIST_FIRST(&op->premodify_list); + while ( pm_list != NULL ) { + LDAP_LIST_REMOVE ( pm_list, link ); + pm_prev = pm_list; + pm_list = LDAP_LIST_NEXT ( pm_list, link ); + free (pm_prev); + } +#endif + rc = TXN_ABORT( ltid ); ltid = NULL; op->o_private = NULL; @@ -384,6 +393,21 @@ retry: /* transaction retry */ newSuperior->bv_val, 0, 0 ); #endif + /* newSuperior == oldParent? */ + if( dn_match( &p_ndn, nnewSuperior ) ) { +#ifdef NEW_LOGGING + LDAP_LOG( BACK_LDBM, INFO, "bdb_back_modrdn: " + "new parent \"%s\" same as the old parent \"%s\"\n", + newSuperior->bv_val, p_dn.bv_val, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "bdb_back_modrdn: " + "new parent \"%s\" same as the old parent \"%s\"\n", + newSuperior->bv_val, p_dn.bv_val, 0 ); +#endif + newSuperior = NULL; /* ignore newSuperior */ + } + } + if ( newSuperior != NULL ) { if ( newSuperior->bv_len ) { np_dn = newSuperior; np_ndn = nnewSuperior; @@ -392,7 +416,8 @@ retry: /* transaction retry */ /* newSuperior == entry being moved?, if so ==> ERROR */ /* Get Entry with dn=newSuperior. Does newSuperior exist? */ - rc = bdb_dn2entry_r( be, ltid, nnewSuperior, &np, NULL, 0, locker, &lock ); + rc = bdb_dn2entry_r( be, + ltid, nnewSuperior, &np, NULL, 0, locker, &lock ); switch( rc ) { case 0: @@ -700,6 +725,14 @@ retry: /* transaction retry */ goto return_results; } +#ifdef LDAP_CLIENT_UPDATE + if ( rc == LDAP_SUCCESS && !op->o_noop ) { + LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) { + bdb_psearch(be, conn, op, ps_list, e, LCUP_PSEARCH_BY_PREMODIFY ); + } + } +#endif /* LDAP_CLIENT_UPDATE */ + /* modify entry */ rc = bdb_modify_internal( be, conn, op, ltid, &mod[0], e, &text, textbuf, textlen ); @@ -794,6 +827,24 @@ return_results: send_ldap_result( conn, op, rc, NULL, text, NULL, NULL ); +#ifdef LDAP_CLIENT_UPDATE + if ( rc == LDAP_SUCCESS && !op->o_noop ) { + /* Loop through in-scope entries for each psearch spec */ + LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) { + bdb_psearch( be, conn, op, ps_list, e, LCUP_PSEARCH_BY_MODIFY ); + } + pm_list = LDAP_LIST_FIRST(&op->premodify_list); + while ( pm_list != NULL ) { + bdb_psearch(be, conn, op, pm_list->ps->op, + e, LCUP_PSEARCH_BY_SCOPEOUT); + LDAP_LIST_REMOVE ( pm_list, link ); + pm_prev = pm_list; + pm_list = LDAP_LIST_NEXT ( pm_list, link ); + free (pm_prev); + } + } +#endif /* LDAP_CLIENT_UPDATE */ + if( rc == LDAP_SUCCESS && bdb->bi_txn_cp ) { ldap_pvt_thread_yield(); TXN_CHECKPOINT( bdb->bi_dbenv, @@ -836,6 +887,15 @@ done: } if( ltid != NULL ) { +#ifdef LDAP_CLIENT_UPDATE + pm_list = LDAP_LIST_FIRST(&op->premodify_list); + while ( pm_list != NULL ) { + LDAP_LIST_REMOVE ( pm_list, link ); + pm_prev = pm_list; + pm_list = LDAP_LIST_NEXT ( pm_list, link ); + free (pm_prev); + } +#endif TXN_ABORT( ltid ); op->o_private = NULL; } diff --git a/servers/slapd/back-bdb/operational.c b/servers/slapd/back-bdb/operational.c index 1c5d4b14d6..7cead61e7c 100644 --- a/servers/slapd/back-bdb/operational.c +++ b/servers/slapd/back-bdb/operational.c @@ -16,9 +16,9 @@ #include "proto-bdb.h" /* - * sets the supported operational attributes (if required) + * sets *hasSubordinates to LDAP_COMPARE_TRUE/LDAP_COMPARE_FALSE + * if the entry has children or not. */ - int bdb_hasSubordinates( BackendDB *be, @@ -124,6 +124,9 @@ return_results: return rc; } +/* + * sets the supported operational attributes (if required) + */ int bdb_operational( BackendDB *be, diff --git a/servers/slapd/back-bdb/proto-bdb.h b/servers/slapd/back-bdb/proto-bdb.h index 6c7dfeb586..d3df97b10a 100644 --- a/servers/slapd/back-bdb/proto-bdb.h +++ b/servers/slapd/back-bdb/proto-bdb.h @@ -364,6 +364,40 @@ int bdb_cache_delete_entry( ); void bdb_cache_release_all( Cache *cache ); +#ifdef LDAP_CLIENT_UPDATE +int bdb_abandon( + BackendDB *be, + Connection *conn, + ber_int_t id +); + +int bdb_add_psearch_spec( + BackendDB *be, + Connection *conn, + Operation *op, + struct berval *base, + struct berval *nbase, + int scope, + int deref, + int slimit, + int tlimit, + Filter *filter, + struct berval *fstr, + AttributeName *attrs, + int attrsonly +); + +int bdb_psearch( + BackendDB *be, + Connection *conn, + Operation *op, + Operation *ps_op, + Entry *entry, + int psearch_type +); + +#endif + #ifdef BDB_REUSE_LOCKERS int bdb_locker_id( Operation *op, DB_ENV *env, int *locker ); diff --git a/servers/slapd/back-bdb/search.c b/servers/slapd/back-bdb/search.c index 91db533895..5d2bdcec14 100644 --- a/servers/slapd/back-bdb/search.c +++ b/servers/slapd/back-bdb/search.c @@ -67,10 +67,6 @@ bdb_search( struct slap_limits_set *limit = NULL; int isroot = 0; -#ifdef SLAP_X_FILTER_HASSUBORDINATES - int filter_hasSubordinates = 0; -#endif /* SLAP_X_FILTER_HASSUBORDINATES */ - u_int32_t locker; DB_LOCK lock; @@ -81,6 +77,15 @@ bdb_search( 0, 0, 0); #endif +#ifdef LDAP_CLIENT_UPDATE + if ( op->o_clientupdate_type & SLAP_LCUP_PERSIST ) { + bdb_add_psearch_spec( be, conn, op, base, base, scope, + deref, slimit, tlimit, filter, filterstr, attrs, attrsonly ); + return LDAP_SUCCESS; + } +#endif + + manageDSAit = get_manageDSAit( op ); rc = LOCK_ID (bdb->bi_dbenv, &locker ); @@ -333,14 +338,6 @@ dn2entry_retry: } } -#ifdef SLAP_X_FILTER_HASSUBORDINATES - /* - * is hasSubordinates used in the filter ? - * FIXME: we may compute this directly when parsing the filter - */ - filter_hasSubordinates = filter_has_subordinates( filter ); -#endif /* SLAP_X_FILTER_HASSUBORDINATES */ - #ifdef LDAP_CLIENT_UPDATE if ( op->o_clientupdate_type & SLAP_LCUP_SYNC ) { lcupf.f_choice = LDAP_FILTER_AND; @@ -373,9 +370,6 @@ dn2entry_retry: id = bdb_idl_next( candidates, &cursor ) ) { int scopeok = 0; -#ifdef SLAP_X_FILTER_HASSUBORDINATES - Attribute *hasSubordinates = NULL; -#endif /* SLAP_X_FILTER_HASSUBORDINATES */ /* check for abandon */ if ( op->o_abandon ) { @@ -539,31 +533,6 @@ id2entry_retry: goto loop_continue; } -#ifdef SLAP_X_FILTER_HASSUBORDINATES - /* - * if hasSubordinates is used in the filter, - * append it to the entry's attributes - */ - if ( filter_hasSubordinates ) { - int hs; - - rc = bdb_hasSubordinates( be, conn, op, e, &hs); - if ( rc != LDAP_SUCCESS ) { - goto loop_continue; - } - - hasSubordinates = slap_operational_hasSubordinate( - hs == LDAP_COMPARE_TRUE ); - - if ( hasSubordinates == NULL ) { - goto loop_continue; - } - - hasSubordinates->a_next = e->e_attrs; - e->e_attrs = hasSubordinates; - } -#endif /* SLAP_X_FILTER_HASSUBORDINATES */ - /* if it matches the filter and scope, send it */ #ifdef LDAP_CLIENT_UPDATE if ( op->o_clientupdate_type & SLAP_LCUP_SYNC ) { @@ -574,21 +543,6 @@ id2entry_retry: rc = test_filter( be, conn, op, e, filter ); } -#ifdef SLAP_X_FILTER_HASSUBORDINATES - if ( hasSubordinates ) { - /* - * FIXME: this is fairly inefficient, because - * if hasSubordinates is among the required - * attrs, it will be added again later; - * maybe we should leave it and check - * check later if it's already present, - * if required - */ - e->e_attrs = e->e_attrs->a_next; - attr_free( hasSubordinates ); - } -#endif /* SLAP_X_FILTER_HASSUBORDINATES */ - if ( rc == LDAP_COMPARE_TRUE ) { struct berval dn; @@ -866,7 +820,7 @@ done: bdb_cache_return_entry_r ( bdb->bi_dbenv, &bdb->bi_cache, e, &lock ); } -#ifdef LDAP_CLIENT_UDATE +#ifdef LDAP_CLIENT_UPDATE if ( op->o_clientupdate_type & SLAP_LCUP_SYNC ) { if ( csnfeq.f_ava != NULL && csnfeq.f_av_value.bv_val != NULL ) { ch_free( csnfeq.f_av_value.bv_val );