servers/slapd/overlays/syncprov.c - diff

Return to syncprov.c CVS log

Up to [OpenLDAP] / servers / slapd / overlays

Diff for /servers/slapd/overlays/syncprov.c between versions 1.37 and 1.88

version 1.37, 2004/12/05 19:52:49	version 1.88, 2005/07/10 08:20:21
Line 1	Line 1
	/* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.87 2005/06/30 02:06:40 hyc Exp $ */
/* syncprov.c - syncrepl provider */	/* syncprov.c - syncrepl provider */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.	/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*	*
* Copyright 2004 The OpenLDAP Foundation.	* Copyright 2004-2005 The OpenLDAP Foundation.
* All rights reserved.	* All rights reserved.
*	*
* Redistribution and use in source and binary forms, with or without	* Redistribution and use in source and binary forms, with or without
Line 24	Line 25
#include <ac/string.h>	#include <ac/string.h>
#include "lutil.h"	#include "lutil.h"
#include "slap.h"	#include "slap.h"
	#include "config.h"

/* A modify request on a particular entry */	/* A modify request on a particular entry */
typedef struct modinst {	typedef struct modinst {
Line 55 typedef struct syncops {	Line 57 typedef struct syncops {
struct berval s_base; /* ndn of search base */	struct berval s_base; /* ndn of search base */
ID s_eid; /* entryID of search base */	ID s_eid; /* entryID of search base */
Operation s_op; / search op */	Operation s_op; / search op */
long s_sid;	int s_rid;
long s_rid;
struct berval s_filterstr;	struct berval s_filterstr;
int s_flags; /* search status */	int s_flags; /* search status */
int s_inuse; /* reference count */	int s_inuse; /* reference count */
Line 83 typedef struct sync_control {	Line 84 typedef struct sync_control {
#define SLAP_SYNC_REFRESH_AND_PERSIST (LDAP_SYNC_REFRESH_AND_PERSIST<<SLAP_CONTROL_SHIFT)	#define SLAP_SYNC_REFRESH_AND_PERSIST (LDAP_SYNC_REFRESH_AND_PERSIST<<SLAP_CONTROL_SHIFT)

#define PS_IS_REFRESHING 0x01	#define PS_IS_REFRESHING 0x01
	#define PS_IS_DETACHED 0x02

/* Record of which searches matched at premodify step */	/* Record of which searches matched at premodify step */
typedef struct syncmatches {	typedef struct syncmatches {
Line 90 typedef struct syncmatches {	Line 92 typedef struct syncmatches {
syncops *sm_op;	syncops *sm_op;
} syncmatches;	} syncmatches;

	/* Session log data */
	typedef struct slog_entry {
	struct slog_entry *se_next;
	struct berval se_uuid;
	struct berval se_csn;
	ber_tag_t se_tag;
	} slog_entry;

	typedef struct sessionlog {
	struct berval sl_mincsn;
	int sl_num;
	int sl_size;
	slog_entry *sl_head;
	slog_entry *sl_tail;
	ldap_pvt_thread_mutex_t sl_mutex;
	} sessionlog;

/* The main state for this overlay */	/* The main state for this overlay */
typedef struct syncprov_info_t {	typedef struct syncprov_info_t {
syncops *si_ops;	syncops *si_ops;
Line 99 typedef struct syncprov_info_t {	Line 118 typedef struct syncprov_info_t {
int si_numops; /* number of ops since last checkpoint */	int si_numops; /* number of ops since last checkpoint */
time_t si_chklast; /* time of last checkpoint */	time_t si_chklast; /* time of last checkpoint */
Avlnode si_mods; / entries being modified */	Avlnode si_mods; / entries being modified */
	sessionlog *si_logs;
ldap_pvt_thread_mutex_t si_csn_mutex;	ldap_pvt_thread_mutex_t si_csn_mutex;
ldap_pvt_thread_mutex_t si_ops_mutex;	ldap_pvt_thread_mutex_t si_ops_mutex;
ldap_pvt_thread_rdwr_t si_mods_rwlock;	ldap_pvt_thread_mutex_t si_mods_mutex;
char si_ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];	char si_ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
} syncprov_info_t;	} syncprov_info_t;

Line 231 syncprov_done_ctrl(	Line 251 syncprov_done_ctrl(
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

#if 0
/* Generate state based on session log - not implemented yet */
static int
syncprov_state_ctrl_from_slog(
Operation *op,
SlapReply *rs,
struct slog_entry *slog_e,
int entry_sync_state,
LDAPControl **ctrls,
int num_ctrls,
int send_cookie,
struct berval *cookie)
{
Attribute* a;
int ret;
int res;
const char *text = NULL;

BerElementBuffer berbuf;
BerElement ber = (BerElement )&berbuf;

struct berval entryuuid_bv = BER_BVNULL;

ber_init2( ber, NULL, LBER_USE_DER );
ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );

ctrls[num_ctrls] = ch_malloc ( sizeof ( LDAPControl ) );

entryuuid_bv = slog_e->sl_uuid;

if ( send_cookie && cookie ) {
ber_printf( ber, "{eOON}",
entry_sync_state, &entryuuid_bv, cookie );
} else {
ber_printf( ber, "{eON}",
entry_sync_state, &entryuuid_bv );
}

ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_STATE;
ctrls[num_ctrls]->ldctl_iscritical = (op->o_sync == SLAP_CONTROL_CRITICAL);
ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 );

ber_free_buf( ber );

if ( ret < 0 ) {
Debug( LDAP_DEBUG_TRACE,
"slap_build_sync_ctrl: ber_flatten2 failed\n",
0, 0, 0 );
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
return ret;
}

return LDAP_SUCCESS;
}
#endif

static int	static int
syncprov_sendinfo(	syncprov_sendinfo(
Operation *op,	Operation *op,
Line 451 syncprov_findbase( Operation *op, fbase_	Line 415 syncprov_findbase( Operation *op, fbase_
cb.sc_private = fc;	cb.sc_private = fc;

fop.o_sync_mode &= SLAP_CONTROL_MASK; /* turn off sync mode */	fop.o_sync_mode &= SLAP_CONTROL_MASK; /* turn off sync mode */
	fop.o_managedsait = SLAP_CONTROL_CRITICAL;
fop.o_callback = &cb;	fop.o_callback = &cb;
fop.o_tag = LDAP_REQ_SEARCH;	fop.o_tag = LDAP_REQ_SEARCH;
fop.ors_scope = LDAP_SCOPE_BASE;	fop.ors_scope = LDAP_SCOPE_BASE;
Line 504 findmax_cb( Operation op, SlapReply rs	Line 469 findmax_cb( Operation op, SlapReply rs
Attribute *a = attr_find( rs->sr_entry->e_attrs,	Attribute *a = attr_find( rs->sr_entry->e_attrs,
slap_schema.si_ad_entryCSN );	slap_schema.si_ad_entryCSN );

if ( a && ber_bvcmp( &a->a_vals[0], maxcsn )) {	if ( a && ber_bvcmp( &a->a_vals[0], maxcsn ) > 0 ) {
maxcsn->bv_len = a->a_vals[0].bv_len;	maxcsn->bv_len = a->a_vals[0].bv_len;
strcpy( maxcsn->bv_val, a->a_vals[0].bv_val );	strcpy( maxcsn->bv_val, a->a_vals[0].bv_val );
}	}
Line 525 findcsn_cb( Operation op, SlapReply rs	Line 490 findcsn_cb( Operation op, SlapReply rs

/* Build a list of entryUUIDs for sending in a SyncID set */	/* Build a list of entryUUIDs for sending in a SyncID set */

	#define UUID_LEN 16

typedef struct fpres_cookie {	typedef struct fpres_cookie {
int num;	int num;
BerVarray uuids;	BerVarray uuids;
	char *last;
} fpres_cookie;	} fpres_cookie;

static int	static int
Line 535 findpres_cb( Operation op, SlapReply r	Line 503 findpres_cb( Operation op, SlapReply r
{	{
slap_callback *sc = op->o_callback;	slap_callback *sc = op->o_callback;
fpres_cookie *pc = sc->sc_private;	fpres_cookie *pc = sc->sc_private;
	Attribute *a;
int ret = SLAP_CB_CONTINUE;	int ret = SLAP_CB_CONTINUE;

if ( rs->sr_type == REP_SEARCH ) {	switch ( rs->sr_type ) {
ret = slap_build_syncUUID_set( op, &pc->uuids, rs->sr_entry );	case REP_SEARCH:
if ( ret > 0 ) {	a = attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_entryUUID );
	if ( a ) {
	pc->uuids[pc->num].bv_val = pc->last;
	AC_MEMCPY( pc->uuids[pc->num].bv_val, a->a_nvals[0].bv_val,
	pc->uuids[pc->num].bv_len );
pc->num++;	pc->num++;
ret = LDAP_SUCCESS;	pc->last = pc->uuids[pc->num].bv_val;
if ( pc->num == SLAP_SYNCUUID_SET_SIZE ) {	pc->uuids[pc->num].bv_val = NULL;
ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,
0, pc->uuids, 0 );
ber_bvarray_free_x( pc->uuids, op->o_tmpmemctx );
pc->uuids = NULL;
pc->num = 0;
}
} else {
ret = LDAP_OTHER;
}	}
} else if ( rs->sr_type == REP_RESULT ) {	ret = LDAP_SUCCESS;
	if ( pc->num != SLAP_SYNCUUID_SET_SIZE )
	break;
	/* FALLTHRU */
	case REP_RESULT:
ret = rs->sr_err;	ret = rs->sr_err;
if ( pc->num ) {	if ( pc->num ) {
ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,	ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,
0, pc->uuids, 0 );	0, pc->uuids, 0 );
ber_bvarray_free_x( pc->uuids, op->o_tmpmemctx );	pc->uuids[pc->num].bv_val = pc->last;
pc->uuids = NULL;
pc->num = 0;	pc->num = 0;
	pc->last = pc->uuids[0].bv_val;
}	}
	break;
	default:
	break;
}	}
return ret;	return ret;
}	}


static int	static int
syncprov_findcsn( Operation *op, int mode )	syncprov_findcsn( Operation *op, int mode )
{	{
Line 577 syncprov_findcsn( Operation *op, int mod	Line 548 syncprov_findcsn( Operation *op, int mod
SlapReply frs = { REP_RESULT };	SlapReply frs = { REP_RESULT };
char buf[LDAP_LUTIL_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")];	char buf[LDAP_LUTIL_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")];
char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];	char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
struct berval fbuf, maxcsn;	struct berval maxcsn;
Filter cf;	Filter cf, af;
AttributeAssertion eq;	#ifdef LDAP_COMP_MATCH
int rc = LDAP_SUCCESS;	AttributeAssertion eq = { NULL, BER_BVNULL, NULL };
	#else
	AttributeAssertion eq = { NULL, BER_BVNULL };
	#endif
	int i, rc = LDAP_SUCCESS;
fpres_cookie pcookie;	fpres_cookie pcookie;
int locked = 0;	sync_control *srs = NULL;
sync_control *srs;

if ( mode != FIND_MAXCSN ) {	if ( mode != FIND_MAXCSN ) {
srs = op->o_controls[slap_cids.sc_LDAPsync];	srs = op->o_controls[slap_cids.sc_LDAPsync];

if ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {	if ( srs->sr_state.ctxcsn.bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {
return LDAP_OTHER;	return LDAP_OTHER;
}	}
}	}

fop = *op;	fop = *op;
fop.o_sync_mode &= SLAP_CONTROL_MASK; /* turn off sync_mode */	fop.o_sync_mode &= SLAP_CONTROL_MASK; /* turn off sync_mode */
	/* We want pure entries, not referrals */
	fop.o_managedsait = SLAP_CONTROL_CRITICAL;

fbuf.bv_val = buf;
cf.f_ava = &eq;	cf.f_ava = &eq;
cf.f_av_desc = slap_schema.si_ad_entryCSN;	cf.f_av_desc = slap_schema.si_ad_entryCSN;
cf.f_next = NULL;	cf.f_next = NULL;

	fop.o_callback = &cb;
	fop.ors_limit = NULL;
	fop.ors_tlimit = SLAP_NO_LIMIT;
	fop.ors_filter = &cf;
	fop.ors_filterstr.bv_val = buf;

switch( mode ) {	switch( mode ) {
case FIND_MAXCSN:	case FIND_MAXCSN:
cf.f_choice = LDAP_FILTER_GE;	cf.f_choice = LDAP_FILTER_GE;
cf.f_av_value = si->si_ctxcsn;	cf.f_av_value = si->si_ctxcsn;
fbuf.bv_len = sprintf( buf, "(entryCSN>=%s)",	fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN>=%s)",
cf.f_av_value.bv_val );	cf.f_av_value.bv_val );
fop.ors_attrsonly = 0;	fop.ors_attrsonly = 0;
fop.ors_attrs = csn_anlist;	fop.ors_attrs = csn_anlist;
fop.ors_slimit = SLAP_NO_LIMIT;	fop.ors_slimit = SLAP_NO_LIMIT;
cb.sc_private = &maxcsn;	cb.sc_private = &maxcsn;
cb.sc_response = findmax_cb;	cb.sc_response = findmax_cb;
	strcpy( cbuf, si->si_ctxcsn.bv_val );
maxcsn.bv_val = cbuf;	maxcsn.bv_val = cbuf;
maxcsn.bv_len = 0;	maxcsn.bv_len = si->si_ctxcsn.bv_len;
break;	break;
case FIND_CSN:	case FIND_CSN:
cf.f_choice = LDAP_FILTER_LE;	cf.f_choice = LDAP_FILTER_LE;
cf.f_av_value = *srs->sr_state.ctxcsn;	cf.f_av_value = srs->sr_state.ctxcsn;
fbuf.bv_len = sprintf( buf, "(entryCSN<=%s)",	fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",
cf.f_av_value.bv_val );	cf.f_av_value.bv_val );
fop.ors_attrsonly = 1;	fop.ors_attrsonly = 1;
fop.ors_attrs = slap_anlist_no_attrs;	fop.ors_attrs = slap_anlist_no_attrs;
Line 627 syncprov_findcsn( Operation *op, int mod	Line 609 syncprov_findcsn( Operation *op, int mod
cb.sc_response = findcsn_cb;	cb.sc_response = findcsn_cb;
break;	break;
case FIND_PRESENT:	case FIND_PRESENT:
	af.f_choice = LDAP_FILTER_AND;
	af.f_next = NULL;
	af.f_and = &cf;
cf.f_choice = LDAP_FILTER_LE;	cf.f_choice = LDAP_FILTER_LE;
cf.f_av_value = *srs->sr_state.ctxcsn;	cf.f_av_value = srs->sr_state.ctxcsn;
fbuf.bv_len = sprintf( buf, "(entryCSN<=%s)",	cf.f_next = op->ors_filter;
cf.f_av_value.bv_val );	fop.ors_filter = ⁡
	filter2bv_x( &fop, fop.ors_filter, &fop.ors_filterstr );
fop.ors_attrsonly = 0;	fop.ors_attrsonly = 0;
fop.ors_attrs = uuid_anlist;	fop.ors_attrs = uuid_anlist;
fop.ors_slimit = SLAP_NO_LIMIT;	fop.ors_slimit = SLAP_NO_LIMIT;
/* We want pure entries, not referrals */
fop.o_managedsait = SLAP_CONTROL_CRITICAL;
cb.sc_private = &pcookie;	cb.sc_private = &pcookie;
cb.sc_response = findpres_cb;	cb.sc_response = findpres_cb;
pcookie.num = 0;	pcookie.num = 0;
pcookie.uuids = NULL;
	/* preallocate storage for a full set */
	pcookie.uuids = op->o_tmpalloc( (SLAP_SYNCUUID_SET_SIZE+1) *
	sizeof(struct berval) + SLAP_SYNCUUID_SET_SIZE * UUID_LEN,
	op->o_tmpmemctx );
	pcookie.last = (char *)(pcookie.uuids + SLAP_SYNCUUID_SET_SIZE+1);
	pcookie.uuids[0].bv_val = pcookie.last;
	pcookie.uuids[0].bv_len = UUID_LEN;
	for (i=1; i<SLAP_SYNCUUID_SET_SIZE; i++) {
	pcookie.uuids[i].bv_val = pcookie.uuids[i-1].bv_val + UUID_LEN;
	pcookie.uuids[i].bv_len = UUID_LEN;
	}
break;	break;
}	}
fop.o_callback = &cb;
fop.ors_limit = NULL;
fop.ors_tlimit = SLAP_NO_LIMIT;
fop.ors_filter = &cf;
fop.ors_filterstr = fbuf;

fop.o_bd->bd_info = on->on_info->oi_orig;	fop.o_bd->bd_info = on->on_info->oi_orig;
fop.o_bd->be_search( &fop, &frs );	fop.o_bd->be_search( &fop, &frs );
Line 654 syncprov_findcsn( Operation *op, int mod	Line 644 syncprov_findcsn( Operation *op, int mod

switch( mode ) {	switch( mode ) {
case FIND_MAXCSN:	case FIND_MAXCSN:
if ( maxcsn.bv_len ) {	strcpy( si->si_ctxcsnbuf, maxcsn.bv_val );
strcpy( si->si_ctxcsnbuf, maxcsn.bv_val );	si->si_ctxcsn.bv_len = maxcsn.bv_len;
si->si_ctxcsn.bv_len = maxcsn.bv_len;
}
break;	break;
case FIND_CSN:	case FIND_CSN:
/* If matching CSN was not found, invalidate the context. */	/* If matching CSN was not found, invalidate the context. */
if ( !cb.sc_private ) rc = LDAP_NO_SUCH_OBJECT;	if ( !cb.sc_private ) rc = LDAP_NO_SUCH_OBJECT;
break;	break;
case FIND_PRESENT:	case FIND_PRESENT:
	op->o_tmpfree( pcookie.uuids, op->o_tmpmemctx );
	op->o_tmpfree( fop.ors_filterstr.bv_val, op->o_tmpmemctx );
break;	break;
}	}

return rc;	return rc;
}	}

/* Queue a persistent search response if still in Refresh stage */	/* Queue a persistent search response */
static int	static int
syncprov_qresp( opcookie opc, syncops so, int mode )	syncprov_qresp( opcookie opc, syncops so, int mode )
{	{
Line 680 syncprov_qresp( opcookie opc, syncops	Line 670 syncprov_qresp( opcookie opc, syncops
opc->sdn.bv_len + 1 + opc->sndn.bv_len + 1 + opc->sctxcsn.bv_len + 1 );	opc->sdn.bv_len + 1 + opc->sndn.bv_len + 1 + opc->sctxcsn.bv_len + 1 );
sr->s_next = NULL;	sr->s_next = NULL;
sr->s_dn.bv_val = (char *)(sr + 1);	sr->s_dn.bv_val = (char *)(sr + 1);
	sr->s_dn.bv_len = opc->sdn.bv_len;
sr->s_mode = mode;	sr->s_mode = mode;
sr->s_isreference = opc->sreference;	sr->s_isreference = opc->sreference;
sr->s_ndn.bv_val = lutil_strcopy( sr->s_dn.bv_val, opc->sdn.bv_val );	sr->s_ndn.bv_val = lutil_strcopy( sr->s_dn.bv_val, opc->sdn.bv_val );
	sr->s_ndn.bv_len = opc->sndn.bv_len;
*(sr->s_ndn.bv_val++) = '\0';	*(sr->s_ndn.bv_val++) = '\0';
sr->s_uuid.bv_val = lutil_strcopy( sr->s_ndn.bv_val, opc->sndn.bv_val );	sr->s_uuid.bv_val = lutil_strcopy( sr->s_ndn.bv_val, opc->sndn.bv_val );
	sr->s_uuid.bv_len = opc->suuid.bv_len;
*(sr->s_uuid.bv_val++) = '\0';	*(sr->s_uuid.bv_val++) = '\0';
sr->s_csn.bv_val = lutil_strcopy( sr->s_uuid.bv_val, opc->suuid.bv_val );	sr->s_csn.bv_val = lutil_strcopy( sr->s_uuid.bv_val, opc->suuid.bv_val );
	sr->s_csn.bv_len = opc->sctxcsn.bv_len;
	strcpy( sr->s_csn.bv_val, opc->sctxcsn.bv_val );

if ( !so->s_res ) {	if ( !so->s_res ) {
so->s_res = sr;	so->s_res = sr;
Line 698 syncprov_qresp( opcookie opc, syncops	Line 693 syncprov_qresp( opcookie opc, syncops
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

	/* Play back queued responses */
	static int
	syncprov_sendresp( Operation op, opcookie opc, syncops so, Entry *e, int mode, int queue );

	static int
	syncprov_qplay( Operation op, slap_overinst on, syncops *so )
	{
	syncres sr, srnext;
	Entry *e;
	opcookie opc;
	int rc;

	opc.son = on;
	op->o_bd->bd_info = (BackendInfo *)on->on_info;
	for (sr = so->s_res; sr; sr=srnext) {
	srnext = sr->s_next;
	opc.sdn = sr->s_dn;
	opc.sndn = sr->s_ndn;
	opc.suuid = sr->s_uuid;
	opc.sctxcsn = sr->s_csn;
	opc.sreference = sr->s_isreference;
	e = NULL;

	if ( sr->s_mode != LDAP_SYNC_DELETE ) {
	rc = be_entry_get_rw( op, &opc.sndn, NULL, NULL, 0, &e );
	if ( rc ) {
	ch_free( sr );
	so->s_res = srnext;
	continue;
	}
	}
	rc = syncprov_sendresp( op, &opc, so, &e, sr->s_mode, 0 );

	if ( e ) {
	be_entry_release_rw( op, e, 0 );
	}
	if ( rc )
	break;

	ch_free( sr );
	so->s_res = srnext;
	}
	op->o_bd->bd_info = (BackendInfo *)on;
	if ( !so->s_res )
	so->s_restail = NULL;
	return rc;
	}

/* Send a persistent search response */	/* Send a persistent search response */
static int	static int
syncprov_sendresp( Operation op, opcookie opc, syncops so, Entry e, int mode, int queue )	syncprov_sendresp( Operation op, opcookie opc, syncops so, Entry *e, int mode, int queue )
{	{
slap_overinst *on = opc->son;	slap_overinst *on = opc->son;
syncprov_info_t *si = on->on_bi.bi_private;	syncprov_info_t *si = on->on_bi.bi_private;
Line 713 syncprov_sendresp( Operation *op, opcook	Line 756 syncprov_sendresp( Operation *op, opcook
Operation sop = *so->s_op;	Operation sop = *so->s_op;
Opheader ohdr;	Opheader ohdr;

	if ( so->s_op->o_abandon )
	return SLAPD_ABANDON;

ohdr = *sop.o_hdr;	ohdr = *sop.o_hdr;
sop.o_hdr = &ohdr;	sop.o_hdr = &ohdr;
sop.o_tmpmemctx = op->o_tmpmemctx;	sop.o_tmpmemctx = op->o_tmpmemctx;
sop.o_bd = op->o_bd;	sop.o_bd = op->o_bd;
sop.o_controls = op->o_controls;	sop.o_controls = op->o_controls;
	sop.o_private = op->o_private;

if ( queue && (so->s_flags & PS_IS_REFRESHING) ) {	/* If queueing is allowed */
	if ( queue ) {
ldap_pvt_thread_mutex_lock( &so->s_mutex );	ldap_pvt_thread_mutex_lock( &so->s_mutex );
if ( so->s_flags & PS_IS_REFRESHING )	/* If we're still in refresh mode, must queue */
	if (so->s_flags & PS_IS_REFRESHING) {
	return syncprov_qresp( opc, so, mode );
	}
	/* If connection is free but queue is non-empty,
	* try to flush the queue.
	*/
	if ( so->s_res ) {
	rs.sr_err = syncprov_qplay( &sop, on, so );
	}
	/* If the connection is busy, must queue */
	if ( sop.o_conn->c_writewaiter \|\| rs.sr_err == LDAP_BUSY ) {
return syncprov_qresp( opc, so, mode );	return syncprov_qresp( opc, so, mode );
	}
ldap_pvt_thread_mutex_unlock( &so->s_mutex );	ldap_pvt_thread_mutex_unlock( &so->s_mutex );

	/* If syncprov_qplay returned any other error, bail out. */
	if ( rs.sr_err ) {
	return rs.sr_err;
	}
	} else {
	/* Queueing not allowed and conn is busy, give up */
	if ( sop.o_conn->c_writewaiter )
	return LDAP_BUSY;
}	}

ctrls[1] = NULL;	ctrls[1] = NULL;
slap_compose_sync_cookie( op, &cookie, &opc->sctxcsn,	slap_compose_sync_cookie( op, &cookie, &opc->sctxcsn, so->s_rid );
so->s_sid, so->s_rid );

e_uuid.e_attrs = &a_uuid;	e_uuid.e_attrs = &a_uuid;
a_uuid.a_desc = slap_schema.si_ad_entryUUID;	a_uuid.a_desc = slap_schema.si_ad_entryUUID;
Line 736 syncprov_sendresp( Operation *op, opcook	Line 804 syncprov_sendresp( Operation *op, opcook
rs.sr_err = syncprov_state_ctrl( &sop, &rs, &e_uuid,	rs.sr_err = syncprov_state_ctrl( &sop, &rs, &e_uuid,
mode, ctrls, 0, 1, &cookie );	mode, ctrls, 0, 1, &cookie );

rs.sr_entry = e;
rs.sr_ctrls = ctrls;	rs.sr_ctrls = ctrls;
	op->o_bd->bd_info = (BackendInfo *)on->on_info;
switch( mode ) {	switch( mode ) {
case LDAP_SYNC_ADD:	case LDAP_SYNC_ADD:
	rs.sr_entry = *e;
	if ( rs.sr_entry->e_private )
	rs.sr_flags = REP_ENTRY_MUSTRELEASE;
if ( opc->sreference ) {	if ( opc->sreference ) {
rs.sr_ref = get_entry_referrals( &sop, e );	rs.sr_ref = get_entry_referrals( &sop, rs.sr_entry );
send_search_reference( &sop, &rs );	send_search_reference( &sop, &rs );
ber_bvarray_free( rs.sr_ref );	ber_bvarray_free( rs.sr_ref );
	if ( !rs.sr_entry )
	*e = NULL;
break;	break;
}	}
/* fallthru */	/* fallthru */
case LDAP_SYNC_MODIFY:	case LDAP_SYNC_MODIFY:
	rs.sr_entry = *e;
	if ( rs.sr_entry->e_private )
	rs.sr_flags = REP_ENTRY_MUSTRELEASE;
rs.sr_attrs = sop.ors_attrs;	rs.sr_attrs = sop.ors_attrs;
send_search_entry( &sop, &rs );	send_search_entry( &sop, &rs );
	if ( !rs.sr_entry )
	*e = NULL;
break;	break;
case LDAP_SYNC_DELETE:	case LDAP_SYNC_DELETE:
e_uuid.e_attrs = NULL;	e_uuid.e_attrs = NULL;
Line 768 syncprov_sendresp( Operation *op, opcook	Line 846 syncprov_sendresp( Operation *op, opcook
assert(0);	assert(0);
}	}
op->o_tmpfree( rs.sr_ctrls[0], op->o_tmpmemctx );	op->o_tmpfree( rs.sr_ctrls[0], op->o_tmpmemctx );
	op->o_private = sop.o_private;
rs.sr_ctrls = NULL;	rs.sr_ctrls = NULL;
	/* Check queue again here; if we were hanging in a send and eventually
	* recovered, there may be more to send now. But don't check if the
	* original psearch has been abandoned.
	*/
	if ( so->s_op->o_abandon )
	return SLAPD_ABANDON;

	if ( rs.sr_err == LDAP_SUCCESS && queue && so->s_res ) {
	ldap_pvt_thread_mutex_lock( &so->s_mutex );
	rs.sr_err = syncprov_qplay( &sop, on, so );
	ldap_pvt_thread_mutex_unlock( &so->s_mutex );
	}
return rs.sr_err;	return rs.sr_err;
}	}

Line 776 static void	Line 867 static void
syncprov_free_syncop( syncops *so )	syncprov_free_syncop( syncops *so )
{	{
syncres sr, srnext;	syncres sr, srnext;
	GroupAssertion ga, gnext;

ldap_pvt_thread_mutex_lock( &so->s_mutex );	ldap_pvt_thread_mutex_lock( &so->s_mutex );
so->s_inuse--;	so->s_inuse--;
Line 784 syncprov_free_syncop( syncops *so )	Line 876 syncprov_free_syncop( syncops *so )
return;	return;
}	}
ldap_pvt_thread_mutex_unlock( &so->s_mutex );	ldap_pvt_thread_mutex_unlock( &so->s_mutex );
filter_free( so->s_op->ors_filter );	if ( so->s_flags & PS_IS_DETACHED ) {
ch_free( so->s_op );	filter_free( so->s_op->ors_filter );
	for ( ga = so->s_op->o_groups; ga; ga=gnext ) {
	gnext = ga->ga_next;
	ch_free( ga );
	}
	ch_free( so->s_op );
	}
ch_free( so->s_base.bv_val );	ch_free( so->s_base.bv_val );
for ( sr=so->s_res; sr; sr=srnext ) {	for ( sr=so->s_res; sr; sr=srnext ) {
srnext = sr->s_next;	srnext = sr->s_next;
Line 796 syncprov_free_syncop( syncops *so )	Line 894 syncprov_free_syncop( syncops *so )
}	}

static int	static int
syncprov_drop_psearch( syncops *so )	syncprov_drop_psearch( syncops *so, int lock )
{	{
ldap_pvt_thread_mutex_lock( &so->s_op->o_conn->c_mutex );	if ( so->s_flags & PS_IS_DETACHED ) {
so->s_op->o_conn->c_n_ops_executing--;	if ( lock )
so->s_op->o_conn->c_n_ops_completed++;	ldap_pvt_thread_mutex_lock( &so->s_op->o_conn->c_mutex );
ldap_pvt_thread_mutex_unlock( &so->s_op->o_conn->c_mutex );	so->s_op->o_conn->c_n_ops_executing--;
	so->s_op->o_conn->c_n_ops_completed++;
	LDAP_STAILQ_REMOVE( &so->s_op->o_conn->c_ops, so->s_op, slap_op,
	o_next );
	if ( lock )
	ldap_pvt_thread_mutex_unlock( &so->s_op->o_conn->c_mutex );
	}
syncprov_free_syncop( so );	syncprov_free_syncop( so );

	return 0;
	}

	static int
	syncprov_ab_cleanup( Operation op, SlapReply rs )
	{
	slap_callback *sc = op->o_callback;
	op->o_callback = sc->sc_next;
	syncprov_drop_psearch( op->o_callback->sc_private, 0 );
	op->o_tmpfree( sc, op->o_tmpmemctx );
	return 0;
}	}

static int	static int
Line 826 syncprov_op_abandon( Operation *op, Slap	Line 942 syncprov_op_abandon( Operation *op, Slap
if ( so ) {	if ( so ) {
/* Is this really a Cancel exop? */	/* Is this really a Cancel exop? */
if ( op->o_tag != LDAP_REQ_ABANDON ) {	if ( op->o_tag != LDAP_REQ_ABANDON ) {
	so->s_op->o_cancel = SLAP_CANCEL_ACK;
rs->sr_err = LDAP_CANCELLED;	rs->sr_err = LDAP_CANCELLED;
send_ldap_result( so->s_op, rs );	send_ldap_result( so->s_op, rs );
	if ( so->s_flags & PS_IS_DETACHED ) {
	slap_callback *cb;
	cb = op->o_tmpcalloc( 1, sizeof(slap_callback), op->o_tmpmemctx );
	cb->sc_cleanup = syncprov_ab_cleanup;
	cb->sc_next = op->o_callback;
	cb->sc_private = so;
	return SLAP_CB_CONTINUE;
	}
}	}
syncprov_drop_psearch( so );	syncprov_drop_psearch( so, 0 );
}	}
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}
Line 862 syncprov_matchops( Operation *op, opcook	Line 987 syncprov_matchops( Operation *op, opcook
if ( op->o_tag != LDAP_REQ_ADD ) {	if ( op->o_tag != LDAP_REQ_ADD ) {
op->o_bd->bd_info = (BackendInfo *)on->on_info;	op->o_bd->bd_info = (BackendInfo *)on->on_info;
rc = be_entry_get_rw( op, fc.fdn, NULL, NULL, 0, &e );	rc = be_entry_get_rw( op, fc.fdn, NULL, NULL, 0, &e );
	/* If we're sending responses now, make a copy and unlock the DB */
	if ( e && !saveit ) {
	Entry *e2 = entry_dup( e );
	be_entry_release_rw( op, e, 0 );
	e = e2;
	}
op->o_bd->bd_info = (BackendInfo *)on;	op->o_bd->bd_info = (BackendInfo *)on;
if ( rc ) return;	if ( rc ) return;
} else {	} else {
e = op->ora_e;	e = op->ora_e;
}	}

/* Never replicate these */
if ( is_entry_syncConsumerSubentry( e )) {
goto done;
}
if ( saveit ) {	if ( saveit ) {
ber_dupbv_x( &opc->sdn, &e->e_name, op->o_tmpmemctx );	ber_dupbv_x( &opc->sdn, &e->e_name, op->o_tmpmemctx );
ber_dupbv_x( &opc->sndn, &e->e_nname, op->o_tmpmemctx );	ber_dupbv_x( &opc->sndn, &e->e_nname, op->o_tmpmemctx );
Line 903 syncprov_matchops( Operation *op, opcook	Line 1030 syncprov_matchops( Operation *op, opcook
send_ldap_error( ss->s_op, &rs, LDAP_SYNC_REFRESH_REQUIRED,	send_ldap_error( ss->s_op, &rs, LDAP_SYNC_REFRESH_REQUIRED,
"search base has changed" );	"search base has changed" );
sprev->s_next = snext;	sprev->s_next = snext;
syncprov_drop_psearch( ss );	syncprov_drop_psearch( ss, 1 );
continue;	continue;
}	}

Line 932 syncprov_matchops( Operation *op, opcook	Line 1059 syncprov_matchops( Operation *op, opcook
opc->smatches = sm;	opc->smatches = sm;
} else {	} else {
/* if found send UPDATE else send ADD */	/* if found send UPDATE else send ADD */
syncprov_sendresp( op, opc, ss, e,	ss->s_inuse++;
	ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
	syncprov_sendresp( op, opc, ss, &e,
found ? LDAP_SYNC_MODIFY : LDAP_SYNC_ADD, 1 );	found ? LDAP_SYNC_MODIFY : LDAP_SYNC_ADD, 1 );
	ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
	ss->s_inuse--;
}	}
} else if ( !saveit && found ) {	} else if ( !saveit && found ) {
/* send DELETE */	/* send DELETE */
	ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
syncprov_sendresp( op, opc, ss, NULL, LDAP_SYNC_DELETE, 1 );	syncprov_sendresp( op, opc, ss, NULL, LDAP_SYNC_DELETE, 1 );
	ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
}	}
}	}
ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );	ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
done:
if ( op->o_tag != LDAP_REQ_ADD ) {	if ( op->o_tag != LDAP_REQ_ADD && e ) {
op->o_bd->bd_info = (BackendInfo *)on->on_info;	op->o_bd->bd_info = (BackendInfo *)on->on_info;
be_entry_release_r( op, e );	be_entry_release_rw( op, e, 0 );
op->o_bd->bd_info = (BackendInfo *)on;	op->o_bd->bd_info = (BackendInfo *)on;
}	}
if ( freefdn ) {	if ( freefdn ) {
Line 970 syncprov_op_cleanup( Operation *op, Slap	Line 1103 syncprov_op_cleanup( Operation *op, Slap

/* Remove op from lock table */	/* Remove op from lock table */
mtdummy.mt_op = op;	mtdummy.mt_op = op;
ldap_pvt_thread_rdwr_rlock( &si->si_mods_rwlock );	ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );	mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
ldap_pvt_thread_rdwr_runlock( &si->si_mods_rwlock );
if ( mt ) {	if ( mt ) {
modinst *mi = mt->mt_mods;	modinst *mi = mt->mt_mods;

Line 983 syncprov_op_cleanup( Operation *op, Slap	Line 1115 syncprov_op_cleanup( Operation *op, Slap
mt->mt_op = mt->mt_mods->mi_op;	mt->mt_op = mt->mt_mods->mi_op;
ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );	ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
} else {	} else {
ldap_pvt_thread_rdwr_wlock( &si->si_mods_rwlock );
avl_delete( &si->si_mods, mt, sp_avl_cmp );	avl_delete( &si->si_mods, mt, sp_avl_cmp );
ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );
ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );	ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );	ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );
ch_free( mt );	ch_free( mt );
}	}
}	}
	ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
if ( !BER_BVISNULL( &opc->suuid ))	if ( !BER_BVISNULL( &opc->suuid ))
op->o_tmpfree( opc->suuid.bv_val, op->o_tmpmemctx );	op->o_tmpfree( opc->suuid.bv_val, op->o_tmpmemctx );
if ( !BER_BVISNULL( &opc->sndn ))	if ( !BER_BVISNULL( &opc->sndn ))
Line 999 syncprov_op_cleanup( Operation *op, Slap	Line 1130 syncprov_op_cleanup( Operation *op, Slap
op->o_tmpfree( opc->sdn.bv_val, op->o_tmpmemctx );	op->o_tmpfree( opc->sdn.bv_val, op->o_tmpmemctx );
op->o_callback = cb->sc_next;	op->o_callback = cb->sc_next;
op->o_tmpfree(cb, op->o_tmpmemctx);	op->o_tmpfree(cb, op->o_tmpmemctx);

	return 0;
}	}

static void	static void
Line 1008 syncprov_checkpoint( Operation *op, Slap	Line 1141 syncprov_checkpoint( Operation *op, Slap
Modifications mod;	Modifications mod;
Operation opm;	Operation opm;
struct berval bv[2];	struct berval bv[2];
BackendInfo *orig;
slap_callback cb = {0};	slap_callback cb = {0};
	int manage = get_manageDSAit(op);

mod.sml_values = bv;	mod.sml_values = bv;
bv[1].bv_val = NULL;	bv[1].bv_val = NULL;
Line 1017 syncprov_checkpoint( Operation *op, Slap	Line 1150 syncprov_checkpoint( Operation *op, Slap
mod.sml_nvalues = NULL;	mod.sml_nvalues = NULL;
mod.sml_desc = slap_schema.si_ad_contextCSN;	mod.sml_desc = slap_schema.si_ad_contextCSN;
mod.sml_op = LDAP_MOD_REPLACE;	mod.sml_op = LDAP_MOD_REPLACE;
	mod.sml_flags = 0;
mod.sml_next = NULL;	mod.sml_next = NULL;

cb.sc_response = slap_null_cb;	cb.sc_response = slap_null_cb;
Line 1026 syncprov_checkpoint( Operation *op, Slap	Line 1160 syncprov_checkpoint( Operation *op, Slap
opm.orm_modlist = &mod;	opm.orm_modlist = &mod;
opm.o_req_dn = op->o_bd->be_suffix[0];	opm.o_req_dn = op->o_bd->be_suffix[0];
opm.o_req_ndn = op->o_bd->be_nsuffix[0];	opm.o_req_ndn = op->o_bd->be_nsuffix[0];
orig = opm.o_bd->bd_info;
opm.o_bd->bd_info = on->on_info->oi_orig;	opm.o_bd->bd_info = on->on_info->oi_orig;
	opm.o_managedsait = SLAP_CONTROL_NONCRITICAL;
opm.o_bd->be_modify( &opm, rs );	opm.o_bd->be_modify( &opm, rs );
	opm.o_managedsait = manage;
	}

	static void
	syncprov_add_slog( Operation op, struct berval csn )
	{
	opcookie *opc = op->o_callback->sc_private;
	slap_overinst *on = opc->son;
	syncprov_info_t *si = on->on_bi.bi_private;
	sessionlog *sl;
	slog_entry *se;

	sl = si->si_logs;
	{
	/* Allocate a record. UUIDs are not NUL-terminated. */
	se = ch_malloc( sizeof( slog_entry ) + opc->suuid.bv_len +
	csn->bv_len + 1 );
	se->se_next = NULL;
	se->se_tag = op->o_tag;

	se->se_uuid.bv_val = (char *)(se+1);
	se->se_csn.bv_val = se->se_uuid.bv_val + opc->suuid.bv_len + 1;
	AC_MEMCPY( se->se_uuid.bv_val, opc->suuid.bv_val, opc->suuid.bv_len );
	se->se_uuid.bv_len = opc->suuid.bv_len;

	AC_MEMCPY( se->se_csn.bv_val, csn->bv_val, csn->bv_len );
	se->se_csn.bv_val[csn->bv_len] = '\0';
	se->se_csn.bv_len = csn->bv_len;

	ldap_pvt_thread_mutex_lock( &sl->sl_mutex );
	if ( sl->sl_head ) {
	sl->sl_tail->se_next = se;
	} else {
	sl->sl_head = se;
	}
	sl->sl_tail = se;
	sl->sl_num++;
	while ( sl->sl_num > sl->sl_size ) {
	se = sl->sl_head;
	sl->sl_head = se->se_next;
	strcpy( sl->sl_mincsn.bv_val, se->se_csn.bv_val );
	sl->sl_mincsn.bv_len = se->se_csn.bv_len;
	ch_free( se );
	sl->sl_num--;
	if ( !sl->sl_head ) {
	sl->sl_tail = NULL;
	}
	}
	ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );
	}
	}

	/* Just set a flag if we found the matching entry */
	static int
	playlog_cb( Operation op, SlapReply rs )
	{
	if ( rs->sr_type == REP_SEARCH ) {
	op->o_callback->sc_private = (void *)1;
	}
	return rs->sr_err;
	}

	/* enter with sl->sl_mutex locked, release before returning */
	static void
	syncprov_playlog( Operation op, SlapReply rs, sessionlog *sl,
	struct berval oldcsn, struct berval ctxcsn )
	{
	slap_overinst on = (slap_overinst )op->o_bd->bd_info;
	syncprov_info_t *si = on->on_bi.bi_private;
	slog_entry *se;
	int i, j, ndel, num, nmods, mmods;
	BerVarray uuids;

	if ( !sl->sl_num ) {
	ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );
	return;
	}

	num = sl->sl_num;
	i = 0;
	nmods = 0;

	uuids = op->o_tmpalloc( (num+1) * sizeof( struct berval ) +
	num * UUID_LEN, op->o_tmpmemctx );

	uuids[0].bv_val = (char *)(uuids + num + 1);

	/* Make a copy of the relevant UUIDs. Put the Deletes up front
	* and everything else at the end. Do this first so we can
	* unlock the list mutex.
	*/
	for ( se=sl->sl_head; se; se=se->se_next ) {
	if ( ber_bvcmp( &se->se_csn, oldcsn ) < 0 ) continue;
	if ( ber_bvcmp( &se->se_csn, ctxcsn ) > 0 ) break;
	if ( se->se_tag == LDAP_REQ_DELETE ) {
	j = i;
	i++;
	} else {
	nmods++;
	j = num - nmods;
	}
	uuids[j].bv_val = uuids[0].bv_val + (j * UUID_LEN);
	AC_MEMCPY(uuids[j].bv_val, se->se_uuid.bv_val, UUID_LEN);
	uuids[j].bv_len = UUID_LEN;
	}
	ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );

	ndel = i;

	/* Zero out unused slots */
	for ( i=ndel; i < num - nmods; i++ )
	uuids[i].bv_len = 0;

	/* Mods must be validated to see if they belong in this delete set.
	*/

	mmods = nmods;
	/* Strip any duplicates */
	for ( i=0; i<nmods; i++ ) {
	for ( j=0; j<ndel; j++ ) {
	if ( bvmatch( &uuids[j], &uuids[num - 1 - i] )) {
	uuids[num - 1 - i].bv_len = 0;
	mmods --;
	break;
	}
	}
	if ( uuids[num - 1 - i].bv_len == 0 ) continue;
	for ( j=0; j<i; j++ ) {
	if ( bvmatch( &uuids[num - 1 - j], &uuids[num - 1 - i] )) {
	uuids[num - 1 - i].bv_len = 0;
	mmods --;
	break;
	}
	}
	}

	if ( mmods ) {
	Operation fop;
	SlapReply frs = { REP_RESULT };
	int rc;
	Filter mf, af;
	#ifdef LDAP_COMP_MATCH
	AttributeAssertion eq = { NULL, BER_BVNULL, NULL };
	#else
	AttributeAssertion eq;
	#endif
	slap_callback cb = {0};

	fop = *op;

	fop.o_sync_mode = 0;
	fop.o_callback = &cb;
	fop.ors_limit = NULL;
	fop.ors_tlimit = SLAP_NO_LIMIT;
	fop.ors_attrs = slap_anlist_all_attributes;
	fop.ors_attrsonly = 0;
	fop.o_managedsait = SLAP_CONTROL_CRITICAL;

	af.f_choice = LDAP_FILTER_AND;
	af.f_next = NULL;
	af.f_and = &mf;
	mf.f_choice = LDAP_FILTER_EQUALITY;
	mf.f_ava = &eq;
	mf.f_av_desc = slap_schema.si_ad_entryUUID;
	mf.f_next = fop.ors_filter;

	fop.ors_filter = ⁡

	cb.sc_response = playlog_cb;
	fop.o_bd->bd_info = on->on_info->oi_orig;

	for ( i=ndel; i<num; i++ ) {
	if ( uuids[i].bv_len == 0 ) continue;

	mf.f_av_value = uuids[i];
	cb.sc_private = NULL;
	fop.ors_slimit = 1;
	rc = fop.o_bd->be_search( &fop, &frs );

	/* If entry was not found, add to delete list */
	if ( !cb.sc_private ) {
	uuids[ndel++] = uuids[i];
	}
	}
	fop.o_bd->bd_info = (BackendInfo *)on;
	}
	if ( ndel ) {
	uuids[ndel].bv_val = NULL;
	syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL, 0, uuids, 1 );
	}
}	}

static int	static int
Line 1041 syncprov_op_response( Operation *op, Sla	Line 1365 syncprov_op_response( Operation *op, Sla

if ( rs->sr_err == LDAP_SUCCESS )	if ( rs->sr_err == LDAP_SUCCESS )
{	{
struct berval maxcsn;	struct berval maxcsn = BER_BVNULL, curcsn = BER_BVNULL;
char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];	char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];

/* Update our context CSN */	/* Update our context CSN */
cbuf[0] = '\0';	cbuf[0] = '\0';
ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );	ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
slap_get_commit_csn( op, &maxcsn );	slap_get_commit_csn( op, &maxcsn, &curcsn );
if ( !BER_BVISNULL( &maxcsn ) ) {	if ( !BER_BVISNULL( &maxcsn ) ) {
strcpy( cbuf, maxcsn.bv_val );	strcpy( cbuf, maxcsn.bv_val );
if ( ber_bvcmp( &maxcsn, &si->si_ctxcsn ) > 0 ) {	if ( ber_bvcmp( &maxcsn, &si->si_ctxcsn ) > 0 ) {
Line 1056 syncprov_op_response( Operation *op, Sla	Line 1380 syncprov_op_response( Operation *op, Sla
}	}
}	}

	/* Don't do any processing for consumer contextCSN updates */
	if ( SLAP_SYNC_SHADOW( op->o_bd ) &&
	op->o_msgid == SLAP_SYNC_UPDATE_MSGID ) {
	ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );
	return SLAP_CB_CONTINUE;
	}

si->si_numops++;	si->si_numops++;
if ( si->si_chkops \|\| si->si_chktime ) {	if ( si->si_chkops \|\| si->si_chktime ) {
int do_check=0;	int do_check=0;
Line 1090 syncprov_op_response( Operation *op, Sla	Line 1421 syncprov_op_response( Operation *op, Sla
/* for each match in opc->smatches:	/* for each match in opc->smatches:
* send DELETE msg	* send DELETE msg
*/	*/
ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
for ( sm = opc->smatches; sm; sm=sm->sm_next ) {	for ( sm = opc->smatches; sm; sm=sm->sm_next ) {
if ( sm->sm_op->s_op->o_abandon )	if ( sm->sm_op->s_op->o_abandon )
continue;	continue;
syncprov_sendresp( op, opc, sm->sm_op, NULL,	syncprov_sendresp( op, opc, sm->sm_op, NULL,
LDAP_SYNC_DELETE, 1 );	LDAP_SYNC_DELETE, 1 );
}	}
ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
break;	break;
}	}
}	}

	/* Add any log records */
	if ( si->si_logs && op->o_tag != LDAP_REQ_ADD ) {
	syncprov_add_slog( op, &curcsn );
	}

}	}
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}
Line 1206 syncprov_op_mod( Operation *op, SlapRepl	Line 1540 syncprov_op_mod( Operation *op, SlapRepl

/* See if we're already modifying this entry... */	/* See if we're already modifying this entry... */
mtdummy.mt_op = op;	mtdummy.mt_op = op;
ldap_pvt_thread_rdwr_wlock( &si->si_mods_rwlock );	ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );	mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
if ( mt ) {	if ( mt ) {
ldap_pvt_thread_mutex_lock( &mt->mt_mutex );	ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );	ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
mt->mt_tail->mi_next = mi;	mt->mt_tail->mi_next = mi;
mt->mt_tail = mi;	mt->mt_tail = mi;
/* wait for this op to get to head of list */	/* wait for this op to get to head of list */
Line 1218 syncprov_op_mod( Operation *op, SlapRepl	Line 1552 syncprov_op_mod( Operation *op, SlapRepl
ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );	ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
ldap_pvt_thread_yield();	ldap_pvt_thread_yield();
ldap_pvt_thread_mutex_lock( &mt->mt_mutex );	ldap_pvt_thread_mutex_lock( &mt->mt_mutex );

	/* clean up if the caller is giving up */
	if ( op->o_abandon ) {
	modinst *m2;
	for ( m2 = mt->mt_mods; m2->mi_next != mi;
	m2 = m2->mi_next );
	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;
	}
}	}
	ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
} else {	} else {
/* Record that we're modifying this entry now */	/* Record that we're modifying this entry now */
mt = ch_malloc( sizeof(modtarget) );	mt = ch_malloc( sizeof(modtarget) );
Line 1227 syncprov_op_mod( Operation *op, SlapRepl	Line 1574 syncprov_op_mod( Operation *op, SlapRepl
mt->mt_op = mi->mi_op;	mt->mt_op = mi->mi_op;
ldap_pvt_thread_mutex_init( &mt->mt_mutex );	ldap_pvt_thread_mutex_init( &mt->mt_mutex );
avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error );	avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error );
ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );	ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
}	}

if ( op->o_tag != LDAP_REQ_ADD )
syncprov_matchops( op, opc, 1 );
}	}

	if (( si->si_ops \|\| si->si_logs ) && op->o_tag != LDAP_REQ_ADD )
	syncprov_matchops( op, opc, 1 );

return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

Line 1249 syncprov_op_extended( Operation *op, Sla	Line 1596 syncprov_op_extended( Operation *op, Sla
typedef struct searchstate {	typedef struct searchstate {
slap_overinst *ss_on;	slap_overinst *ss_on;
syncops *ss_so;	syncops *ss_so;
	int ss_present;
} searchstate;	} searchstate;

static int	static int
syncprov_search_cleanup( Operation op, SlapReply rs )	syncprov_search_cleanup( Operation op, SlapReply rs )
{	{
#if 0
if ( rs->sr_ctrls ) {	if ( rs->sr_ctrls ) {
free( rs->sr_ctrls[0] );	op->o_tmpfree( rs->sr_ctrls[0], op->o_tmpmemctx );
op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx );	op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx );
rs->sr_ctrls = NULL;	rs->sr_ctrls = NULL;
}	}
#endif
return 0;	return 0;
}	}

Line 1271 syncprov_detach_op( Operation *op, synco	Line 1617 syncprov_detach_op( Operation *op, synco
int i, alen = 0;	int i, alen = 0;
size_t size;	size_t size;
char *ptr;	char *ptr;
	GroupAssertion g1, g2;

/* count the search attrs */	/* count the search attrs */
for (i=0; op->ors_attrs && !BER_BVISNULL( &op->ors_attrs[i].an_name ); i++) {	for (i=0; op->ors_attrs && !BER_BVISNULL( &op->ors_attrs[i].an_name ); i++) {
Line 1283 syncprov_detach_op( Operation *op, synco	Line 1630 syncprov_detach_op( Operation *op, synco
op->o_req_ndn.bv_len + 1 +	op->o_req_ndn.bv_len + 1 +
op->o_ndn.bv_len + 1 +	op->o_ndn.bv_len + 1 +
so->s_filterstr.bv_len + 1;	so->s_filterstr.bv_len + 1;
op2 = (Operation *)ch_malloc( size );	op2 = (Operation *)ch_calloc( 1, size );
op2 = op;
op2->o_hdr = (Opheader *)(op2+1);	op2->o_hdr = (Opheader *)(op2+1);

	/* Copy the fields we care about explicitly, leave the rest alone */
op2->o_hdr = op->o_hdr;	op2->o_hdr = op->o_hdr;
	op2->o_tag = op->o_tag;
	op2->o_time = op->o_time;
	op2->o_bd = op->o_bd;
	op2->o_request = op->o_request;

if ( i ) {	if ( i ) {
op2->ors_attrs = (AttributeName *)(op2->o_hdr + 1);	op2->ors_attrs = (AttributeName *)(op2->o_hdr + 1);
ptr = (char *)(op2->ors_attrs+i+1);	ptr = (char *)(op2->ors_attrs+i+1);
Line 1299 syncprov_detach_op( Operation *op, synco	Line 1652 syncprov_detach_op( Operation *op, synco
} else {	} else {
ptr = (char *)(op2->o_hdr + 1);	ptr = (char *)(op2->o_hdr + 1);
}	}
	op2->o_authz = op->o_authz;
op2->o_ndn.bv_val = ptr;	op2->o_ndn.bv_val = ptr;
ptr = lutil_strcopy(ptr, op->o_ndn.bv_val) + 1;	ptr = lutil_strcopy(ptr, op->o_ndn.bv_val) + 1;
op2->o_dn = op2->o_ndn;	op2->o_dn = op2->o_ndn;
	op2->o_req_dn.bv_len = op->o_req_dn.bv_len;
op2->o_req_dn.bv_val = ptr;	op2->o_req_dn.bv_val = ptr;
ptr = lutil_strcopy(ptr, op->o_req_dn.bv_val) + 1;	ptr = lutil_strcopy(ptr, op->o_req_dn.bv_val) + 1;
	op2->o_req_ndn.bv_len = op->o_req_ndn.bv_len;
op2->o_req_ndn.bv_val = ptr;	op2->o_req_ndn.bv_val = ptr;
ptr = lutil_strcopy(ptr, op->o_req_ndn.bv_val) + 1;	ptr = lutil_strcopy(ptr, op->o_req_ndn.bv_val) + 1;
op2->ors_filterstr.bv_val = ptr;	op2->ors_filterstr.bv_val = ptr;
strcpy( ptr, so->s_filterstr.bv_val );	strcpy( ptr, so->s_filterstr.bv_val );
op2->ors_filterstr.bv_len = so->s_filterstr.bv_len;	op2->ors_filterstr.bv_len = so->s_filterstr.bv_len;
op2->ors_filter = str2filter( ptr );	op2->ors_filter = str2filter( ptr );
op2->o_controls = NULL;
op2->o_callback = NULL;
so->s_op = op2;	so->s_op = op2;

/* Increment number of ops so that idletimeout ignores us */	/* Copy any cached group ACLs individually */
	op2->o_groups = NULL;
	for ( g1=op->o_groups; g1; g1=g1->ga_next ) {
	g2 = ch_malloc( sizeof(GroupAssertion) + g1->ga_len );
	g2 = g1;
	strcpy( g2->ga_ndn, g1->ga_ndn );
	g2->ga_next = op2->o_groups;
	op2->o_groups = g2;
	}

	/* Add op2 to conn so abandon will find us */
ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex );	ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex );
op->o_conn->c_n_ops_executing++;	op->o_conn->c_n_ops_executing++;
op->o_conn->c_n_ops_completed--;	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 );	ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex );
}	}

Line 1341 syncprov_search_response( Operation *op,	Line 1707 syncprov_search_response( Operation *op,
Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );	Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}
if ( srs->sr_state.ctxcsn ) {	if ( !BER_BVISNULL( &srs->sr_state.ctxcsn )) {
Attribute *a = attr_find( rs->sr_entry->e_attrs,	Attribute *a = attr_find( rs->sr_entry->e_attrs,
slap_schema.si_ad_entryCSN );	slap_schema.si_ad_entryCSN );

/* Don't send the ctx entry twice */	/* Don't send the ctx entry twice */
if ( bvmatch( &a->a_nvals[0], srs->sr_state.ctxcsn ))	if ( a && bvmatch( &a->a_nvals[0], &srs->sr_state.ctxcsn ) )
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}
rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl )2,	rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl )2,
Line 1358 syncprov_search_response( Operation *op,	Line 1725 syncprov_search_response( Operation *op,

slap_compose_sync_cookie( op, &cookie,	slap_compose_sync_cookie( op, &cookie,
&op->ors_filter->f_and->f_ava->aa_value,	&op->ors_filter->f_and->f_ava->aa_value,
srs->sr_state.sid, srs->sr_state.rid );	srs->sr_state.rid );

/* Is this a regular refresh? */	/* Is this a regular refresh? */
if ( !ss->ss_so ) {	if ( !ss->ss_so ) {
Line 1366 syncprov_search_response( Operation *op,	Line 1733 syncprov_search_response( Operation *op,
op->o_tmpmemctx );	op->o_tmpmemctx );
rs->sr_ctrls[1] = NULL;	rs->sr_ctrls[1] = NULL;
rs->sr_err = syncprov_done_ctrl( op, rs, rs->sr_ctrls,	rs->sr_err = syncprov_done_ctrl( op, rs, rs->sr_ctrls,
0, 1, &cookie, LDAP_SYNC_REFRESH_PRESENTS );	0, 1, &cookie, ss->ss_present ? LDAP_SYNC_REFRESH_PRESENTS :
	LDAP_SYNC_REFRESH_DELETES );
} else {	} else {
int locked = 0;	int locked = 0;
/* It's RefreshAndPersist, transition to Persist phase */	/* It's RefreshAndPersist, transition to Persist phase */
syncprov_sendinfo( op, rs, rs->sr_nentries ?	syncprov_sendinfo( op, rs, ( ss->ss_present && rs->sr_nentries ) ?
LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,	LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,
&cookie, 1, NULL, 0 );	&cookie, 1, NULL, 0 );
/* Flush any queued persist messages */	/* Flush any queued persist messages */
if ( ss->ss_so->s_res ) {	if ( ss->ss_so->s_res ) {
syncres sr, srnext;
Entry *e;
opcookie opc;

opc.son = on;
ldap_pvt_thread_mutex_lock( &ss->ss_so->s_mutex );	ldap_pvt_thread_mutex_lock( &ss->ss_so->s_mutex );
locked = 1;	locked = 1;
for (sr = ss->ss_so->s_res; sr; sr=srnext) {	syncprov_qplay( op, on, ss->ss_so );
int rc = LDAP_SUCCESS;
srnext = sr->s_next;
opc.sdn = sr->s_dn;
opc.sndn = sr->s_ndn;
opc.suuid = sr->s_uuid;
opc.sctxcsn = sr->s_csn;
opc.sreference = sr->s_isreference;
e = NULL;

if ( sr->s_mode != LDAP_SYNC_DELETE ) {
op->o_bd->bd_info = (BackendInfo *)on->on_info;
rc = be_entry_get_rw( op, &opc.sndn, NULL, NULL, 0, &e );
op->o_bd->bd_info = (BackendInfo *)on;
}
if ( rc == LDAP_SUCCESS )
syncprov_sendresp( op, &opc, ss->ss_so, e,
sr->s_mode, 0 );

if ( e ) {
op->o_bd->bd_info = (BackendInfo *)on->on_info;
be_entry_release_r( op, e );
op->o_bd->bd_info = (BackendInfo *)on;
}
ch_free( sr );
}
ss->ss_so->s_res = NULL;
ss->ss_so->s_restail = NULL;
}	}

/* Turn off the refreshing flag */	/* Turn off the refreshing flag */
Line 1433 syncprov_op_search( Operation *op, SlapR	Line 1769 syncprov_op_search( Operation *op, SlapR
slap_overinst on = (slap_overinst )op->o_bd->bd_info;	slap_overinst on = (slap_overinst )op->o_bd->bd_info;
syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;	syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;
slap_callback *cb;	slap_callback *cb;
int gotstate = 0, nochange = 0;	int gotstate = 0, nochange = 0, do_present = 1;
Filter fand, fava;	Filter fand, fava;
syncops *sop = NULL;	syncops *sop = NULL;
searchstate *ss;	searchstate *ss;
sync_control *srs;	sync_control *srs;
	struct berval ctxcsn;
	char csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];

if ( !(op->o_sync_mode & SLAP_SYNC_REFRESH) ) return SLAP_CB_CONTINUE;	if ( !(op->o_sync_mode & SLAP_SYNC_REFRESH) ) return SLAP_CB_CONTINUE;

Line 1447 syncprov_op_search( Operation *op, SlapR	Line 1785 syncprov_op_search( Operation *op, SlapR
}	}

srs = op->o_controls[slap_cids.sc_LDAPsync];	srs = op->o_controls[slap_cids.sc_LDAPsync];
	op->o_managedsait = SLAP_CONTROL_NONCRITICAL;

/* If this is a persistent search, set it up right away */	/* If this is a persistent search, set it up right away */
if ( op->o_sync_mode & SLAP_SYNC_PERSIST ) {	if ( op->o_sync_mode & SLAP_SYNC_PERSIST ) {
Line 1475 syncprov_op_search( Operation *op, SlapR	Line 1814 syncprov_op_search( Operation *op, SlapR
sop = ch_malloc( sizeof( syncops ));	sop = ch_malloc( sizeof( syncops ));
*sop = so;	*sop = so;
ldap_pvt_thread_mutex_init( &sop->s_mutex );	ldap_pvt_thread_mutex_init( &sop->s_mutex );
ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
sop->s_sid = srs->sr_state.sid;
sop->s_rid = srs->sr_state.rid;	sop->s_rid = srs->sr_state.rid;
sop->s_next = si->si_ops;
sop->s_inuse = 1;	sop->s_inuse = 1;

	ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
	sop->s_next = si->si_ops;
si->si_ops = sop;	si->si_ops = sop;
ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );	ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
}	}

/* If we have a cookie, handle the PRESENT lookups	/* snapshot the ctxcsn */
*/	ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
if ( srs->sr_state.ctxcsn ) {	strcpy( csnbuf, si->si_ctxcsnbuf );
/* Is the CSN in a valid format? */	ctxcsn.bv_len = si->si_ctxcsn.bv_len;
if ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {	ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );
send_ldap_error( op, rs, LDAP_OTHER, "invalid sync cookie" );	ctxcsn.bv_val = csnbuf;
return rs->sr_err;
	/* If we have a cookie, handle the PRESENT lookups */
	if ( !BER_BVISNULL( &srs->sr_state.ctxcsn )) {
	sessionlog *sl;

	/* The cookie was validated when it was parsed, just use it */

	/* If just Refreshing and nothing has changed, shortcut it */
	if ( bvmatch( &srs->sr_state.ctxcsn, &ctxcsn )) {
	nochange = 1;
	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;
	}
	/* Do we have a sessionlog for this search? */
	sl=si->si_logs;
	if ( sl ) {
	ldap_pvt_thread_mutex_lock( &sl->sl_mutex );
	if ( ber_bvcmp( &srs->sr_state.ctxcsn, &sl->sl_mincsn ) >= 0 ) {
	do_present = 0;
	/* mutex is unlocked in playlog */
	syncprov_playlog( op, rs, sl, &srs->sr_state.ctxcsn, &ctxcsn );
	} else {
	ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );
	}
}	}
/* Is the CSN still present in the database? */	/* Is the CSN still present in the database? */
if ( syncprov_findcsn( op, FIND_CSN ) != LDAP_SUCCESS ) {	if ( syncprov_findcsn( op, FIND_CSN ) != LDAP_SUCCESS ) {
Line 1503 syncprov_op_search( Operation *op, SlapR	Line 1877 syncprov_op_search( Operation *op, SlapR
#endif	#endif
} else {	} else {
gotstate = 1;	gotstate = 1;
/* If just Refreshing and nothing has changed, shortcut it */	/* If changed and doing Present lookup, send Present UUIDs */
if ( bvmatch( srs->sr_state.ctxcsn, &si->si_ctxcsn )) {	if ( do_present && syncprov_findcsn( op, FIND_PRESENT ) !=
nochange = 1;	LDAP_SUCCESS ) {
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;
} else
/* If context has changed, check for Present UUIDs */
if ( syncprov_findcsn( op, FIND_PRESENT ) != LDAP_SUCCESS ) {
send_ldap_result( op, rs );	send_ldap_result( op, rs );
return rs->sr_err;	return rs->sr_err;
}	}
}	}
}	}

	shortcut:
/* Append CSN range to search filter, save original filter	/* Append CSN range to search filter, save original filter
* for persistent search evaluation	* for persistent search evaluation
*/	*/
Line 1543 syncprov_op_search( Operation *op, SlapR	Line 1901 syncprov_op_search( Operation *op, SlapR
fava->f_choice = LDAP_FILTER_LE;	fava->f_choice = LDAP_FILTER_LE;
fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );	fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );
fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;	fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;
ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );	#ifdef LDAP_COMP_MATCH
ber_dupbv_x( &fava->f_ava->aa_value, &si->si_ctxcsn, op->o_tmpmemctx );	fava->f_ava->aa_cf = NULL;
ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );	#endif
	ber_dupbv_x( &fava->f_ava->aa_value, &ctxcsn, op->o_tmpmemctx );
fand->f_and = fava;	fand->f_and = fava;
if ( gotstate ) {	if ( gotstate ) {
fava->f_next = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );	fava->f_next = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );
Line 1553 syncprov_op_search( Operation *op, SlapR	Line 1912 syncprov_op_search( Operation *op, SlapR
fava->f_choice = LDAP_FILTER_GE;	fava->f_choice = LDAP_FILTER_GE;
fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );	fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );
fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;	fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;
ber_dupbv_x( &fava->f_ava->aa_value, srs->sr_state.ctxcsn, op->o_tmpmemctx );	#ifdef LDAP_COMP_MATCH
	fava->f_ava->aa_cf = NULL;
	#endif
	ber_dupbv_x( &fava->f_ava->aa_value, &srs->sr_state.ctxcsn, op->o_tmpmemctx );
}	}
fava->f_next = op->ors_filter;	fava->f_next = op->ors_filter;
op->ors_filter = fand;	op->ors_filter = fand;
filter2bv_x( op, op->ors_filter, &op->ors_filterstr );	filter2bv_x( op, op->ors_filter, &op->ors_filterstr );

shortcut:
/* Let our callback add needed info to returned entries */	/* Let our callback add needed info to returned entries */
cb = op->o_tmpcalloc(1, sizeof(slap_callback)+sizeof(searchstate), op->o_tmpmemctx);	cb = op->o_tmpcalloc(1, sizeof(slap_callback)+sizeof(searchstate), op->o_tmpmemctx);
ss = (searchstate *)(cb+1);	ss = (searchstate *)(cb+1);
ss->ss_on = on;	ss->ss_on = on;
ss->ss_so = sop;	ss->ss_so = sop;
	ss->ss_present = do_present;
cb->sc_response = syncprov_search_response;	cb->sc_response = syncprov_search_response;
cb->sc_cleanup = syncprov_search_cleanup;	cb->sc_cleanup = syncprov_search_cleanup;
cb->sc_private = ss;	cb->sc_private = ss;
Line 1633 syncprov_operational(	Line 1995 syncprov_operational(
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

	enum {
	SP_CHKPT = 1,
	SP_SESSL
	};

	static ConfigDriver sp_cf_gen;

	static ConfigTable spcfg[] = {
	{ "syncprov-checkpoint", "ops> <minutes", 3, 3, 0, ARG_MAGIC\|SP_CHKPT,
	sp_cf_gen, "( OLcfgOvAt:1.1 NAME 'olcSpCheckpoint' "
	"DESC 'ContextCSN checkpoint interval in ops and minutes' "
	"SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
	{ "syncprov-sessionlog", "size", 2, 2, 0, ARG_INT\|ARG_MAGIC\|SP_SESSL,
	sp_cf_gen, "( OLcfgOvAt:1.2 NAME 'olcSpSessionlog' "
	"DESC 'Session log size in ops' "
	"SYNTAX OMsInteger SINGLE-VALUE )", NULL, NULL },
	{ NULL, NULL, 0, 0, 0, ARG_IGNORED }
	};

	static ConfigOCs spocs[] = {
	{ "( OLcfgOvOc:1.1 "
	"NAME 'olcSyncProvConfig' "
	"DESC 'SyncRepl Provider configuration' "
	"SUP olcOverlayConfig "
	"MAY ( olcSpCheckpoint $ olcSpSessionlog ) )",
	Cft_Overlay, spcfg },
	{ NULL, 0, NULL }
	};

static int	static int
syncprov_db_config(	sp_cf_gen(ConfigArgs *c)
BackendDB *be,
const char *fname,
int lineno,
int argc,
char **argv
)
{	{
slap_overinst on = (slap_overinst )be->bd_info;	slap_overinst on = (slap_overinst )c->bi;
syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;	syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;
	int rc = 0;

if ( strcasecmp( argv[ 0 ], "syncprov-checkpoint" ) == 0 ) {	if ( c->op == SLAP_CONFIG_EMIT ) {
if ( argc != 3 ) {	switch ( c->type ) {
fprintf( stderr, "%s: line %d: wrong number of arguments in "	case SP_CHKPT:
"\"syncprov-checkpoint <ops> <minutes>\"\n", fname, lineno );	if ( si->si_chkops \|\| si->si_chktime ) {
return -1;	struct berval bv;
	bv.bv_len = sprintf( c->msg, "%d %d",
	si->si_chkops, si->si_chktime );
	bv.bv_val = c->msg;
	value_add_one( &c->rvalue_vals, &bv );
	} else {
	rc = 1;
	}
	break;
	case SP_SESSL:
	if ( si->si_logs ) {
	c->value_int = si->si_logs->sl_size;
	} else {
	rc = 1;
	}
	break;
}	}
si->si_chkops = atoi( argv[1] );	return rc;
si->si_chktime = atoi( argv[2] ) * 60;	} else if ( c->op == LDAP_MOD_DELETE ) {
return 0;	switch ( c->type ) {
	case SP_CHKPT:
	si->si_chkops = 0;
	si->si_chktime = 0;
	break;
	case SP_SESSL:
	if ( si->si_logs )
	si->si_logs->sl_size = 0;
	else
	rc = LDAP_NO_SUCH_ATTRIBUTE;
	break;
	}
	return rc;
}	}
	switch ( c->type ) {
return SLAP_CONF_UNKNOWN;	case SP_CHKPT:
	si->si_chkops = atoi( c->argv[1] );
	si->si_chktime = atoi( c->argv[2] ) * 60;
	break;
	case SP_SESSL: {
	sessionlog *sl;
	int size = c->value_int;

	if ( size < 0 ) {
	sprintf( c->msg, "%s size %d is negative",
	c->argv[0], size );
	Debug( LDAP_DEBUG_CONFIG, "%s: %s\n", c->log, c->msg, 0 );
	return ARG_BAD_CONF;
	}
	sl = si->si_logs;
	if ( !sl ) {
	sl = ch_malloc( sizeof( sessionlog ) + LDAP_LUTIL_CSNSTR_BUFSIZE );
	sl->sl_mincsn.bv_val = (char *)(sl+1);
	sl->sl_mincsn.bv_len = 0;
	sl->sl_num = 0;
	sl->sl_head = sl->sl_tail = NULL;
	ldap_pvt_thread_mutex_init( &sl->sl_mutex );
	si->si_logs = sl;
	}
	sl->sl_size = size;
	}
	break;
	}
	return rc;
}	}

/* Cheating - we have no thread pool context for these functions,	/* Cheating - we have no thread pool context for these functions,
Line 1673 typedef struct thread_keys {	Line 2113 typedef struct thread_keys {
/* A fake thread context */	/* A fake thread context */
static thread_keys thrctx[MAXKEYS];	static thread_keys thrctx[MAXKEYS];

	/* ITS#3456 we cannot run this search on the main thread, must use a
	* child thread in order to insure we have a big enough stack.
	*/
	static void *
	syncprov_db_otask(
	void *ptr
	)
	{
	syncprov_findcsn( ptr, FIND_MAXCSN );
	return NULL;
	}

/* Read any existing contextCSN from the underlying db.	/* Read any existing contextCSN from the underlying db.
* Then search for any entries newer than that. If no value exists,	* Then search for any entries newer than that. If no value exists,
* just generate it. Cache whatever result.	* just generate it. Cache whatever result.
Line 1687 syncprov_db_open(	Line 2139 syncprov_db_open(

Connection conn;	Connection conn;
char opbuf[OPERATION_BUFFER_SIZE];	char opbuf[OPERATION_BUFFER_SIZE];
	char ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
Operation op = (Operation )opbuf;	Operation op = (Operation )opbuf;
Entry *e;	Entry *e;
Attribute *a;	Attribute *a;
int rc;	int rc;

	if ( slapMode & SLAP_TOOL_MODE ) {
	return 0;
	}

	rc = overlay_register_control( be, LDAP_CONTROL_SYNC );
	if ( rc ) {
	return rc;
	}

connection_fake_init( &conn, op, thrctx );	connection_fake_init( &conn, op, thrctx );
op->o_bd = be;	op->o_bd = be;
op->o_dn = be->be_rootdn;	op->o_dn = be->be_rootdn;
op->o_ndn = be->be_rootndn;	op->o_ndn = be->be_rootndn;

	ctxcsnbuf[0] = '\0';

op->o_bd->bd_info = on->on_info->oi_orig;	op->o_bd->bd_info = on->on_info->oi_orig;
rc = be_entry_get_rw( op, be->be_nsuffix, NULL,	rc = be_entry_get_rw( op, be->be_nsuffix, NULL,
slap_schema.si_ad_contextCSN, 0, &e );	slap_schema.si_ad_contextCSN, 0, &e );

if ( e ) {	if ( e ) {
	ldap_pvt_thread_t tid;

a = attr_find( e->e_attrs, slap_schema.si_ad_contextCSN );	a = attr_find( e->e_attrs, slap_schema.si_ad_contextCSN );
if ( a ) {	if ( a ) {
si->si_ctxcsn.bv_len = a->a_nvals[0].bv_len;	si->si_ctxcsn.bv_len = a->a_nvals[0].bv_len;
Line 1710 syncprov_db_open(	Line 2176 syncprov_db_open(
strncpy( si->si_ctxcsnbuf, a->a_nvals[0].bv_val,	strncpy( si->si_ctxcsnbuf, a->a_nvals[0].bv_val,
si->si_ctxcsn.bv_len );	si->si_ctxcsn.bv_len );
si->si_ctxcsnbuf[si->si_ctxcsn.bv_len] = '\0';	si->si_ctxcsnbuf[si->si_ctxcsn.bv_len] = '\0';
	strcpy( ctxcsnbuf, si->si_ctxcsnbuf );
}	}
be_entry_release_r( op, e );	be_entry_release_rw( op, e, 0 );
op->o_bd->bd_info = (BackendInfo *)on;	op->o_bd->bd_info = (BackendInfo *)on;
op->o_req_dn = be->be_suffix[0];	op->o_req_dn = be->be_suffix[0];
op->o_req_ndn = be->be_nsuffix[0];	op->o_req_ndn = be->be_nsuffix[0];
op->ors_scope = LDAP_SCOPE_SUBTREE;	op->ors_scope = LDAP_SCOPE_SUBTREE;
syncprov_findcsn( op, FIND_MAXCSN );	ldap_pvt_thread_create( &tid, 0, syncprov_db_otask, op );
	ldap_pvt_thread_join( tid, NULL );
	} else if ( SLAP_SYNC_SHADOW( op->o_bd )) {
	/* If we're also a consumer, and we didn't find the context entry,
	* then don't generate anything, wait for our provider to send it
	* to us.
	*/
	goto out;
}	}

if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {	if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {
Line 1724 syncprov_db_open(	Line 2198 syncprov_db_open(
&si->si_ctxcsn, 0 );	&si->si_ctxcsn, 0 );
}	}

	/* If our ctxcsn is different from what was read from the root
	* entry, make sure we do a checkpoint on close
	*/
	if ( strcmp( si->si_ctxcsnbuf, ctxcsnbuf )) {
	si->si_numops++;
	}

	out:
op->o_bd->bd_info = (BackendInfo *)on;	op->o_bd->bd_info = (BackendInfo *)on;
return 0;	return 0;
}	}
Line 1739 syncprov_db_close(	Line 2221 syncprov_db_close(
syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;	syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;
int i;	int i;

	if ( slapMode & SLAP_TOOL_MODE ) {
	return 0;
	}
if ( si->si_numops ) {	if ( si->si_numops ) {
Connection conn;	Connection conn;
char opbuf[OPERATION_BUFFER_SIZE];	char opbuf[OPERATION_BUFFER_SIZE];
Line 1772 syncprov_db_init(	Line 2257 syncprov_db_init(
on->on_bi.bi_private = si;	on->on_bi.bi_private = si;
ldap_pvt_thread_mutex_init( &si->si_csn_mutex );	ldap_pvt_thread_mutex_init( &si->si_csn_mutex );
ldap_pvt_thread_mutex_init( &si->si_ops_mutex );	ldap_pvt_thread_mutex_init( &si->si_ops_mutex );
ldap_pvt_thread_rdwr_init( &si->si_mods_rwlock );	ldap_pvt_thread_mutex_init( &si->si_mods_mutex );
si->si_ctxcsn.bv_val = si->si_ctxcsnbuf;	si->si_ctxcsn.bv_val = si->si_ctxcsnbuf;

csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;	csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;
Line 1793 syncprov_db_destroy(	Line 2278 syncprov_db_destroy(
syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;	syncprov_info_t si = (syncprov_info_t )on->on_bi.bi_private;

if ( si ) {	if ( si ) {
ldap_pvt_thread_rdwr_destroy( &si->si_mods_rwlock );	ldap_pvt_thread_mutex_destroy( &si->si_mods_mutex );
ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );	ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );
ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );	ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );
ch_free( si );	ch_free( si );
Line 1886 static int syncprov_parseCtrl (	Line 2371 static int syncprov_parseCtrl (
sr = op->o_tmpcalloc( 1, sizeof(struct sync_control), op->o_tmpmemctx );	sr = op->o_tmpcalloc( 1, sizeof(struct sync_control), op->o_tmpmemctx );
sr->sr_rhint = rhint;	sr->sr_rhint = rhint;
if (!BER_BVISNULL(&cookie)) {	if (!BER_BVISNULL(&cookie)) {
ber_bvarray_add( &sr->sr_state.octet_str, &cookie );	ber_dupbv( &sr->sr_state.octet_str, &cookie );
slap_parse_sync_cookie( &sr->sr_state );	slap_parse_sync_cookie( &sr->sr_state );
}	}

Line 1919 syncprov_init()	Line 2404 syncprov_init()
SLAP_CTRL_HIDE\|SLAP_CTRL_SEARCH, NULL,	SLAP_CTRL_HIDE\|SLAP_CTRL_SEARCH, NULL,
syncprov_parseCtrl, &slap_cids.sc_LDAPsync );	syncprov_parseCtrl, &slap_cids.sc_LDAPsync );
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
fprintf( stderr, "Failed to register control %d\n", rc );	Debug( LDAP_DEBUG_ANY,
	"syncprov_init: Failed to register control %d\n", rc, 0, 0 );
return rc;	return rc;
}	}

syncprov.on_bi.bi_type = "syncprov";	syncprov.on_bi.bi_type = "syncprov";
syncprov.on_bi.bi_db_init = syncprov_db_init;	syncprov.on_bi.bi_db_init = syncprov_db_init;
syncprov.on_bi.bi_db_config = syncprov_db_config;
syncprov.on_bi.bi_db_destroy = syncprov_db_destroy;	syncprov.on_bi.bi_db_destroy = syncprov_db_destroy;
syncprov.on_bi.bi_db_open = syncprov_db_open;	syncprov.on_bi.bi_db_open = syncprov_db_open;
syncprov.on_bi.bi_db_close = syncprov_db_close;	syncprov.on_bi.bi_db_close = syncprov_db_close;
Line 1942 syncprov_init()	Line 2427 syncprov_init()
syncprov.on_bi.bi_extended = syncprov_op_extended;	syncprov.on_bi.bi_extended = syncprov_op_extended;
syncprov.on_bi.bi_operational = syncprov_operational;	syncprov.on_bi.bi_operational = syncprov_operational;

	syncprov.on_bi.bi_cf_ocs = spocs;

	rc = config_register_schema( spcfg, spocs );
	if ( rc ) return rc;

return overlay_register( &syncprov );	return overlay_register( &syncprov );
}	}

Removed from v.1.37
changed lines
	Added in v.1.88