--- servers/slapd/overlays/syncprov.c 2007/09/23 23:31:24 1.199 +++ servers/slapd/overlays/syncprov.c 2008/03/20 23:09:24 1.224 @@ -1,8 +1,8 @@ -/* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.198 2007/09/23 02:40:17 hyc Exp $ */ +/* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.223 2008/03/19 23:31:42 hyc Exp $ */ /* syncprov.c - syncrepl provider */ /* This work is part of OpenLDAP Software . * - * Copyright 2004-2007 The OpenLDAP Foundation. + * Copyright 2004-2008 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -624,8 +624,11 @@ again: maxid = i; } } - fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN>=%s)", - cf.f_av_value.bv_val ); + fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ), + "(entryCSN>=%s)", cf.f_av_value.bv_val ); + if ( fop.ors_filterstr.bv_len < 0 || fop.ors_filterstr.bv_len >= sizeof( buf ) ) { + return LDAP_OTHER; + } fop.ors_attrsonly = 0; fop.ors_attrs = csn_anlist; fop.ors_slimit = SLAP_NO_LIMIT; @@ -649,16 +652,19 @@ again: /* Look for exact match the first time */ if ( findcsn_retry ) { cf.f_choice = LDAP_FILTER_EQUALITY; - fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN=%s)", - cf.f_av_value.bv_val ); + fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ), + "(entryCSN=%s)", cf.f_av_value.bv_val ); /* On retry, look for <= */ } else { cf.f_choice = LDAP_FILTER_LE; fop.ors_limit = &fc_limits; memset( &fc_limits, 0, sizeof( fc_limits )); fc_limits.lms_s_unchecked = 1; - fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)", - cf.f_av_value.bv_val ); + fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ), + "(entryCSN<=%s)", cf.f_av_value.bv_val ); + } + if ( fop.ors_filterstr.bv_len < 0 || fop.ors_filterstr.bv_len >= sizeof( buf ) ) { + return LDAP_OTHER; } fop.ors_attrsonly = 1; fop.ors_attrs = slap_anlist_no_attrs; @@ -690,7 +696,10 @@ again: break; } - fop.o_bd->bd_info = on->on_info->oi_orig; + if ( on->on_next ) + fop.o_bd->bd_info = (BackendInfo *)on->on_next; + else + fop.o_bd->bd_info = on->on_info->oi_orig; fop.o_bd->be_search( &fop, &frs ); fop.o_bd->bd_info = (BackendInfo *)on; @@ -770,6 +779,8 @@ syncprov_sendresp( Operation *op, opcook BER_BVZERO( &csns[1] ); slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, so->s_sid ); + Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: cookie=%s\n", cookie.bv_val, 0, 0 ); + e_uuid.e_attrs = &a_uuid; a_uuid.a_desc = slap_schema.si_ad_entryUUID; a_uuid.a_nvals = &opc->suuid; @@ -829,8 +840,10 @@ syncprov_sendresp( Operation *op, opcook /* Play back queued responses */ static int -syncprov_qplay( Operation *op, slap_overinst *on, syncops *so ) +syncprov_qplay( Operation *op, struct re_s *rtask ) { + syncops *so = rtask->arg; + slap_overinst *on = LDAP_SLIST_FIRST(&so->s_op->o_extra)->oe_key; syncres *sr; Entry *e; opcookie opc; @@ -845,10 +858,10 @@ syncprov_qplay( Operation *op, slap_over so->s_res = sr->s_next; if ( !so->s_res ) so->s_restail = NULL; - ldap_pvt_thread_mutex_unlock( &so->s_mutex ); - + /* Exit loop with mutex held */ if ( !sr || so->s_op->o_abandon ) break; + ldap_pvt_thread_mutex_unlock( &so->s_mutex ); opc.sdn = sr->s_dn; opc.sndn = sr->s_ndn; @@ -875,9 +888,24 @@ syncprov_qplay( Operation *op, slap_over ch_free( sr ); - if ( rc ) + if ( rc ) { + /* Exit loop with mutex held */ + ldap_pvt_thread_mutex_lock( &so->s_mutex ); break; + } + } + + /* wait until we get explicitly scheduled again */ + ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); + ldap_pvt_runqueue_stoptask( &slapd_rq, rtask ); + if ( rc == 0 ) { + ldap_pvt_runqueue_resched( &slapd_rq, rtask, 1 ); + } else { + /* bail out on any error */ + ldap_pvt_runqueue_remove( &slapd_rq, rtask ); } + ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); + ldap_pvt_thread_mutex_unlock( &so->s_mutex ); return rc; } @@ -887,7 +915,6 @@ syncprov_qtask( void *ctx, void *arg ) { struct re_s *rtask = arg; syncops *so = rtask->arg; - slap_overinst *on = so->s_op->o_private; OperationBuffer opbuf; Operation *op; BackendDB be; @@ -909,25 +936,14 @@ syncprov_qtask( void *ctx, void *arg ) be = *so->s_op->o_bd; be.be_flags |= SLAP_DBFLAG_OVERLAY; op->o_bd = &be; - op->o_private = NULL; + LDAP_SLIST_FIRST(&op->o_extra) = NULL; op->o_callback = NULL; - rc = syncprov_qplay( op, on, so ); + rc = syncprov_qplay( op, rtask ); /* decrement use count... */ syncprov_free_syncop( so ); - /* wait until we get explicitly scheduled again */ - ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); - ldap_pvt_runqueue_stoptask( &slapd_rq, rtask ); - if ( rc == 0 ) { - ldap_pvt_runqueue_resched( &slapd_rq, rtask, 1 ); - } else { - /* bail out on any error */ - ldap_pvt_runqueue_remove( &slapd_rq, rtask ); - } - ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); - #if 0 /* FIXME: connection_close isn't exported from slapd. * should it be? */ @@ -974,15 +990,18 @@ static int syncprov_qresp( opcookie *opc, syncops *so, int mode ) { syncres *sr; - int sid; + int sid, srsize; /* Don't send changes back to their originator */ sid = slap_parse_csn_sid( &opc->sctxcsn ); if ( sid >= 0 && sid == so->s_sid ) return LDAP_SUCCESS; - sr = ch_malloc(sizeof(syncres) + opc->suuid.bv_len + 1 + - opc->sdn.bv_len + 1 + opc->sndn.bv_len + 1 + opc->sctxcsn.bv_len + 1 ); + srsize = sizeof(syncres) + opc->suuid.bv_len + 1 + + opc->sdn.bv_len + 1 + opc->sndn.bv_len + 1; + if ( opc->sctxcsn.bv_len ) + srsize += opc->sctxcsn.bv_len + 1; + sr = ch_malloc( srsize ); sr->s_next = NULL; sr->s_dn.bv_val = (char *)(sr + 1); sr->s_dn.bv_len = opc->sdn.bv_len; @@ -995,9 +1014,13 @@ syncprov_qresp( opcookie *opc, syncops * opc->sndn.bv_val ) + 1; sr->s_uuid.bv_len = opc->suuid.bv_len; AC_MEMCPY( sr->s_uuid.bv_val, opc->suuid.bv_val, opc->suuid.bv_len ); - sr->s_csn.bv_val = sr->s_uuid.bv_val + sr->s_uuid.bv_len + 1; + if ( opc->sctxcsn.bv_len ) { + sr->s_csn.bv_val = sr->s_uuid.bv_val + sr->s_uuid.bv_len + 1; + strcpy( sr->s_csn.bv_val, opc->sctxcsn.bv_val ); + } else { + sr->s_csn.bv_val = NULL; + } sr->s_csn.bv_len = opc->sctxcsn.bv_len; - strcpy( sr->s_csn.bv_val, opc->sctxcsn.bv_val ); ldap_pvt_thread_mutex_lock( &so->s_mutex ); if ( !so->s_res ) { @@ -1194,7 +1217,7 @@ syncprov_matchops( Operation *op, opcook } /* check if current o_req_dn is in scope and matches filter */ - if ( fc.fscope && test_filter( op, e, ss->s_op->ors_filter ) == + if ( fc.fscope && test_filter( ss->s_op, e, ss->s_op->ors_filter ) == LDAP_COMPARE_TRUE ) { if ( saveit ) { sm = op->o_tmpalloc( sizeof(syncmatches), op->o_tmpmemctx ); @@ -1286,6 +1309,7 @@ syncprov_checkpoint( Operation *op, Slap Operation opm; SlapReply rsm = { 0 }; slap_callback cb = {0}; + BackendDB be; mod.sml_numvals = si->si_numcsns; mod.sml_values = si->si_ctxcsn; @@ -1301,8 +1325,12 @@ syncprov_checkpoint( Operation *op, Slap opm.o_callback = &cb; opm.orm_modlist = &mod; opm.orm_no_opattrs = 1; - opm.o_req_dn = op->o_bd->be_suffix[0]; - opm.o_req_ndn = op->o_bd->be_nsuffix[0]; + if ( SLAP_GLUE_SUBORDINATE( op->o_bd )) { + be = *on->on_info->oi_origdb; + opm.o_bd = &be; + } + opm.o_req_dn = opm.o_bd->be_suffix[0]; + opm.o_req_ndn = opm.o_bd->be_nsuffix[0]; opm.o_bd->bd_info = on->on_info->oi_orig; opm.o_managedsait = SLAP_CONTROL_NONCRITICAL; opm.o_no_schema_check = 1; @@ -1310,7 +1338,6 @@ syncprov_checkpoint( Operation *op, Slap if ( mod.sml_next != NULL ) { slap_mods_free( mod.sml_next, 1 ); } - opm.orm_no_opattrs = 0; } static void @@ -1504,7 +1531,10 @@ syncprov_playlog( Operation *op, SlapRep fop.ors_filter = ⁡ cb.sc_response = playlog_cb; - fop.o_bd->bd_info = on->on_info->oi_orig; + if ( on->on_next ) + fop.o_bd->bd_info = (BackendInfo *)on->on_next; + else + fop.o_bd->bd_info = on->on_info->oi_orig; for ( i=ndel; isr_state.rid, - srs->sr_state.sid ); + if ( delcsn[0].bv_len ) { + slap_compose_sync_cookie( op, &cookie, delcsn, srs->sr_state.rid, + srs->sr_state.sid ); + } + + Debug( LDAP_DEBUG_SYNC, "syncprov_playlog: cookie=%s\n", cookie.bv_val, 0, 0 ); + uuids[ndel].bv_val = NULL; - syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, &cookie, 0, uuids, 1 ); + syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, + delcsn[0].bv_len ? &cookie : NULL, 0, uuids, 1 ); op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx ); } op->o_tmpfree( uuids, op->o_tmpmemctx ); @@ -1546,7 +1582,7 @@ syncprov_op_response( Operation *op, Sla { struct berval maxcsn = BER_BVNULL; char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE]; - int do_check = 0; + int do_check = 0, have_psearches; /* Update our context CSN */ cbuf[0] = '\0'; @@ -1589,8 +1625,12 @@ syncprov_op_response( Operation *op, Sla } if ( si->si_chktime && (op->o_time - si->si_chklast >= si->si_chktime )) { - do_check = 1; - si->si_chklast = op->o_time; + if ( si->si_chklast ) { + do_check = 1; + si->si_chklast = op->o_time; + } else { + si->si_chklast = 1; + } } } ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock ); @@ -1605,7 +1645,10 @@ syncprov_op_response( Operation *op, Sla opc->sctxcsn.bv_val = cbuf; /* Handle any persistent searches */ - if ( si->si_ops ) { + ldap_pvt_thread_mutex_lock( &si->si_ops_mutex ); + have_psearches = ( si->si_ops != NULL ); + ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex ); + if ( have_psearches ) { switch(op->o_tag) { case LDAP_REQ_ADD: case LDAP_REQ_MODIFY: @@ -1680,10 +1723,10 @@ syncprov_op_compare( Operation *op, Slap rs->sr_err = LDAP_COMPARE_FALSE; - if ( value_find_ex( op->oq_compare.rs_ava->aa_desc, + if ( attr_valfind( &a, SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH | SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH, - a.a_nvals, &op->oq_compare.rs_ava->aa_value, op->o_tmpmemctx ) == 0 ) + &op->oq_compare.rs_ava->aa_value, NULL, op->o_tmpmemctx ) == 0 ) { rs->sr_err = LDAP_COMPARE_TRUE; } @@ -1708,12 +1751,19 @@ syncprov_op_mod( Operation *op, SlapRepl { slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; syncprov_info_t *si = on->on_bi.bi_private; + slap_callback *cb; + opcookie *opc; + int have_psearches, cbsize; - slap_callback *cb = op->o_tmpcalloc(1, sizeof(slap_callback)+ - sizeof(opcookie) + - (si->si_ops ? sizeof(modinst) : 0 ), - op->o_tmpmemctx); - opcookie *opc = (opcookie *)(cb+1); + ldap_pvt_thread_mutex_lock( &si->si_ops_mutex ); + have_psearches = ( si->si_ops != NULL ); + ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex ); + + cbsize = sizeof(slap_callback) + sizeof(opcookie) + + (have_psearches ? sizeof(modinst) : 0 ); + + cb = op->o_tmpcalloc(1, cbsize, op->o_tmpmemctx); + opc = (opcookie *)(cb+1); opc->son = on; cb->sc_response = syncprov_op_response; cb->sc_cleanup = syncprov_op_cleanup; @@ -1724,7 +1774,7 @@ syncprov_op_mod( Operation *op, SlapRepl /* If there are active persistent searches, lock this operation. * See seqmod.c for the locking logic on its own. */ - if ( si->si_ops ) { + if ( have_psearches ) { modtarget *mt, mtdummy; modinst *mi; @@ -1743,7 +1793,13 @@ syncprov_op_mod( Operation *op, SlapRepl /* wait for this op to get to head of list */ while ( mt->mt_mods != mi ) { ldap_pvt_thread_mutex_unlock( &mt->mt_mutex ); - ldap_pvt_thread_yield(); + /* FIXME: if dynamic config can delete overlays or + * databases we'll have to check for cleanup here. + * Currently it's not an issue because there are + * no dynamic config deletes... + */ + if ( !ldap_pvt_thread_pool_pausecheck( &connection_pool )) + ldap_pvt_thread_yield(); ldap_pvt_thread_mutex_lock( &mt->mt_mutex ); /* clean up if the caller is giving up */ @@ -1771,7 +1827,7 @@ syncprov_op_mod( Operation *op, SlapRepl } } - if (( si->si_ops || si->si_logs ) && op->o_tag != LDAP_REQ_ADD ) + if (( have_psearches || si->si_logs ) && op->o_tag != LDAP_REQ_ADD ) syncprov_matchops( op, opc, 1 ); return SLAP_CB_CONTINUE; @@ -1792,7 +1848,9 @@ typedef struct searchstate { BerVarray ss_ctxcsn; int *ss_sids; int ss_numcsns; - int ss_present; +#define SS_PRESENT 0x01 +#define SS_CHANGED 0x02 + int ss_flags; } searchstate; static int @@ -1809,6 +1867,7 @@ syncprov_search_cleanup( Operation *op, typedef struct SyncOperationBuffer { Operation sob_op; Opheader sob_hdr; + OpExtra sob_oe; AttributeName sob_extra; /* not always present */ /* Further data allocated here */ } SyncOperationBuffer; @@ -1837,6 +1896,7 @@ syncprov_detach_op( Operation *op, synco sopbuf2 = ch_calloc( 1, size ); op2 = &sopbuf2->sob_op; op2->o_hdr = &sopbuf2->sob_hdr; + LDAP_SLIST_FIRST(&op2->o_extra) = &sopbuf2->sob_oe; /* Copy the fields we care about explicitly, leave the rest alone */ *op2->o_hdr = *op->o_hdr; @@ -1844,7 +1904,8 @@ syncprov_detach_op( Operation *op, synco op2->o_time = op->o_time; op2->o_bd = on->on_info->oi_origdb; op2->o_request = op->o_request; - op2->o_private = on; + LDAP_SLIST_FIRST(&op2->o_extra)->oe_key = on; + LDAP_SLIST_NEXT(LDAP_SLIST_FIRST(&op2->o_extra), oe_next) = NULL; ptr = (char *) sopbuf2 + offsetof( SyncOperationBuffer, sob_extra ); if ( i ) { @@ -1895,12 +1956,10 @@ syncprov_detach_op( Operation *op, synco op2->o_do_not_cache = 1; /* Add op2 to conn so abandon will find us */ - ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); op->o_conn->c_n_ops_executing++; op->o_conn->c_n_ops_completed--; LDAP_STAILQ_INSERT_TAIL( &op->o_conn->c_ops, op2, o_next ); so->s_flags |= PS_IS_DETACHED; - ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); /* Prevent anyone else from trying to send a result for this op */ op->o_abandon = 1; @@ -1940,16 +1999,20 @@ syncprov_search_response( Operation *op, rs->sr_entry->e_name.bv_val, 0, 0 ); return LDAP_SUCCESS; } - /* Make sure entry is less than the snapshot'd contextCSN */ - for ( i=0; iss_numcsns; i++ ) { - if ( sid == ss->ss_sids[i] && ber_bvcmp( &a->a_nvals[0], - &ss->ss_ctxcsn[i] ) > 0 ) { - Debug( LDAP_DEBUG_SYNC, - "Entry %s CSN %s greater than snapshot %s\n", - rs->sr_entry->e_name.bv_val, - a->a_nvals[0].bv_val, - ss->ss_ctxcsn[i].bv_val ); - return LDAP_SUCCESS; + + /* If not a persistent search */ + if ( !ss->ss_so ) { + /* Make sure entry is less than the snapshot'd contextCSN */ + for ( i=0; iss_numcsns; i++ ) { + if ( sid == ss->ss_sids[i] && ber_bvcmp( &a->a_nvals[0], + &ss->ss_ctxcsn[i] ) > 0 ) { + Debug( LDAP_DEBUG_SYNC, + "Entry %s CSN %s greater than snapshot %s\n", + rs->sr_entry->e_name.bv_val, + a->a_nvals[0].bv_val, + ss->ss_ctxcsn[i].bv_val ); + return LDAP_SUCCESS; + } } } @@ -1977,36 +2040,56 @@ syncprov_search_response( Operation *op, } else if ( rs->sr_type == REP_RESULT && rs->sr_err == LDAP_SUCCESS ) { struct berval cookie; - slap_compose_sync_cookie( op, &cookie, ss->ss_ctxcsn, - srs->sr_state.rid, srs->sr_state.sid ); + if ( ss->ss_flags & SS_CHANGED ) { + slap_compose_sync_cookie( op, &cookie, ss->ss_ctxcsn, + srs->sr_state.rid, srs->sr_state.sid ); + + Debug( LDAP_DEBUG_SYNC, "syncprov_search_response: cookie=%s\n", cookie.bv_val, 0, 0 ); + } - /* Is this a regular refresh? */ + /* Is this a regular refresh? + * Note: refresh never gets here if there were no changes + */ if ( !ss->ss_so ) { rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2, op->o_tmpmemctx ); rs->sr_ctrls[1] = NULL; rs->sr_err = syncprov_done_ctrl( op, rs, rs->sr_ctrls, - 0, 1, &cookie, ss->ss_present ? LDAP_SYNC_REFRESH_PRESENTS : + 0, 1, &cookie, ( ss->ss_flags & SS_PRESENT ) ? LDAP_SYNC_REFRESH_PRESENTS : LDAP_SYNC_REFRESH_DELETES ); op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx ); } else { /* It's RefreshAndPersist, transition to Persist phase */ - syncprov_sendinfo( op, rs, ss->ss_present ? + syncprov_sendinfo( op, rs, ( ss->ss_flags & SS_PRESENT ) ? LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE, - &cookie, 1, NULL, 0 ); - op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx ); + ( ss->ss_flags & SS_CHANGED ) ? &cookie : NULL, + 1, NULL, 0 ); + if ( ss->ss_flags & SS_CHANGED ) + op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx ); /* Detach this Op from frontend control */ ldap_pvt_thread_mutex_lock( &ss->ss_so->s_mutex ); + ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); - /* Turn off the refreshing flag */ - ss->ss_so->s_flags ^= PS_IS_REFRESHING; + /* But not if this connection was closed along the way */ + if ( op->o_abandon ) { + ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); + ldap_pvt_thread_mutex_unlock( &ss->ss_so->s_mutex ); + syncprov_free_syncop( ss->ss_so ); + return SLAPD_ABANDON; - syncprov_detach_op( op, ss->ss_so, on ); + } else { + /* Turn off the refreshing flag */ + ss->ss_so->s_flags ^= PS_IS_REFRESHING; + + syncprov_detach_op( op, ss->ss_so, on ); - /* If there are queued responses, fire them off */ - if ( ss->ss_so->s_res ) - syncprov_qstart( ss->ss_so ); + ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); + + /* If there are queued responses, fire them off */ + if ( ss->ss_so->s_res ) + syncprov_qstart( ss->ss_so ); + } ldap_pvt_thread_mutex_unlock( &ss->ss_so->s_mutex ); return LDAP_SUCCESS; @@ -2022,7 +2105,7 @@ syncprov_op_search( Operation *op, SlapR slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private; slap_callback *cb; - int gotstate = 0, nochange = 0, do_present; + int gotstate = 0, changed = 0, do_present = 0; syncops *sop = NULL; searchstate *ss; sync_control *srs; @@ -2037,8 +2120,6 @@ syncprov_op_search( Operation *op, SlapR return rs->sr_err; } - do_present = si->si_nopres ? 0 : 1; - srs = op->o_controls[slap_cids.sc_LDAPsync]; op->o_managedsait = SLAP_CONTROL_NONCRITICAL; @@ -2106,6 +2187,9 @@ syncprov_op_search( Operation *op, SlapR if ( !numcsns ) goto no_change; + if ( !si->si_nopres ) + do_present = SS_PRESENT; + /* If there are SIDs we don't recognize in the cookie, drop them */ for (i=0; isr_state.numcsns; ) { for (j=0; jsr_state.numcsns == numcsns ) { - int i, j, changed = 0; + int i, j; for ( i=0; isr_state.numcsns; i++ ) { for ( j=0; jsr_state.sids[i] != sids[j] ) continue; if ( !bvmatch( &srs->sr_state.ctxcsn[i], &ctxcsn[j] )) - changed = 1; + changed = SS_CHANGED; break; } if ( changed ) break; } if ( !changed ) { -no_change: nochange = 1; - if ( !(op->o_sync_mode & SLAP_SYNC_PERSIST) ) { + do_present = 0; +no_change: if ( !(op->o_sync_mode & SLAP_SYNC_PERSIST) ) { LDAPControl *ctrls[2]; ctrls[0] = NULL; @@ -2188,6 +2272,8 @@ no_change: nochange = 1; if ( si->si_usehint && srs->sr_rhint == 0 ) { if ( ctxcsn ) ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx ); + if ( sids ) + op->o_tmpfree( sids, op->o_tmpmemctx ); send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" ); return rs->sr_err; } @@ -2198,10 +2284,15 @@ no_change: nochange = 1; LDAP_SUCCESS ) { if ( ctxcsn ) ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx ); + if ( sids ) + op->o_tmpfree( sids, op->o_tmpmemctx ); send_ldap_result( op, rs ); return rs->sr_err; } } + } else { + /* No consumer state, assume something has changed */ + changed = SS_CHANGED; } shortcut: @@ -2213,7 +2304,7 @@ shortcut: } /* If something changed, find the changes */ - if ( gotstate && !nochange ) { + if ( gotstate && changed ) { Filter *fand, *fava; fand = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx ); @@ -2240,7 +2331,7 @@ shortcut: ss = (searchstate *)(cb+1); ss->ss_on = on; ss->ss_so = sop; - ss->ss_present = do_present; + ss->ss_flags = do_present | changed; ss->ss_ctxcsn = ctxcsn; ss->ss_numcsns = numcsns; ss->ss_sids = sids; @@ -2254,7 +2345,7 @@ shortcut: * the refresh phase, just invoke the response callback to transition * us into persist phase */ - if ( nochange ) { + if ( !changed ) { rs->sr_err = LDAP_SUCCESS; rs->sr_nentries = 0; send_ldap_result( op, rs ); @@ -2271,6 +2362,12 @@ syncprov_operational( slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private; + /* This prevents generating unnecessarily; frontend will strip + * any statically stored copy. + */ + if ( op->o_sync != SLAP_CONTROL_NONE ) + return SLAP_CB_CONTINUE; + if ( rs->sr_entry && dn_match( &rs->sr_entry->e_nname, op->o_bd->be_nsuffix )) { @@ -2368,10 +2465,14 @@ sp_cf_gen(ConfigArgs *c) case SP_CHKPT: if ( si->si_chkops || si->si_chktime ) { struct berval bv; - bv.bv_len = sprintf( c->cr_msg, "%d %d", - si->si_chkops, si->si_chktime ); - bv.bv_val = c->cr_msg; - value_add_one( &c->rvalue_vals, &bv ); + bv.bv_len = snprintf( c->cr_msg, sizeof( c->cr_msg ), + "%d %d", si->si_chkops, si->si_chktime ); + if ( bv.bv_len < 0 || bv.bv_len >= sizeof( c->cr_msg ) ) { + rc = 1; + } else { + bv.bv_val = c->cr_msg; + value_add_one( &c->rvalue_vals, &bv ); + } } else { rc = 1; } @@ -2786,10 +2887,14 @@ static int syncprov_parseCtrl ( sr->sr_rhint = rhint; if (!BER_BVISNULL(&cookie)) { ber_dupbv_x( &sr->sr_state.octet_str, &cookie, op->o_tmpmemctx ); + /* If parse fails, pretend no cookie was sent */ if ( slap_parse_sync_cookie( &sr->sr_state, op->o_tmpmemctx ) || sr->sr_state.rid == -1 ) { - rs->sr_text = "Sync control : cookie parsing error"; - return LDAP_PROTOCOL_ERROR; + if ( sr->sr_state.ctxcsn ) { + ber_bvarray_free_x( sr->sr_state.ctxcsn, op->o_tmpmemctx ); + sr->sr_state.ctxcsn = NULL; + } + sr->sr_state.numcsns = 0; } }