/* syncprov.c - syncrepl provider */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2004-2008 The OpenLDAP Foundation.
+ * Copyright 2004-2009 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
static int
syncprov_findbase( Operation *op, fbase_cookie *fc )
{
- opcookie *opc = op->o_callback->sc_private;
- slap_overinst *on = opc->son;
-
/* Use basic parameters from syncrepl search, but use
* current op's threadctx / tmpmemctx
*/
slap_callback cb = {0};
Operation fop;
SlapReply frs = { REP_RESULT };
- BackendInfo *bi;
int rc;
fc->fss->s_flags ^= PS_FIND_BASE;
fop = *fc->fss->s_op;
+ fop.o_bd = fop.o_bd->bd_self;
fop.o_hdr = op->o_hdr;
- fop.o_bd = op->o_bd;
fop.o_time = op->o_time;
fop.o_tincr = op->o_tincr;
- bi = op->o_bd->bd_info;
cb.sc_response = findbase_cb;
cb.sc_private = fc;
fop.ors_filter = &generic_filter;
fop.ors_filterstr = generic_filterstr;
- rc = overlay_op_walk( &fop, &frs, op_search, on->on_info, on );
- op->o_bd->bd_info = bi;
+ rc = fop.o_bd->be_search( &fop, &frs );
} else {
ldap_pvt_thread_mutex_unlock( &fc->fss->s_mutex );
fc->fbase = 1;
Attribute *a = attr_find( rs->sr_entry->e_attrs,
slap_schema.si_ad_entryCSN );
- if ( a && ber_bvcmp( &a->a_vals[0], maxcsn ) > 0 ) {
+ if ( a && ber_bvcmp( &a->a_vals[0], maxcsn ) > 0 &&
+ slap_parse_csn_sid( &a->a_vals[0] ) == slap_serverID ) {
maxcsn->bv_len = a->a_vals[0].bv_len;
strcpy( maxcsn->bv_val, a->a_vals[0].bv_val );
}
sync_control *srs = NULL;
struct slap_limits_set fc_limits;
int i, rc = LDAP_SUCCESS, findcsn_retry = 1;
- int maxid = 0;
+ int maxid;
if ( mode != FIND_MAXCSN ) {
srs = op->o_controls[slap_cids.sc_LDAPsync];
switch( mode ) {
case FIND_MAXCSN:
cf.f_choice = LDAP_FILTER_GE;
- cf.f_av_value = si->si_ctxcsn[0];
- /* If there are multiple CSNs, use the largest */
- for ( i=1; i<si->si_numcsns; i++) {
- if ( ber_bvcmp( &cf.f_av_value, &si->si_ctxcsn[i] ) < 0 ) {
- cf.f_av_value = si->si_ctxcsn[i];
+ /* If there are multiple CSNs, use the one with our serverID */
+ for ( i=0; i<si->si_numcsns; i++) {
+ if ( slap_serverID == si->si_sids[i] ) {
maxid = i;
+ break;
}
}
+ if ( i == si->si_numcsns ) {
+ /* No match: this is multimaster, and none of the content in the DB
+ * originated locally. Treat like no CSN.
+ */
+ return LDAP_NO_SUCH_OBJECT;
+ }
+ cf.f_av_value = si->si_ctxcsn[maxid];
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 ) ) {
+ if ( fop.ors_filterstr.bv_len >= sizeof( buf ) ) {
return LDAP_OTHER;
}
fop.ors_attrsonly = 0;
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 ) ) {
+ if ( fop.ors_filterstr.bv_len >= sizeof( buf ) ) {
return LDAP_OTHER;
}
fop.ors_attrsonly = 1;
} else {
/* bail out on any error */
ldap_pvt_runqueue_remove( &slapd_rq, rtask );
+
+ /* Prevent duplicate remove */
+ if ( so->s_qtask == rtask )
+ so->s_qtask = NULL;
}
ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
ldap_pvt_thread_mutex_unlock( &so->s_mutex );
sprev = ss, ss=snext)
{
Operation op2;
+ Opheader oh;
syncmatches *sm;
int found = 0;
if ( fc.fscope ) {
op2 = *ss->s_op;
- op2.o_hdr = op->o_hdr;
+ oh = *op->o_hdr;
+ oh.oh_conn = ss->s_op->o_conn;
+ oh.oh_connid = ss->s_op->o_connid;
+ op2.o_hdr = &oh;
op2.o_extra = op->o_extra;
}
/* send DELETE */
syncprov_qresp( opc, ss, LDAP_SYNC_DELETE );
}
+ if ( !saveit && found ) {
+ /* Decrement s_inuse, was incremented when called
+ * with saveit == TRUE
+ */
+ syncprov_free_syncop( ss );
+ }
}
ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
mod.sml_nvalues = NULL;
mod.sml_desc = slap_schema.si_ad_contextCSN;
mod.sml_op = LDAP_MOD_REPLACE;
- mod.sml_flags = 0;
+ mod.sml_flags = SLAP_MOD_INTERNAL;
mod.sml_next = NULL;
cb.sc_response = slap_null_cb;
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 );
+ 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,
delcsn[0].bv_len ? &cookie : NULL, 0, uuids, 1 );
- op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
+ if ( delcsn[0].bv_len ) {
+ op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
+ }
}
op->o_tmpfree( uuids, op->o_tmpmemctx );
}
{
struct berval maxcsn = BER_BVNULL;
char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
- int do_check = 0, have_psearches;
+ int do_check = 0, have_psearches, foundit;
/* Update our context CSN */
cbuf[0] = '\0';
ldap_pvt_thread_rdwr_wlock( &si->si_csn_rwlock );
- slap_get_commit_csn( op, &maxcsn );
+ slap_get_commit_csn( op, &maxcsn, &foundit );
+ if ( BER_BVISNULL( &maxcsn ) && SLAP_GLUE_SUBORDINATE( op->o_bd )) {
+ /* syncrepl queues the CSN values in the db where
+ * it is configured , not where the changes are made.
+ * So look for a value in the glue db if we didn't
+ * find any in this db.
+ */
+ BackendDB *be = op->o_bd;
+ op->o_bd = select_backend( &be->be_nsuffix[0], 1);
+ slap_get_commit_csn( op, &maxcsn, &foundit );
+ op->o_bd = be;
+ }
if ( !BER_BVISNULL( &maxcsn ) ) {
int i, sid;
strcpy( cbuf, maxcsn.bv_val );
sizeof(int));
si->si_sids[i] = sid;
}
- } else {
+ } else if ( !foundit ) {
/* internal ops that aren't meant to be replicated */
ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
return SLAP_CB_CONTINUE;
}
/* Don't do any processing for consumer contextCSN updates */
- if ( SLAP_SYNC_SHADOW( op->o_bd ) &&
- op->o_msgid == SLAP_SYNC_UPDATE_MSGID ) {
+ if ( op->o_dont_replicate ) {
ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
return SLAP_CB_CONTINUE;
}
ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
}
- opc->sctxcsn.bv_len = maxcsn.bv_len;
- opc->sctxcsn.bv_val = cbuf;
+ /* only update consumer ctx if this is the greatest csn */
+ if ( bvmatch( &maxcsn, &op->o_csn )) {
+ opc->sctxcsn.bv_len = maxcsn.bv_len;
+ opc->sctxcsn.bv_val = cbuf;
+ }
/* Handle any persistent searches */
ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
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 );
+ /* syncprov_ab_cleanup will free this syncop */
return SLAPD_ABANDON;
} else {
send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" );
return rs->sr_err;
}
+ if ( srs->sr_state.ctxcsn ) {
+ ber_bvarray_free_x( srs->sr_state.ctxcsn, op->o_tmpmemctx );
+ srs->sr_state.ctxcsn = NULL;
+ }
+ if ( srs->sr_state.sids ) {
+ slap_sl_free( srs->sr_state.sids, op->o_tmpmemctx );
+ srs->sr_state.sids = NULL;
+ }
+ srs->sr_state.numcsns = 0;
} else {
gotstate = 1;
/* If changed and doing Present lookup, send Present UUIDs */
"NAME 'olcSyncProvConfig' "
"DESC 'SyncRepl Provider configuration' "
"SUP olcOverlayConfig "
- "MAY ( olcSpCheckpoint $ olcSpSessionlog $ olcSpNoPresent ) )",
+ "MAY ( olcSpCheckpoint "
+ "$ olcSpSessionlog "
+ "$ olcSpNoPresent "
+ "$ olcSpReloadHint "
+ ") )",
Cft_Overlay, spcfg },
{ NULL, 0, NULL }
};
struct berval 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 ) ) {
+ if ( bv.bv_len >= sizeof( c->cr_msg ) ) {
rc = 1;
} else {
bv.bv_val = c->cr_msg;
si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, a->a_numvals, NULL );
}
overlay_entry_release_ov( op, e, 0, on );
- if ( si->si_ctxcsn ) {
+ if ( si->si_ctxcsn && !SLAP_DBCLEAN( be )) {
op->o_req_dn = be->be_suffix[0];
op->o_req_ndn = be->be_nsuffix[0];
op->ors_scope = LDAP_SCOPE_SUBTREE;