/* syncprov.c - syncrepl provider */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2004-2011 The OpenLDAP Foundation.
+ * Copyright 2004-2012 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
} slog_entry;
typedef struct sessionlog {
- struct berval sl_mincsn;
+ BerVarray sl_mincsn;
+ int *sl_sids;
+ int sl_numcsns;
int sl_num;
int sl_size;
slog_entry *sl_head;
/* The main state for this overlay */
typedef struct syncprov_info_t {
syncops *si_ops;
- BerVarray si_ctxcsn; /* ldapsync context */
struct berval si_contextdn;
+ BerVarray si_ctxcsn; /* ldapsync context */
int *si_sids;
int si_numcsns;
int si_chkops; /* checkpointing info */
if ( ret < 0 ) {
Debug( LDAP_DEBUG_TRACE,
- "slap_build_sync_ctrl: ber_flatten2 failed\n",
- 0, 0, 0 );
+ "slap_build_sync_ctrl: ber_flatten2 failed (%d)\n",
+ ret, 0, 0 );
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
- return ret;
+ return LDAP_OTHER;
}
return LDAP_SUCCESS;
if ( ret < 0 ) {
Debug( LDAP_DEBUG_TRACE,
- "syncprov_done_ctrl: ber_flatten2 failed\n",
- 0, 0, 0 );
+ "syncprov_done_ctrl: ber_flatten2 failed (%d)\n",
+ ret, 0, 0 );
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
- return ret;
+ return LDAP_OTHER;
}
return LDAP_SUCCESS;
if ( ret < 0 ) {
Debug( LDAP_DEBUG_TRACE,
- "syncprov_sendinfo: ber_flatten2 failed\n",
- 0, 0, 0 );
+ "syncprov_sendinfo: ber_flatten2 failed (%d)\n",
+ ret, 0, 0 );
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
- return ret;
+ return LDAP_OTHER;
}
rs->sr_rspoid = LDAP_SYNC_INFO;
fop.o_sync_mode = 0; /* turn off sync mode */
fop.o_managedsait = SLAP_CONTROL_CRITICAL;
fop.o_callback = &cb;
+ LDAP_SLIST_INIT( &fop.o_extra );
fop.o_tag = LDAP_REQ_SEARCH;
fop.ors_scope = LDAP_SCOPE_BASE;
fop.ors_limit = NULL;
}
static int
-syncprov_findcsn( Operation *op, find_csn_t mode )
+syncprov_findcsn( Operation *op, find_csn_t mode, struct berval *csn )
{
slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
syncprov_info_t *si = on->on_bi.bi_private;
break;
case FIND_CSN:
if ( BER_BVISEMPTY( &cf.f_av_value )) {
- cf.f_av_value = srs->sr_state.ctxcsn[0];
- /* If there are multiple CSNs, use the smallest */
- for ( i=1; i<srs->sr_state.numcsns; i++ ) {
- if ( ber_bvcmp( &cf.f_av_value, &srs->sr_state.ctxcsn[i] )
- > 0 ) {
- cf.f_av_value = srs->sr_state.ctxcsn[i];
- }
- }
+ cf.f_av_value = *csn;
}
+ fop.o_dn = op->o_bd->be_rootdn;
+ fop.o_ndn = op->o_bd->be_rootndn;
+ fop.o_req_dn = op->o_bd->be_suffix[0];
+ fop.o_req_ndn = op->o_bd->be_nsuffix[0];
/* Look for exact match the first time */
if ( findcsn_retry ) {
cf.f_choice = LDAP_FILTER_EQUALITY;
{
SlapReply rs = { REP_SEARCH };
LDAPControl *ctrls[2];
- struct berval cookie = BER_BVNULL, csns[2];
+ struct berval cookie, csns[2];
Entry e_uuid = {0};
Attribute a_uuid = {0};
return SLAPD_ABANDON;
ctrls[1] = NULL;
- if ( !BER_BVISNULL( &opc->sctxcsn )) {
- csns[0] = opc->sctxcsn;
- BER_BVZERO( &csns[1] );
- slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, slap_serverID ? slap_serverID : -1 );
- }
+ csns[0] = opc->sctxcsn;
+ BER_BVZERO( &csns[1] );
+ slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, slap_serverID ? slap_serverID : -1 );
#ifdef LDAP_DEBUG
if ( so->s_sid > 0 ) {
Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: to=%03x, cookie=%s\n",
- so->s_sid, cookie.bv_val ? cookie.bv_val : "", 0 );
+ so->s_sid, cookie.bv_val, 0 );
} else {
Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: cookie=%s\n",
- cookie.bv_val ? cookie.bv_val : "", 0, 0 );
+ cookie.bv_val, 0, 0 );
}
#endif
a_uuid.a_nvals = &opc->suuid;
rs.sr_err = syncprov_state_ctrl( op, &rs, &e_uuid,
mode, ctrls, 0, 1, &cookie );
- if ( !BER_BVISNULL( &cookie )) {
- op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
- }
+ op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
rs.sr_ctrls = ctrls;
rs.sr_entry = &e_uuid;
op->o_hdr = &opbuf.ob_hdr;
op->o_controls = opbuf.ob_controls;
memset( op->o_controls, 0, sizeof(opbuf.ob_controls) );
+ op->o_sync = SLAP_CONTROL_IGNORED;
*op->o_hdr = *so->s_op->o_hdr;
} else {
sl->sl_head = se;
sl->sl_tail = se;
+ if ( !sl->sl_mincsn ) {
+ sl->sl_numcsns = 1;
+ sl->sl_mincsn = ch_malloc( 2*sizeof( struct berval ));
+ sl->sl_sids = ch_malloc( sizeof( int ));
+ sl->sl_sids[0] = se->se_sid;
+ ber_dupbv( sl->sl_mincsn, &se->se_csn );
+ BER_BVZERO( &sl->sl_mincsn[1] );
+ }
}
sl->sl_num++;
while ( sl->sl_num > sl->sl_size ) {
+ int i, j;
se = sl->sl_head;
sl->sl_head = se->se_next;
- AC_MEMCPY( sl->sl_mincsn.bv_val, se->se_csn.bv_val, se->se_csn.bv_len );
- sl->sl_mincsn.bv_len = se->se_csn.bv_len;
+ for ( i=0; i<sl->sl_numcsns; i++ )
+ if ( sl->sl_sids[i] >= se->se_sid )
+ break;
+ if ( i == sl->sl_numcsns || sl->sl_sids[i] != se->se_sid ) {
+ slap_insert_csn_sids( (struct sync_cookie *)sl,
+ i, se->se_sid, &se->se_csn );
+ } else {
+ ber_bvreplace( &sl->sl_mincsn[i], &se->se_csn );
+ }
ch_free( se );
sl->sl_num--;
}
#endif
sid = slap_parse_csn_sid( &maxcsn );
for ( i=0; i<si->si_numcsns; i++ ) {
+ if ( sid < si->si_sids[i] )
+ break;
if ( sid == si->si_sids[i] ) {
if ( ber_bvcmp( &maxcsn, &si->si_ctxcsn[i] ) > 0 ) {
ber_bvreplace( &si->si_ctxcsn[i], &maxcsn );
}
}
/* It's a new SID for us */
- if ( i == si->si_numcsns ) {
- value_add_one( &si->si_ctxcsn, &maxcsn );
+ if ( i == si->si_numcsns || sid != si->si_sids[i] ) {
+ slap_insert_csn_sids((struct sync_cookie *)&(si->si_ctxcsn),
+ i, sid, &maxcsn );
csn_changed = 1;
- si->si_numcsns++;
- si->si_sids = ch_realloc( si->si_sids, si->si_numcsns *
- sizeof(int));
- si->si_sids[i] = sid;
}
}
for ( i=0; i<mod->sml_numvals; i++ ) {
sid = slap_parse_csn_sid( &mod->sml_values[i] );
for ( j=0; j<si->si_numcsns; j++ ) {
+ if ( sid < si->si_sids[j] )
+ break;
if ( sid == si->si_sids[j] ) {
if ( ber_bvcmp( &mod->sml_values[i], &si->si_ctxcsn[j] ) > 0 ) {
ber_bvreplace( &si->si_ctxcsn[j], &mod->sml_values[i] );
}
}
- if ( j == si->si_numcsns ) {
- value_add_one( &si->si_ctxcsn, &mod->sml_values[i] );
- si->si_numcsns++;
- si->si_sids = ch_realloc( si->si_sids, si->si_numcsns *
- sizeof(int));
- si->si_sids[j] = sid;
+ if ( j == si->si_numcsns || sid != si->si_sids[j] ) {
+ slap_insert_csn_sids( (struct sync_cookie *)&si->si_ctxcsn,
+ j, sid, &mod->sml_values[i] );
csn_changed = 1;
}
}
opc->rsid = scook->sid;
}
+ if ( op->o_dont_replicate )
+ return SLAP_CB_CONTINUE;
+
/* If there are active persistent searches, lock this operation.
* See seqmod.c for the locking logic on its own.
*/
/* clean up if the caller is giving up */
if ( op->o_abandon ) {
modinst *m2;
- for ( m2 = mt->mt_mods; m2->mi_next != mi;
+ for ( m2 = mt->mt_mods; m2 && m2->mi_next != mi;
m2 = m2->mi_next );
- m2->mi_next = mi->mi_next;
- if ( mt->mt_tail == mi ) mt->mt_tail = m2;
+ if ( m2 ) {
+ m2->mi_next = mi->mi_next;
+ if ( mt->mt_tail == mi ) mt->mt_tail = m2;
+ }
op->o_tmpfree( cb, op->o_tmpmemctx );
ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
return SLAPD_ABANDON;
BerVarray ctxcsn;
int i, *sids, numcsns;
struct berval mincsn, maxcsn;
+ int minsid, maxsid;
int dirty = 0;
if ( !(op->o_sync_mode & SLAP_SYNC_REFRESH) ) return SLAP_CB_CONTINUE;
/* If there are SIDs we don't recognize in the cookie, drop them */
for (i=0; i<srs->sr_state.numcsns; ) {
- for (j=0; j<numcsns; j++) {
- if ( srs->sr_state.sids[i] == sids[j] ) {
+ for (j=i; j<numcsns; j++) {
+ if ( srs->sr_state.sids[i] <= sids[j] ) {
break;
}
}
/* not found */
- if ( j == numcsns ) {
- struct berval tmp = srs->sr_state.ctxcsn[i];
- j = srs->sr_state.numcsns - 1;
- srs->sr_state.ctxcsn[i] = srs->sr_state.ctxcsn[j];
- tmp.bv_len = 0;
- srs->sr_state.ctxcsn[j] = tmp;
- srs->sr_state.numcsns = j;
- srs->sr_state.sids[i] = srs->sr_state.sids[j];
+ if ( j == numcsns || srs->sr_state.sids[i] != sids[j] ) {
+ char *tmp = srs->sr_state.ctxcsn[i].bv_val;
+ srs->sr_state.numcsns--;
+ for ( j=i; j<srs->sr_state.numcsns; j++ ) {
+ srs->sr_state.ctxcsn[j] = srs->sr_state.ctxcsn[j+1];
+ srs->sr_state.sids[j] = srs->sr_state.sids[j+1];
+ }
+ srs->sr_state.ctxcsn[j].bv_val = tmp;
+ srs->sr_state.ctxcsn[j].bv_len = 0;
continue;
}
i++;
}
+ if (srs->sr_state.numcsns != numcsns) {
+ /* consumer doesn't have the right number of CSNs */
+ changed = SS_CHANGED;
+ 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;
+ goto shortcut;
+ }
+
/* Find the smallest CSN which differs from contextCSN */
mincsn.bv_len = 0;
maxcsn.bv_len = 0;
- for ( i=0; i<srs->sr_state.numcsns; i++ ) {
- for ( j=0; j<numcsns; j++ ) {
- if ( srs->sr_state.sids[i] != sids[j] )
- continue;
- if ( BER_BVISEMPTY( &maxcsn ) || ber_bvcmp( &maxcsn,
- &srs->sr_state.ctxcsn[i] ) < 0 ) {
- maxcsn = srs->sr_state.ctxcsn[i];
+ for ( i=0,j=0; i<srs->sr_state.numcsns; i++ ) {
+ int newer;
+ while ( srs->sr_state.sids[i] != sids[j] ) j++;
+ if ( BER_BVISEMPTY( &maxcsn ) || ber_bvcmp( &maxcsn,
+ &srs->sr_state.ctxcsn[i] ) < 0 ) {
+ maxcsn = srs->sr_state.ctxcsn[i];
+ maxsid = sids[j];
+ }
+ newer = ber_bvcmp( &srs->sr_state.ctxcsn[i], &ctxcsn[j] );
+ /* If our state is newer, tell consumer about changes */
+ if ( newer < 0) {
+ changed = SS_CHANGED;
+ if ( BER_BVISEMPTY( &mincsn ) || ber_bvcmp( &mincsn,
+ &srs->sr_state.ctxcsn[i] ) > 0 ) {
+ mincsn = srs->sr_state.ctxcsn[i];
+ minsid = sids[j];
}
- if ( ber_bvcmp( &srs->sr_state.ctxcsn[i], &ctxcsn[j] ) < 0) {
- if ( BER_BVISEMPTY( &mincsn ) || ber_bvcmp( &mincsn,
- &srs->sr_state.ctxcsn[i] ) > 0 ) {
- mincsn = srs->sr_state.ctxcsn[i];
- }
+ } else if ( newer > 0 && sids[j] == slap_serverID ) {
+ /* our state is older, complain to consumer */
+ rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
+ rs->sr_text = "consumer state is newer than provider!";
+bailout:
+ if ( sop ) {
+ syncops **sp = &si->si_ops;
+
+ ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
+ while ( *sp != sop )
+ sp = &(*sp)->s_next;
+ *sp = sop->s_next;
+ ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
+ ch_free( sop );
}
+ rs->sr_ctrls = NULL;
+ send_ldap_result( op, rs );
+ return rs->sr_err;
}
}
- if ( BER_BVISEMPTY( &mincsn ))
+ if ( BER_BVISEMPTY( &mincsn )) {
mincsn = maxcsn;
+ minsid = maxsid;
+ }
/* If nothing has changed, shortcut it */
- if ( srs->sr_state.numcsns == numcsns ) {
- int i, j, newer;
- for ( i=0; i<srs->sr_state.numcsns; i++ ) {
- for ( j=0; j<numcsns; j++ ) {
- if ( srs->sr_state.sids[i] != sids[j] )
- continue;
- newer = ber_bvcmp( &srs->sr_state.ctxcsn[i], &ctxcsn[j] );
- /* If our state is newer, tell consumer about changes */
- if ( newer < 0 )
- changed = SS_CHANGED;
- else if ( newer > 0 ) {
- /* our state is older, complain to consumer */
- rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
- rs->sr_text = "consumer state is newer than provider!";
-bailout:
- if ( sop ) {
- syncops **sp = &si->si_ops;
-
- ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
- while ( *sp != sop )
- sp = &(*sp)->s_next;
- *sp = sop->s_next;
- ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
- ch_free( sop );
- }
- rs->sr_ctrls = NULL;
- send_ldap_result( op, rs );
- return rs->sr_err;
- }
- break;
- }
- if ( changed )
- break;
- }
- if ( !changed && !dirty ) {
- do_present = 0;
+ if ( !changed && !dirty ) {
+ do_present = 0;
no_change: if ( !(op->o_sync_mode & SLAP_SYNC_PERSIST) ) {
- LDAPControl *ctrls[2];
-
- ctrls[0] = NULL;
- ctrls[1] = NULL;
- syncprov_done_ctrl( op, rs, ctrls, 0, 0,
- NULL, LDAP_SYNC_REFRESH_DELETES );
- rs->sr_ctrls = ctrls;
- rs->sr_err = LDAP_SUCCESS;
- send_ldap_result( op, rs );
- rs->sr_ctrls = NULL;
- return rs->sr_err;
- }
- goto shortcut;
+ LDAPControl *ctrls[2];
+
+ ctrls[0] = NULL;
+ ctrls[1] = NULL;
+ syncprov_done_ctrl( op, rs, ctrls, 0, 0,
+ NULL, LDAP_SYNC_REFRESH_DELETES );
+ rs->sr_ctrls = ctrls;
+ rs->sr_err = LDAP_SUCCESS;
+ send_ldap_result( op, rs );
+ rs->sr_ctrls = NULL;
+ return rs->sr_err;
}
- } else {
- /* consumer doesn't have the right number of CSNs */
- changed = SS_CHANGED;
+ goto shortcut;
}
+
/* Do we have a sessionlog for this search? */
sl=si->si_logs;
if ( sl ) {
+ int do_play = 0;
ldap_pvt_thread_mutex_lock( &sl->sl_mutex );
/* Are there any log entries, and is the consumer state
* present in the session log?
*/
- if ( sl->sl_num > 0 && ber_bvcmp( &mincsn, &sl->sl_mincsn ) >= 0 ) {
+ if ( sl->sl_num > 0 ) {
+ int i;
+ for ( i=0; i<sl->sl_numcsns; i++ ) {
+ /* SID not present == new enough */
+ if ( minsid < sl->sl_sids[i] ) {
+ do_play = 1;
+ break;
+ }
+ /* SID present and new enough */
+ if ( minsid == sl->sl_sids[i]
+ && ber_bvcmp( &mincsn, &sl->sl_mincsn[i] ) >= 0 ) {
+ do_play = 1;
+ break;
+ }
+ }
+ /* SID not present == new enough */
+ if ( i == sl->sl_numcsns )
+ do_play = 1;
+ }
+ if ( do_play ) {
do_present = 0;
/* mutex is unlocked in playlog */
syncprov_playlog( op, rs, sl, srs, ctxcsn, numcsns, sids );
}
}
/* Is the CSN still present in the database? */
- if ( syncprov_findcsn( op, FIND_CSN ) != LDAP_SUCCESS ) {
+ if ( syncprov_findcsn( op, FIND_CSN, &mincsn ) != LDAP_SUCCESS ) {
/* No, so a reload is required */
/* the 2.2 consumer doesn't send this hint */
if ( si->si_usehint && srs->sr_rhint == 0 ) {
} else {
gotstate = 1;
/* If changed and doing Present lookup, send Present UUIDs */
- if ( do_present && syncprov_findcsn( op, FIND_PRESENT ) !=
+ if ( do_present && syncprov_findcsn( op, FIND_PRESENT, 0 ) !=
LDAP_SUCCESS ) {
if ( ctxcsn )
ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );
}
if ( !ap ) {
- if ( rs_ensure_entry_modifiable( op, rs, on )) {
+ if ( rs_entry2modifiable( op, rs, on )) {
a = attr_find( rs->sr_entry->e_attrs,
slap_schema.si_ad_contextCSN );
}
}
sl = si->si_logs;
if ( !sl ) {
- sl = ch_malloc( sizeof( sessionlog ) + LDAP_PVT_CSNSTR_BUFSIZE );
- sl->sl_mincsn.bv_val = (char *)(sl+1);
- sl->sl_mincsn.bv_len = 0;
+ sl = ch_malloc( sizeof( sessionlog ));
+ sl->sl_mincsn = NULL;
+ sl->sl_sids = NULL;
sl->sl_num = 0;
+ sl->sl_numcsns = 0;
sl->sl_head = sl->sl_tail = NULL;
ldap_pvt_thread_mutex_init( &sl->sl_mutex );
si->si_logs = sl;
void *ptr
)
{
- syncprov_findcsn( ptr, FIND_MAXCSN );
+ syncprov_findcsn( ptr, FIND_MAXCSN, 0 );
return NULL;
}
+
/* Read any existing contextCSN from the underlying db.
* Then search for any entries newer than that. If no value exists,
* just generate it. Cache whatever result.
ber_bvarray_dup_x( &si->si_ctxcsn, a->a_vals, NULL );
si->si_numcsns = a->a_numvals;
si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, a->a_numvals, NULL );
+ slap_sort_csn_sids( si->si_ctxcsn, si->si_sids, si->si_numcsns, NULL );
}
overlay_entry_release_ov( op, e, 0, on );
if ( si->si_ctxcsn && !SLAP_DBCLEAN( be )) {
if ( si->si_logs && si->si_numcsns ) {
sessionlog *sl = si->si_logs;
int i;
- /* If there are multiple, find the newest */
- for ( i=0; i < si->si_numcsns; i++ ) {
- if ( ber_bvcmp( &sl->sl_mincsn, &si->si_ctxcsn[i] ) < 0 ) {
- AC_MEMCPY( sl->sl_mincsn.bv_val, si->si_ctxcsn[i].bv_val,
- si->si_ctxcsn[i].bv_len );
- sl->sl_mincsn.bv_len = si->si_ctxcsn[i].bv_len;
- }
- }
+ ber_bvarray_dup_x( &sl->sl_mincsn, si->si_ctxcsn, NULL );
+ sl->sl_numcsns = si->si_numcsns;
+ sl->sl_sids = ch_malloc( si->si_numcsns * sizeof(int) );
+ for ( i=0; i < si->si_numcsns; i++ )
+ sl->sl_sids[i] = si->si_sids[i];
}
out:
}
#ifdef SLAP_CONFIG_DELETE
- ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
- for ( so=si->si_ops, sonext=so; so; so=sonext ) {
- SlapReply rs = {REP_RESULT};
- rs.sr_err = LDAP_UNAVAILABLE;
- send_ldap_result( so->s_op, &rs );
- sonext=so->s_next;
- syncprov_drop_psearch( so, 0);
- }
- si->si_ops=NULL;
- ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
+ if ( !slapd_shutdown ) {
+ for ( so=si->si_ops, sonext=so; so; so=sonext ) {
+ SlapReply rs = {REP_RESULT};
+ rs.sr_err = LDAP_UNAVAILABLE;
+ send_ldap_result( so->s_op, &rs );
+ sonext=so->s_next;
+ syncprov_drop_psearch( so, 0);
+ }
+ si->si_ops=NULL;
+ }
overlay_unregister_control( be, LDAP_CONTROL_SYNC );
#endif /* SLAP_CONFIG_DELETE */
if ( si ) {
if ( si->si_logs ) {
- slog_entry *se = si->si_logs->sl_head;
+ sessionlog *sl = si->si_logs;
+ slog_entry *se = sl->sl_head;
while ( se ) {
slog_entry *se_next = se->se_next;
ch_free( se );
se = se_next;
}
-
+ if ( sl->sl_mincsn )
+ ber_bvarray_free( sl->sl_mincsn );
+ if ( sl->sl_sids )
+ ch_free( sl->sl_sids );
+
ldap_pvt_thread_mutex_destroy(&si->si_logs->sl_mutex);
ch_free( si->si_logs );
}
projects / openldap / blobdiff