bi->bi_op_unbind = 0;
-#if 0
+#if 0 /* DELETE ME */
bi->bi_op_abandon = bdb_abandon;
bi->bi_op_cancel = bdb_cancel;
#endif
struct berval *ndn )
{
Connection conn = { 0 };
- Operation op = { 0 };
- Opheader ohdr = { 0 };
+ char opbuf[OPERATION_BUFFER_SIZE];
+ Operation *op;
SlapReply rs = { 0 };
slap_callback cb = { NULL, monitor_filter2ndn_cb, NULL, NULL };
AttributeName anlist[ 2 ];
return -1;
}
- connection_fake_init( &conn, &op, &ohdr, &conn );
+ op = (Operation *)opbuf;
+ connection_fake_init( &conn, op, &conn );
- op.o_tag = LDAP_REQ_SEARCH;
+ op->o_tag = LDAP_REQ_SEARCH;
/* use global malloc for now */
- op.o_tmpmemctx = NULL;
- op.o_tmpmfuncs = &ch_mfuncs;
+ op->o_tmpmemctx = NULL;
+ op->o_tmpmfuncs = &ch_mfuncs;
- op.o_bd = be_monitor;
+ op->o_bd = be_monitor;
if ( base == NULL || BER_BVISNULL( base ) ) {
- ber_dupbv_x( &op.o_req_dn, &op.o_bd->be_suffix[ 0 ],
- op.o_tmpmemctx );
- ber_dupbv_x( &op.o_req_ndn, &op.o_bd->be_nsuffix[ 0 ],
- op.o_tmpmemctx );
+ ber_dupbv_x( &op->o_req_dn, &op->o_bd->be_suffix[ 0 ],
+ op->o_tmpmemctx );
+ ber_dupbv_x( &op->o_req_ndn, &op->o_bd->be_nsuffix[ 0 ],
+ op->o_tmpmemctx );
} else {
- if ( dnPrettyNormal( NULL, base, &op.o_req_dn, &op.o_req_ndn,
- op.o_tmpmemctx ) ) {
+ if ( dnPrettyNormal( NULL, base, &op->o_req_dn, &op->o_req_ndn,
+ op->o_tmpmemctx ) ) {
/* error */
}
}
- op.o_callback = &cb;
+ op->o_callback = &cb;
cb.sc_private = (void *)ndn;
- op.ors_scope = scope;
- ber_dupbv_x( &op.ors_filterstr, filter, op.o_tmpmemctx );
- op.ors_filter = str2filter_x( &op, filter->bv_val );
- op.ors_attrs = anlist;
+ op->ors_scope = scope;
+ ber_dupbv_x( &op->ors_filterstr, filter, op->o_tmpmemctx );
+ op->ors_filter = str2filter_x( op, filter->bv_val );
+ op->ors_attrs = anlist;
BER_BVSTR( &anlist[ 0 ].an_name, LDAP_NO_ATTRS );
BER_BVZERO( &anlist[ 1 ].an_name );
- op.ors_attrsonly = 0;
- op.ors_tlimit = SLAP_NO_LIMIT;
- op.ors_slimit = 1;
- op.ors_limit = NULL;
- op.ors_deref = LDAP_DEREF_NEVER;
+ op->ors_attrsonly = 0;
+ op->ors_tlimit = SLAP_NO_LIMIT;
+ op->ors_slimit = 1;
+ op->ors_limit = NULL;
+ op->ors_deref = LDAP_DEREF_NEVER;
- op.o_nocaching = 1;
- op.o_managedsait = 1;
+ op->o_nocaching = 1;
+ op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
- rc = op.o_bd->be_search( &op, &rs );
+ rc = op->o_bd->be_search( op, &rs );
- filter_free_x( &op, op.ors_filter );
- op.o_tmpfree( op.ors_filterstr.bv_val, op.o_tmpmemctx );
- op.o_tmpfree( op.o_req_dn.bv_val, op.o_tmpmemctx );
- op.o_tmpfree( op.o_req_ndn.bv_val, op.o_tmpmemctx );
+ filter_free_x( op, op->ors_filter );
+ op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
+ op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );
+ op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
if ( rc != 0 ) {
return rc;
case LDAP_SCOPE_SUBORDINATE: /* FIXME */
#endif
+#if 0 /* DELETE ME - verify ITS first */
if ( op->o_sync_mode & SLAP_SYNC_REFRESH ) {
if (op->o_bd && op->o_bd->be_search) {
rs->sr_err = op->o_bd->be_search( op, rs );
}
return rs->sr_err;
}
+#endif
op->o_callback = &cb;
rs->sr_err = gs.err = LDAP_UNWILLING_TO_PERFORM;
ber_set_option( op->o_ber, LBER_OPT_BER_MEMCTX, &memctx_null );
+#if 0 /* DELETE ME */
if ( op->o_cancel != SLAP_CANCEL_ACK &&
( op->o_sync_mode & SLAP_SYNC_PERSIST ) )
{
slap_sl_mem_detach( ctx, memctx );
-
-#if 0
} else if ( op->o_sync_slog_size != -1 ) {
slap_sl_mem_detach( ctx, memctx );
LDAP_STAILQ_REMOVE( &conn->c_ops, op, slap_op, o_next);
LDAP_STAILQ_NEXT(op, o_next) = NULL;
conn->c_n_ops_executing--;
conn->c_n_ops_completed++;
-#endif
- } else {
+ } else
+#endif
+ {
LDAP_STAILQ_REMOVE( &conn->c_ops, op, slap_op, o_next);
LDAP_STAILQ_NEXT(op, o_next) = NULL;
slap_op_free( op );
connection_fake_init(
Connection *conn,
Operation *op,
- Opheader *ohdr,
void *ctx )
{
conn->c_connid = -1;
conn->c_peer_domain = slap_empty_bv;
conn->c_peer_name = slap_empty_bv;
- op->o_hdr = ohdr;
+ memset(op, 0, OPERATION_BUFFER_SIZE);
+ op->o_hdr = (Opheader *)(op+1);
+ op->o_controls = (void **)(op->o_hdr+1);
/* set memory context */
op->o_tmpmemctx = slap_sl_mem_create(SLAP_SLAB_SIZE, SLAP_SLAB_STACK, ctx);
op->o_tmpmfuncs = &slap_sl_mfuncs;
#ifdef LDAP_CONTROL_SUBENTRIES
static SLAP_CTRL_PARSE_FN parseSubentries;
#endif
-static SLAP_CTRL_PARSE_FN parseLDAPsync;
#undef sc_mask /* avoid conflict with Irix 6.5 <sys/signal.h> */
(int)offsetof(struct slap_control_ids, sc_noOp),
SLAP_CTRL_HIDE|SLAP_CTRL_ACCESS, NULL,
parseNoOp, LDAP_SLIST_ENTRY_INITIALIZER(next) },
- { LDAP_CONTROL_SYNC,
- (int)offsetof(struct slap_control_ids, sc_LDAPsync),
- SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,
- parseLDAPsync, LDAP_SLIST_ENTRY_INITIALIZER(next) },
#ifdef LDAP_CONTROL_MODIFY_INCREMENT
{ LDAP_CONTROL_MODIFY_INCREMENT,
(int)offsetof(struct slap_control_ids, sc_modifyIncrement),
return LDAP_PROTOCOL_ERROR;
}
+#if 0 /* DELETE ME */
if ( op->o_sync != SLAP_CONTROL_NONE ) {
rs->sr_text = "paged results control specified with sync control";
return LDAP_PROTOCOL_ERROR;
}
+#endif
if ( BER_BVISEMPTY( &ctrl->ldctl_value ) ) {
rs->sr_text = "paged results control value is empty (or absent)";
}
#endif
-static int parseLDAPsync (
- Operation *op,
- SlapReply *rs,
- LDAPControl *ctrl )
-{
- ber_tag_t tag;
- BerElement *ber;
- ber_int_t mode;
- ber_len_t len;
- struct slap_session_entry *se;
- struct berval cookie = BER_BVNULL;
- syncrepl_state *sr;
- int rhint = 0;
-
- if ( op->o_sync != SLAP_CONTROL_NONE ) {
- rs->sr_text = "Sync control specified multiple times";
- return LDAP_PROTOCOL_ERROR;
- }
-
- if ( op->o_pagedresults != SLAP_CONTROL_NONE ) {
- rs->sr_text = "Sync control specified with pagedResults control";
- return LDAP_PROTOCOL_ERROR;
- }
-
-
- if ( ctrl->ldctl_value.bv_len == 0 ) {
- rs->sr_text = "Sync control value is empty (or absent)";
- return LDAP_PROTOCOL_ERROR;
- }
-
- /* Parse the control value
- * syncRequestValue ::= SEQUENCE {
- * mode ENUMERATED {
- * -- 0 unused
- * refreshOnly (1),
- * -- 2 reserved
- * refreshAndPersist (3)
- * },
- * cookie syncCookie OPTIONAL
- * }
- */
-
- ber = ber_init( &ctrl->ldctl_value );
- if( ber == NULL ) {
- rs->sr_text = "internal error";
- return LDAP_OTHER;
- }
-
- if ( (tag = ber_scanf( ber, "{i" /*}*/, &mode )) == LBER_ERROR ) {
- rs->sr_text = "Sync control : mode decoding error";
- return LDAP_PROTOCOL_ERROR;
- }
-
- switch( mode ) {
- case LDAP_SYNC_REFRESH_ONLY:
- mode = SLAP_SYNC_REFRESH;
- break;
- case LDAP_SYNC_REFRESH_AND_PERSIST:
- mode = SLAP_SYNC_REFRESH_AND_PERSIST;
- break;
- default:
- rs->sr_text = "Sync control : unknown update mode";
- return LDAP_PROTOCOL_ERROR;
- }
-
- tag = ber_peek_tag( ber, &len );
-
- if ( tag == LDAP_TAG_SYNC_COOKIE ) {
- if (( ber_scanf( ber, /*{*/ "o", &cookie )) == LBER_ERROR ) {
- rs->sr_text = "Sync control : cookie decoding error";
- return LDAP_PROTOCOL_ERROR;
- }
- }
- if ( tag == LDAP_TAG_RELOAD_HINT ) {
- if (( ber_scanf( ber, /*{*/ "b", &rhint )) == LBER_ERROR ) {
- rs->sr_text = "Sync control : rhint decoding error";
- return LDAP_PROTOCOL_ERROR;
- }
- }
- if (( ber_scanf( ber, /*{*/ "}")) == LBER_ERROR ) {
- rs->sr_text = "Sync control : decoding error";
- return LDAP_PROTOCOL_ERROR;
- }
- sr = op->o_tmpcalloc( 1, sizeof(struct syncrepl_state), op->o_tmpmemctx );
- sr->sr_rhint = rhint;
- if (!BER_BVISNULL(&cookie)) {
- ber_bvarray_add( &sr->sr_state.octet_str, &cookie );
- slap_parse_sync_cookie( &sr->sr_state );
- }
-
- op->o_controls[slap_cids.sc_LDAPsync] = sr;
-
- (void) ber_free( ber, 1 );
-
- op->o_sync = ctrl->ldctl_iscritical
- ? SLAP_CONTROL_CRITICAL
- : SLAP_CONTROL_NONCRITICAL;
-
- op->o_sync_mode |= mode; /* o_sync_mode shares o_sync */
-
- return LDAP_SUCCESS;
-}
LDAP_STAILQ_HEAD_INITIALIZER( slap_sync_cookie );
#endif
-int
-slap_build_sync_state_ctrl(
- Operation *op,
- SlapReply *rs,
- Entry *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, 0, LBER_USE_DER );
- ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );
-
- ctrls[num_ctrls] = slap_sl_malloc ( sizeof ( LDAPControl ), op->o_tmpmemctx );
-
- for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
- AttributeDescription *desc = a->a_desc;
- if ( desc == slap_schema.si_ad_entryUUID ) {
- entryuuid_bv = a->a_nvals[0];
- break;
- }
- }
-
- 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;
-}
-
-int
-slap_build_sync_done_ctrl(
- Operation *op,
- SlapReply *rs,
- LDAPControl **ctrls,
- int num_ctrls,
- int send_cookie,
- struct berval *cookie,
- int refreshDeletes )
-{
- int ret;
- BerElementBuffer berbuf;
- BerElement *ber = (BerElement *)&berbuf;
-
- 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 ) );
-
- ber_printf( ber, "{" );
- if ( send_cookie && cookie ) {
- ber_printf( ber, "O", cookie );
- }
- if ( refreshDeletes == LDAP_SYNC_REFRESH_DELETES ) {
- ber_printf( ber, "b", refreshDeletes );
- }
- ber_printf( ber, "N}" );
-
- ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_DONE;
- 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_done_ctrl: ber_flatten2 failed\n",
- 0, 0, 0 );
- send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
- return ret;
- }
-
- return LDAP_SUCCESS;
-}
-
-
-int
-slap_build_sync_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;
-}
-
-int
-slap_send_syncinfo(
- Operation *op,
- SlapReply *rs,
- int type,
- struct berval *cookie,
- int refreshDone,
- BerVarray syncUUIDs,
- int refreshDeletes )
-{
- BerElementBuffer berbuf;
- BerElement *ber = (BerElement *)&berbuf;
- struct berval rspdata;
-
- int ret;
-
- ber_init2( ber, NULL, LBER_USE_DER );
- ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );
-
- if ( type ) {
- switch ( type ) {
- case LDAP_TAG_SYNC_NEW_COOKIE:
- ber_printf( ber, "tO", type, cookie );
- break;
- case LDAP_TAG_SYNC_REFRESH_DELETE:
- case LDAP_TAG_SYNC_REFRESH_PRESENT:
- ber_printf( ber, "t{", type );
- if ( cookie ) {
- ber_printf( ber, "O", cookie );
- }
- if ( refreshDone == 0 ) {
- ber_printf( ber, "b", refreshDone );
- }
- ber_printf( ber, "N}" );
- break;
- case LDAP_TAG_SYNC_ID_SET:
- ber_printf( ber, "t{", type );
- if ( cookie ) {
- ber_printf( ber, "O", cookie );
- }
- if ( refreshDeletes == 1 ) {
- ber_printf( ber, "b", refreshDeletes );
- }
- ber_printf( ber, "[W]", syncUUIDs );
- ber_printf( ber, "N}" );
- break;
- default:
- Debug( LDAP_DEBUG_TRACE,
- "slap_send_syncinfo: invalid syncinfo type (%d)\n",
- type, 0, 0 );
- return LDAP_OTHER;
- }
- }
-
- ret = ber_flatten2( ber, &rspdata, 0 );
-
- if ( ret < 0 ) {
- Debug( LDAP_DEBUG_TRACE,
- "slap_send_syncinfo: ber_flatten2 failed\n",
- 0, 0, 0 );
- send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
- return ret;
- }
-
- rs->sr_rspdata = &rspdata;
- send_ldap_intermediate( op, rs );
- rs->sr_rspdata = NULL;
- ber_free_buf( ber );
-
- return LDAP_SUCCESS;
-}
-
void
slap_compose_sync_cookie(
Operation *op,
op->o_hdr = (Opheader *)(op+1);
op->o_controls = (void **)(op->o_hdr+1);
-#if 0
+#if 0 /* DELETE ME */
slap_sync_cookie_free( &op->o_sync_state, 0 );
if ( op->o_sync_csn.bv_val != NULL ) {
ch_free( op->o_sync_csn.bv_val );
op->o_opid = id;
op->o_res_ber = NULL;
-#if 0
+#if 0 /* DELETE ME */
op->o_sync_state.sid = -1;
op->o_sync_slog_size = -1;
op->o_sync_state.rid = -1;
slap_overinst *on = rtask->arg;
cache_manager *cm = on->on_bi.bi_private;
query_manager *qm = cm->qm;
- Operation op = {0};
- Opheader ohdr = {0};
Connection conn = {0};
+ char opbuf[OPERATION_BUFFER_SIZE];
+ Operation *op;
SlapReply rs = {REP_RESULT};
CachedQuery* query, *query_prev;
int i, return_val, pause = 1;
QueryTemplate* templ;
- connection_fake_init( &conn, &op, &ohdr, ctx );
+ op = (Operation *)opbuf;
+ connection_fake_init( &conn, op, ctx );
- op.o_bd = &cm->db;
- op.o_dn = cm->db.be_rootdn;
- op.o_ndn = cm->db.be_rootndn;
+ op->o_bd = &cm->db;
+ op->o_dn = cm->db.be_rootdn;
+ op->o_ndn = cm->db.be_rootndn;
cm->cc_arg = arg;
templ = qm->templates + i;
query = templ->query_last;
if ( query ) pause = 0;
- op.o_time = slap_get_time();
+ op->o_time = slap_get_time();
ldap_pvt_thread_mutex_lock(&cm->remove_mutex);
- while (query && (query->expiry_time < op.o_time)) {
+ while (query && (query->expiry_time < op->o_time)) {
ldap_pvt_thread_mutex_lock(&qm->lru_mutex);
remove_query(qm, query);
ldap_pvt_thread_mutex_unlock(&qm->lru_mutex);
Debug( LDAP_DEBUG_ANY, "Unlock CR index = %d\n",
i, 0, 0 );
ldap_pvt_thread_rdwr_wunlock(&templ->t_rwlock);
- return_val = remove_query_data(&op, &rs, &query->q_uuid);
+ return_val = remove_query_data(op, &rs, &query->q_uuid);
Debug( LDAP_DEBUG_ANY, "STALE QUERY REMOVED, SIZE=%d\n",
return_val, 0, 0 );
ldap_pvt_thread_mutex_lock(&cm->cache_mutex);
static int sync_cid;
+/* A received sync control */
+typedef struct sync_control {
+ struct sync_cookie sr_state;
+ int sr_rhint;
+} sync_control;
+
+/* o_sync_mode uses data bits of o_sync */
+#define o_sync o_ctrlflag[sync_cid]
+#define o_sync_mode o_ctrlflag[sync_cid]
+
+#define SLAP_SYNC_NONE (LDAP_SYNC_NONE<<SLAP_CONTROL_SHIFT)
+#define SLAP_SYNC_REFRESH (LDAP_SYNC_REFRESH_ONLY<<SLAP_CONTROL_SHIFT)
+#define SLAP_SYNC_PERSIST (LDAP_SYNC_RESERVED<<SLAP_CONTROL_SHIFT)
+#define SLAP_SYNC_REFRESH_AND_PERSIST (LDAP_SYNC_REFRESH_AND_PERSIST<<SLAP_CONTROL_SHIFT)
+
#define PS_IS_REFRESHING 0x01
/* Record of which searches matched at premodify step */
static AttributeName csn_anlist[2];
static AttributeName uuid_anlist[2];
+static int
+syncprov_state_ctrl(
+ Operation *op,
+ SlapReply *rs,
+ Entry *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, 0, LBER_USE_DER );
+ ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );
+
+ ctrls[num_ctrls] = slap_sl_malloc ( sizeof ( LDAPControl ), op->o_tmpmemctx );
+
+ for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
+ AttributeDescription *desc = a->a_desc;
+ if ( desc == slap_schema.si_ad_entryUUID ) {
+ entryuuid_bv = a->a_nvals[0];
+ break;
+ }
+ }
+
+ 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;
+}
+
+static int
+syncprov_done_ctrl(
+ Operation *op,
+ SlapReply *rs,
+ LDAPControl **ctrls,
+ int num_ctrls,
+ int send_cookie,
+ struct berval *cookie,
+ int refreshDeletes )
+{
+ int ret;
+ BerElementBuffer berbuf;
+ BerElement *ber = (BerElement *)&berbuf;
+
+ 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 ) );
+
+ ber_printf( ber, "{" );
+ if ( send_cookie && cookie ) {
+ ber_printf( ber, "O", cookie );
+ }
+ if ( refreshDeletes == LDAP_SYNC_REFRESH_DELETES ) {
+ ber_printf( ber, "b", refreshDeletes );
+ }
+ ber_printf( ber, "N}" );
+
+ ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_DONE;
+ 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,
+ "syncprov_done_ctrl: ber_flatten2 failed\n",
+ 0, 0, 0 );
+ send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
+ return ret;
+ }
+
+ return LDAP_SUCCESS;
+}
+
+
+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;
+}
+
+int
+syncprov_sendinfo(
+ Operation *op,
+ SlapReply *rs,
+ int type,
+ struct berval *cookie,
+ int refreshDone,
+ BerVarray syncUUIDs,
+ int refreshDeletes )
+{
+ BerElementBuffer berbuf;
+ BerElement *ber = (BerElement *)&berbuf;
+ struct berval rspdata;
+
+ int ret;
+
+ ber_init2( ber, NULL, LBER_USE_DER );
+ ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );
+
+ if ( type ) {
+ switch ( type ) {
+ case LDAP_TAG_SYNC_NEW_COOKIE:
+ ber_printf( ber, "tO", type, cookie );
+ break;
+ case LDAP_TAG_SYNC_REFRESH_DELETE:
+ case LDAP_TAG_SYNC_REFRESH_PRESENT:
+ ber_printf( ber, "t{", type );
+ if ( cookie ) {
+ ber_printf( ber, "O", cookie );
+ }
+ if ( refreshDone == 0 ) {
+ ber_printf( ber, "b", refreshDone );
+ }
+ ber_printf( ber, "N}" );
+ break;
+ case LDAP_TAG_SYNC_ID_SET:
+ ber_printf( ber, "t{", type );
+ if ( cookie ) {
+ ber_printf( ber, "O", cookie );
+ }
+ if ( refreshDeletes == 1 ) {
+ ber_printf( ber, "b", refreshDeletes );
+ }
+ ber_printf( ber, "[W]", syncUUIDs );
+ ber_printf( ber, "N}" );
+ break;
+ default:
+ Debug( LDAP_DEBUG_TRACE,
+ "syncprov_sendinfo: invalid syncinfo type (%d)\n",
+ type, 0, 0 );
+ return LDAP_OTHER;
+ }
+ }
+
+ ret = ber_flatten2( ber, &rspdata, 0 );
+
+ if ( ret < 0 ) {
+ Debug( LDAP_DEBUG_TRACE,
+ "syncprov_sendinfo: ber_flatten2 failed\n",
+ 0, 0, 0 );
+ send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
+ return ret;
+ }
+
+ rs->sr_rspdata = &rspdata;
+ send_ldap_intermediate( op, rs );
+ rs->sr_rspdata = NULL;
+ ber_free_buf( ber );
+
+ return LDAP_SUCCESS;
+}
/* syncprov_findbase:
* finds the true DN of the base of a search (with alias dereferencing) and
* checks to make sure the base entry doesn't get replaced with a different
if ( sc->sc_private ) {
int i;
fcsn_cookie *fc = sc->sc_private;
- syncrepl_state *srs = op->o_controls[sync_cid];
+ sync_control *srs = op->o_controls[sync_cid];
Attribute *a = attr_find(rs->sr_entry->e_attrs,
slap_schema.si_ad_entryCSN );
i = ber_bvcmp( &a->a_vals[0], srs->sr_state.ctxcsn );
ret = LDAP_SUCCESS;
if ( pc->num == SLAP_SYNCUUID_SET_SIZE ) {
rs->sr_rspoid = LDAP_SYNC_INFO;
- ret = slap_send_syncinfo( op, rs, LDAP_TAG_SYNC_ID_SET, 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;
ret = rs->sr_err;
if ( pc->num ) {
rs->sr_rspoid = LDAP_SYNC_INFO;
- ret = slap_send_syncinfo( op, rs, LDAP_TAG_SYNC_ID_SET, 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;
fcsn_cookie fcookie;
fpres_cookie pcookie;
int locked = 0;
- syncrepl_state *srs = op->o_controls[sync_cid];
+ sync_control *srs = op->o_controls[sync_cid];
if ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {
return LDAP_OTHER;
e_uuid.e_attrs = &a_uuid;
a_uuid.a_desc = slap_schema.si_ad_entryUUID;
a_uuid.a_nvals = &opc->suuid;
- rs.sr_err = slap_build_sync_state_ctrl( &sop, &rs, &e_uuid,
+ rs.sr_err = syncprov_state_ctrl( &sop, &rs, &e_uuid,
mode, ctrls, 0, 1, &cookie );
rs.sr_entry = e;
op2->ors_attrs[i].an_name.bv_val = ptr;
ptr = lutil_strcopy( ptr, op->ors_attrs[i].an_name.bv_val ) + 1;
}
+ op2->ors_attrs[i].an_name.bv_val = NULL;
+ op2->ors_attrs[i].an_name.bv_len = 0;
} else {
ptr = (char *)(op2->o_hdr + 1);
}
searchstate *ss = op->o_callback->sc_private;
slap_overinst *on = ss->ss_on;
syncprov_info_t *si = on->on_bi.bi_private;
- syncrepl_state *srs = op->o_controls[sync_cid];
+ sync_control *srs = op->o_controls[sync_cid];
if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {
int i;
rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,
op->o_tmpmemctx );
rs->sr_ctrls[1] = NULL;
- rs->sr_err = slap_build_sync_state_ctrl( op, rs, rs->sr_entry,
+ rs->sr_err = syncprov_state_ctrl( op, rs, rs->sr_entry,
LDAP_SYNC_ADD, rs->sr_ctrls, 0, 0, NULL );
} else if ( rs->sr_type == REP_RESULT && rs->sr_err == LDAP_SUCCESS ) {
struct berval cookie;
rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,
op->o_tmpmemctx );
rs->sr_ctrls[1] = NULL;
- rs->sr_err = slap_build_sync_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 );
} else {
int locked = 0;
/* It's RefreshAndPersist, transition to Persist phase */
rs->sr_rspoid = LDAP_SYNC_INFO;
- slap_send_syncinfo( op, rs, rs->sr_nentries ?
+ syncprov_sendinfo( op, rs, rs->sr_nentries ?
LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,
&cookie, 1, NULL, 0 );
/* Flush any queued persist messages */
Filter *fand, *fava;
syncops *sop = NULL;
searchstate *ss;
- syncrepl_state *srs;
+ sync_control *srs;
if ( !(op->o_sync_mode & SLAP_SYNC_REFRESH) ) return SLAP_CB_CONTINUE;
ctrls[0] = NULL;
ctrls[1] = NULL;
- slap_build_sync_done_ctrl( op, rs, ctrls, 0, 0,
+ syncprov_done_ctrl( op, rs, ctrls, 0, 0,
NULL, LDAP_SYNC_REFRESH_DELETES );
rs->sr_ctrls = ctrls;
rs->sr_err = LDAP_SUCCESS;
uuid_anlist[0].an_desc = slap_schema.si_ad_entryUUID;
uuid_anlist[0].an_name = slap_schema.si_ad_entryUUID->ad_cname;
- sync_cid = slap_cids.sc_LDAPsync;
-
return 0;
}
return 0;
}
+static int syncprov_parseCtrl (
+ Operation *op,
+ SlapReply *rs,
+ LDAPControl *ctrl )
+{
+ ber_tag_t tag;
+ BerElement *ber;
+ ber_int_t mode;
+ ber_len_t len;
+ struct berval cookie = BER_BVNULL;
+ sync_control *sr;
+ int rhint = 0;
+
+ if ( op->o_sync != SLAP_CONTROL_NONE ) {
+ rs->sr_text = "Sync control specified multiple times";
+ return LDAP_PROTOCOL_ERROR;
+ }
+
+ if ( op->o_pagedresults != SLAP_CONTROL_NONE ) {
+ rs->sr_text = "Sync control specified with pagedResults control";
+ return LDAP_PROTOCOL_ERROR;
+ }
+
+ if ( ctrl->ldctl_value.bv_len == 0 ) {
+ rs->sr_text = "Sync control value is empty (or absent)";
+ return LDAP_PROTOCOL_ERROR;
+ }
+
+ /* Parse the control value
+ * syncRequestValue ::= SEQUENCE {
+ * mode ENUMERATED {
+ * -- 0 unused
+ * refreshOnly (1),
+ * -- 2 reserved
+ * refreshAndPersist (3)
+ * },
+ * cookie syncCookie OPTIONAL
+ * }
+ */
+
+ ber = ber_init( &ctrl->ldctl_value );
+ if( ber == NULL ) {
+ rs->sr_text = "internal error";
+ return LDAP_OTHER;
+ }
+
+ if ( (tag = ber_scanf( ber, "{i" /*}*/, &mode )) == LBER_ERROR ) {
+ rs->sr_text = "Sync control : mode decoding error";
+ return LDAP_PROTOCOL_ERROR;
+ }
+
+ switch( mode ) {
+ case LDAP_SYNC_REFRESH_ONLY:
+ mode = SLAP_SYNC_REFRESH;
+ break;
+ case LDAP_SYNC_REFRESH_AND_PERSIST:
+ mode = SLAP_SYNC_REFRESH_AND_PERSIST;
+ break;
+ default:
+ rs->sr_text = "Sync control : unknown update mode";
+ return LDAP_PROTOCOL_ERROR;
+ }
+
+ tag = ber_peek_tag( ber, &len );
+
+ if ( tag == LDAP_TAG_SYNC_COOKIE ) {
+ if (( ber_scanf( ber, /*{*/ "o", &cookie )) == LBER_ERROR ) {
+ rs->sr_text = "Sync control : cookie decoding error";
+ return LDAP_PROTOCOL_ERROR;
+ }
+ }
+ if ( tag == LDAP_TAG_RELOAD_HINT ) {
+ if (( ber_scanf( ber, /*{*/ "b", &rhint )) == LBER_ERROR ) {
+ rs->sr_text = "Sync control : rhint decoding error";
+ return LDAP_PROTOCOL_ERROR;
+ }
+ }
+ if (( ber_scanf( ber, /*{*/ "}")) == LBER_ERROR ) {
+ rs->sr_text = "Sync control : decoding error";
+ return LDAP_PROTOCOL_ERROR;
+ }
+ sr = op->o_tmpcalloc( 1, sizeof(struct sync_control), op->o_tmpmemctx );
+ sr->sr_rhint = rhint;
+ if (!BER_BVISNULL(&cookie)) {
+ ber_bvarray_add( &sr->sr_state.octet_str, &cookie );
+ slap_parse_sync_cookie( &sr->sr_state );
+ }
+
+ op->o_controls[sync_cid] = sr;
+
+ (void) ber_free( ber, 1 );
+
+ op->o_sync = ctrl->ldctl_iscritical
+ ? SLAP_CONTROL_CRITICAL
+ : SLAP_CONTROL_NONCRITICAL;
+
+ op->o_sync_mode |= mode; /* o_sync_mode shares o_sync */
+
+ return LDAP_SUCCESS;
+}
+
/* This overlay is set up for dynamic loading via moduleload. For static
* configuration, you'll need to arrange for the slap_overinst to be
* initialized and registered by some other function inside slapd.
int
syncprov_init()
{
+ int rc;
+
+ rc = register_supported_control( LDAP_CONTROL_SYNC,
+ SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,
+ syncprov_parseCtrl, &sync_cid );
+ if ( rc != LDAP_SUCCESS ) {
+ fprintf( stderr, "Failed to register control %d\n", rc );
+ return rc;
+ }
+
syncprov.on_bi.bi_type = "syncprov";
syncprov.on_bi.bi_db_init = syncprov_db_init;
syncprov.on_bi.bi_db_config = syncprov_db_config;
LDAP_SLAPD_F (void) connection_fake_init LDAP_P((
Connection *conn,
Operation *op,
- Opheader *ohdr,
void *threadctx ));
LDAP_SLAPD_F (void) connection_assign_nextid LDAP_P((Connection *));
/*
* ldapsync.c
*/
-LDAP_SLAPD_F (int) slap_build_sync_state_ctrl LDAP_P((
- Operation *, SlapReply *, Entry *, int,
- LDAPControl **, int, int, struct berval * ));
-LDAP_SLAPD_F (int) slap_build_sync_done_ctrl LDAP_P((
- Operation *, SlapReply *, LDAPControl **,
- int, int, struct berval *, int ));
-LDAP_SLAPD_F (int) slap_build_sync_state_ctrl_from_slog LDAP_P((
- Operation *, SlapReply *, struct slog_entry *, int,
- LDAPControl **, int, int, struct berval * ));
-LDAP_SLAPD_F (int) slap_send_syncinfo LDAP_P((
- Operation *, SlapReply *, int,
- struct berval *, int, BerVarray, int ));
LDAP_SLAPD_F (void) slap_compose_sync_cookie LDAP_P((
Operation *, struct berval *, struct berval *, int, int ));
LDAP_SLAPD_F (void) slap_sync_cookie_free LDAP_P((
rs->sr_err = frontendDB->be_search( op, rs );
return_results:;
+#if 0 /* DELETE ME */
if ( ( op->o_sync_mode & SLAP_SYNC_PERSIST ) ) {
return rs->sr_err;
}
-#if 0
if ( ( op->o_sync_slog_size != -1 ) ) {
return rs->sr_err;
}
* if we don't hold it.
*/
+#if 0 /* DELETE ME */
/* Sync control overrides manageDSAit */
if ( manageDSAit != SLAP_CONTROL_NONE ) {
} else {
be_manageDSAit = manageDSAit;
}
+#else
+ be_manageDSAit = manageDSAit;
+#endif
op->o_bd = select_backend( &op->o_req_ndn, be_manageDSAit, 1 );
if ( op->o_bd == NULL ) {
#include "slap.h"
#include "lutil_ldap.h"
-#if 0
+#if 0 /* DELETE ME -- needs to be reimplemented with syncprov overlay */
int
slap_send_session_log(
Operation *op,
int sc_treeDelete;
int sc_searchOptions;
int sc_subentries;
- int sc_LDAPsync;
};
-typedef struct syncrepl_state {
- struct sync_cookie sr_state;
- int sr_rhint;
-} syncrepl_state;
/*
* represents an operation pending from an ldap client
*/
#define get_pagedresults(op) ((int)(op)->o_pagedresults)
-#define o_sync o_ctrlflag[slap_cids.sc_LDAPsync]
- /* o_sync_mode uses data bits of o_sync */
-#define o_sync_mode o_ctrlflag[slap_cids.sc_LDAPsync]
-
-#define SLAP_SYNC_NONE (LDAP_SYNC_NONE<<SLAP_CONTROL_SHIFT)
-#define SLAP_SYNC_REFRESH (LDAP_SYNC_REFRESH_ONLY<<SLAP_CONTROL_SHIFT)
-#define SLAP_SYNC_PERSIST (LDAP_SYNC_RESERVED<<SLAP_CONTROL_SHIFT)
-#define SLAP_SYNC_REFRESH_AND_PERSIST (LDAP_SYNC_REFRESH_AND_PERSIST<<SLAP_CONTROL_SHIFT)
#ifdef BDB_PSEARCH
struct sync_cookie o_sync_state;
int o_sync_rhint;
int o_delete_glue_parent;
} Operation;
+#define OPERATION_BUFFER_SIZE (sizeof(Operation)+sizeof(Opheader)+SLAP_MAX_CIDS*sizeof(void *))
#define send_ldap_error( op, rs, err, text ) do { \
(rs)->sr_err = err; (rs)->sr_text = text; \
int rc = EXIT_SUCCESS;
const char *progname = "slapacl";
Connection conn = {0};
- Operation op = {0};
- Opheader ohdr = {0};
+ char opbuf[OPERATION_BUFFER_SIZE];
+ Operation *op;
Entry e = { 0 };
char *attr = NULL;
argv = &argv[ optind ];
argc -= optind;
- connection_fake_init( &conn, &op, &ohdr, &conn );
+ op = (Operation *)opbuf;
+ connection_fake_init( &conn, op, &conn );
if ( !BER_BVISNULL( &authcID ) ) {
- rc = slap_sasl_getdn( &conn, &op, &authcID, NULL,
+ rc = slap_sasl_getdn( &conn, op, &authcID, NULL,
&authcDN, SLAP_GETDN_AUTHCID );
if ( rc != LDAP_SUCCESS ) {
fprintf( stderr, "ID: <%s> check failed %d (%s)\n",
goto destroy;
}
- op.o_bd = be;
+ op->o_bd = be;
if ( !BER_BVISNULL( &authcDN ) ) {
- op.o_dn = authcDN;
- op.o_ndn = authcDN;
+ op->o_dn = authcDN;
+ op->o_ndn = authcDN;
}
if ( argc == 0 ) {
break;
}
- rc = access_allowed_mask( &op, &e, desc, &val, access,
+ rc = access_allowed_mask( op, &e, desc, &val, access,
NULL, &mask );
if ( accessstr ) {
int rc = EXIT_SUCCESS;
const char *progname = "slapauth";
Connection conn = {0};
- Operation op = {0};
- Opheader ohdr = {0};
+ char opbuf[OPERATION_BUFFER_SIZE];
+ Operation *op;
slap_tool_init( progname, SLAPAUTH, argc, argv );
argv = &argv[ optind ];
argc -= optind;
- connection_fake_init( &conn, &op, &ohdr, &conn );
+ op = (Operation *)opbuf;
+ connection_fake_init( &conn, op, &conn );
if ( !BER_BVISNULL( &authzID ) ) {
struct berval authzdn;
- rc = slap_sasl_getdn( &conn, &op, &authzID, NULL, &authzdn,
+ rc = slap_sasl_getdn( &conn, op, &authzID, NULL, &authzdn,
SLAP_GETDN_AUTHZID );
if ( rc != LDAP_SUCCESS ) {
fprintf( stderr, "authzID: <%s> check failed %d (%s)\n",
if ( !BER_BVISNULL( &authcID ) ) {
if ( !BER_BVISNULL( &authzID ) || argc == 0 ) {
- rc = do_check( &conn, &op, &authcID );
+ rc = do_check( &conn, op, &authcID );
goto destroy;
}
ber_str2bv( argv[ 0 ], 0, 0, &authzID );
- rc = slap_sasl_getdn( &conn, &op, &authzID, NULL, &authzdn,
+ rc = slap_sasl_getdn( &conn, op, &authzID, NULL, &authzdn,
SLAP_GETDN_AUTHZID );
if ( rc != LDAP_SUCCESS ) {
fprintf( stderr, "authzID: <%s> check failed %d (%s)\n",
authzID = authzdn;
- rc = do_check( &conn, &op, &authcID );
+ rc = do_check( &conn, op, &authcID );
- op.o_tmpfree( authzID.bv_val, op.o_tmpmemctx );
+ op->o_tmpfree( authzID.bv_val, op->o_tmpmemctx );
BER_BVZERO( &authzID );
if ( rc && !continuemode ) {
ber_str2bv( argv[ 0 ], 0, 0, &id );
- rc = do_check( &conn, &op, &id );
+ rc = do_check( &conn, op, &id );
if ( rc && !continuemode ) {
goto destroy;
destroy:;
if ( !BER_BVISNULL( &authzID ) ) {
- op.o_tmpfree( authzID.bv_val, op.o_tmpmemctx );
+ op->o_tmpfree( authzID.bv_val, op->o_tmpmemctx );
}
slap_tool_destroy();
struct re_s* rtask = arg;
syncinfo_t *si = ( syncinfo_t * ) rtask->arg;
Connection conn = {0};
- Operation op = {0};
- Opheader ohdr = {0};
+ char opbuf[OPERATION_BUFFER_SIZE];
+ Operation *op;
int rc = LDAP_SUCCESS;
int first = 0;
int dostop = 0;
return NULL;
}
- connection_fake_init( &conn, &op, &ohdr, ctx );
+ op = (Operation *)opbuf;
+ connection_fake_init( &conn, op, ctx );
/* use global malloc for now */
- op.o_tmpmemctx = NULL;
- op.o_tmpmfuncs = &ch_mfuncs;
+ op->o_tmpmemctx = NULL;
+ op->o_tmpmfuncs = &ch_mfuncs;
- op.o_dn = si->si_updatedn;
- op.o_ndn = si->si_updatedn;
- op.o_managedsait = SLAP_CONTROL_NONCRITICAL;
- op.o_bd = be = si->si_be;
+ op->o_dn = si->si_updatedn;
+ op->o_ndn = si->si_updatedn;
+ op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
+ op->o_bd = be = si->si_be;
/* Establish session, do search */
if ( !si->si_ld ) {
first = 1;
si->si_refreshDelete = 0;
si->si_refreshPresent = 0;
- rc = do_syncrep1( &op, si );
+ rc = do_syncrep1( op, si );
}
/* Process results */
if ( rc == LDAP_SUCCESS ) {
ldap_get_option( si->si_ld, LDAP_OPT_DESC, &s );
- rc = do_syncrep2( &op, si );
+ rc = do_syncrep2( op, si );
if ( abs(si->si_type) == LDAP_SYNC_REFRESH_AND_PERSIST ) {
/* If we succeeded, enable the connection for further listening.
if ( rs_search.sr_err == LDAP_SUCCESS &&
!BER_BVISNULL( &si->si_syncUUID_ndn ))
{
-#if 0
+#if 0 /* DELETE ME -- and fix this to do realy Modifies */
char *subseq_ptr;
if ( syncstate != LDAP_SYNC_DELETE ) {
op->o_req_dn = org_req_dn;
op->o_req_ndn = org_req_ndn;
op->o_delete_glue_parent = 0;
-
-#if 0
- op->o_no_psearch = 0;
-#endif
}
switch ( syncstate ) {
projects / openldap / commitdiff