+/* syncrepl.c -- Replication Engine which uses the LDAP Sync protocol */
/* $OpenLDAP$ */
-/*
- * Replication Engine which uses the LDAP Sync protocol
- */
-/*
- * Copyright 2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
- */
-/* Copyright (c) 2003 by International Business Machines, Inc.
- *
- * International Business Machines, Inc. (hereinafter called IBM) grants
- * permission under its copyrights to use, copy, modify, and distribute this
- * Software with or without fee, provided that the above copyright notice and
- * all paragraphs of this notice appear in all copies, and that the name of IBM
- * not be used in connection with the marketing of any product incorporating
- * the Software or modifications thereof, without specific, written prior
- * permission.
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
- * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
- * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
- */
-/* Modified by Howard Chu
+ * Copyright 2003-2004 The OpenLDAP Foundation.
+ * Portions Copyright 2003 by IBM Corporation.
+ * Portions Copyright 2003 by Howard Chu, Symas Corporation.
+ * All rights reserved.
*
- * Copyright (c) 2003 by Howard Chu, Symas Corporation
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
*
- * Modifications provided under the terms of the OpenLDAP public license.
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
*/
#include "portable.h"
return rc;
}
-static const Listener dummy_list = { {0, ""}, {0, ""} };
-
static int
do_syncrep1(
Operation *op,
syncinfo_t *si )
{
int rc;
+ int cmdline_cookie_found = 0;
char syncrepl_cbuf[sizeof(CN_STR SYNCREPL_STR)];
struct berval syncrepl_cn_bv;
+ struct sync_cookie *sc = NULL;
struct sync_cookie syncCookie = { NULL, -1, NULL };
+ struct berval *psub;
+
+ psub = &si->si_be->be_nsuffix[0];
/* Init connection to master */
/* get syncrepl cookie of shadow replica from subentry */
- assert( si->si_id < 1000 );
+ assert( si->si_rid < 1000 );
syncrepl_cn_bv.bv_val = syncrepl_cbuf;
syncrepl_cn_bv.bv_len = snprintf(syncrepl_cbuf, sizeof(syncrepl_cbuf),
- CN_STR "syncrepl%d", si->si_id );
- build_new_dn( &op->o_req_ndn, &si->si_base, &syncrepl_cn_bv,
- op->o_tmpmemctx );
+ CN_STR "syncrepl%ld", si->si_rid );
+ build_new_dn( &op->o_req_ndn, psub, &syncrepl_cn_bv, op->o_tmpmemctx );
op->o_req_dn = op->o_req_ndn;
- if ( slap_sync_cookie != NULL ) {
- /* cookie is supplied in the command line */
+ LDAP_STAILQ_FOREACH( sc, &slap_sync_cookie, sc_next ) {
+ if ( si->si_rid == sc->rid ) {
+ cmdline_cookie_found = 1;
+ break;
+ }
+ }
+ if ( cmdline_cookie_found ) {
+ /* cookie is supplied in the command line */
BerVarray cookie = NULL;
struct berval cookie_bv;
+ LDAP_STAILQ_REMOVE( &slap_sync_cookie, sc, sync_cookie, sc_next );
slap_sync_cookie_free( &si->si_syncCookie, 0 );
- slap_parse_sync_cookie( slap_sync_cookie );
/* read stored cookie if it exists */
backend_attribute( op, NULL, &op->o_req_ndn,
if ( !cookie ) {
/* no stored cookie */
- if ( slap_sync_cookie->ctxcsn == NULL ||
- slap_sync_cookie->ctxcsn->bv_val == NULL ) {
- /* if slap_sync_cookie does not have ctxcsn component */
- /* set it to an initial value */
- slap_init_sync_cookie_ctxcsn( slap_sync_cookie );
+ if ( sc->ctxcsn == NULL ||
+ sc->ctxcsn->bv_val == NULL ) {
+ /* if cmdline cookie does not have ctxcsn */
+ /* component, set it to an initial value */
+ slap_init_sync_cookie_ctxcsn( sc );
}
- slap_dup_sync_cookie( &si->si_syncCookie, slap_sync_cookie );
- slap_sync_cookie_free( slap_sync_cookie, 1 );
- slap_sync_cookie = NULL;
+ slap_dup_sync_cookie( &si->si_syncCookie, sc );
+ slap_sync_cookie_free( sc, 1 );
+ sc = NULL;
} else {
/* stored cookie */
+ struct berval newcookie = { 0, NULL };
ber_dupbv( &cookie_bv, &cookie[0] );
ber_bvarray_add( &si->si_syncCookie.octet_str, &cookie_bv );
slap_parse_sync_cookie( &si->si_syncCookie );
+ ber_bvarray_free( si->si_syncCookie.octet_str );
+ si->si_syncCookie.octet_str = NULL;
ber_bvarray_free_x( cookie, op->o_tmpmemctx );
- if ( slap_sync_cookie->sid != -1 ) {
+ if ( sc->sid != -1 ) {
/* command line cookie wins */
- si->si_syncCookie.sid = slap_sync_cookie->sid;
+ si->si_syncCookie.sid = sc->sid;
}
- if ( slap_sync_cookie->ctxcsn != NULL ) {
+ if ( sc->ctxcsn != NULL ) {
/* command line cookie wins */
if ( si->si_syncCookie.ctxcsn ) {
ber_bvarray_free( si->si_syncCookie.ctxcsn );
si->si_syncCookie.ctxcsn = NULL;
}
- ber_dupbv( &cookie_bv, &slap_sync_cookie->ctxcsn[0] );
+ ber_dupbv( &cookie_bv, &sc->ctxcsn[0] );
ber_bvarray_add( &si->si_syncCookie.ctxcsn, &cookie_bv );
}
- slap_sync_cookie_free( slap_sync_cookie, 1 );
- slap_sync_cookie = NULL;
+ if ( sc->rid != -1 ) {
+ /* command line cookie wins */
+ si->si_syncCookie.rid = sc->rid;
+ }
+ slap_sync_cookie_free( sc, 1 );
+ sc = NULL;
+ slap_compose_sync_cookie( NULL, &newcookie,
+ &si->si_syncCookie.ctxcsn[0],
+ si->si_syncCookie.sid, si->si_syncCookie.rid );
+ ber_bvarray_add( &si->si_syncCookie.octet_str, &newcookie );
}
} else {
/* no command line cookie is specified */
int rc, err, i;
ber_len_t len;
- slap_callback cb;
-
- int rc_efree;
+ int rc_efree = 1;
struct berval *psub;
Modifications *modlist = NULL;
BerVarray syncUUIDs = NULL;
ber_tag_t si_tag;
- if ( slapd_abrupt_shutdown ) {
+ if ( slapd_shutdown ) {
rc = -2;
goto done;
}
Debug( LDAP_DEBUG_TRACE, "=>do_syncrep2\n", 0, 0, 0 );
#endif
- op->o_callback = &cb;
-
psub = &si->si_be->be_nsuffix[0];
slap_dup_sync_cookie( &syncCookie_req, &si->si_syncCookie );
while (( rc = ldap_result( si->si_ld, LDAP_RES_ANY, LDAP_MSG_ONE, tout_p, &res ))
> 0 )
{
- if ( slapd_abrupt_shutdown ) {
+ if ( slapd_shutdown ) {
rc = -2;
goto done;
}
syncCookie.octet_str[0].bv_val )
slap_parse_sync_cookie( &syncCookie );
}
- entry = syncrepl_message_to_entry( si, op, msg,
- &modlist, syncstate );
- rc_efree = syncrepl_entry( si, op, entry, modlist, syncstate,
- &syncUUID, &syncCookie_req );
- if ( syncCookie.octet_str && syncCookie.octet_str[0].bv_val ) {
- syncrepl_updateCookie( si, op, psub, &syncCookie );
+ if ( syncrepl_message_to_entry( si, op, msg,
+ &modlist, &entry, syncstate ) == LDAP_SUCCESS ) {
+ rc_efree = syncrepl_entry( si, op, entry, modlist,
+ syncstate, &syncUUID, &syncCookie_req );
+ if ( syncCookie.octet_str &&
+ syncCookie.octet_str[0].bv_val ) {
+ syncrepl_updateCookie( si, op, psub, &syncCookie );
+ }
}
ldap_controls_free( rctrls );
if ( modlist ) {
}
if ( rc_efree && entry ) {
entry_free( entry );
+ entry = NULL;
}
break;
&syncCookie_req.ctxcsn[0], &syncCookie.ctxcsn[0], &text );
}
if ( syncCookie.octet_str && syncCookie.octet_str->bv_val
- && match < 0 ) {
+ && match < 0 && err == LDAP_SUCCESS ) {
syncrepl_updateCookie( si, op, psub, &syncCookie );
}
if ( rctrls ) {
* 1) err code : LDAP_BUSY ...
* 2) on err policy : stop service, stop sync, retry
*/
- if ( refreshDeletes == 0 && match < 0 ) {
+ if ( refreshDeletes == 0 && match < 0 &&
+ err == LDAP_SUCCESS ) {
syncrepl_del_nonpresent( op, si );
} else {
avl_free( si->si_presentlist, avl_ber_bvfree );
default:
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, ERR,
- "do_syncrep2 : unknown syncinfo tag (%d)\n",
- si_tag, 0, 0 );
+ "do_syncrep2 : unknown syncinfo tag (%ld)\n",
+ (long) si_tag, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
- "do_syncrep2 : unknown syncinfo tag (%d)\n",
- si_tag, 0, 0 );
+ "do_syncrep2 : unknown syncinfo tag (%ld)\n",
+ (long) si_tag, 0, 0 );
#endif
ldap_memfree( retoid );
ber_bvfree( retdata );
return NULL;
}
- if ( slapd_abrupt_shutdown && si->si_ld ) {
+ if ( slapd_shutdown && si->si_ld ) {
ldap_get_option( si->si_ld, LDAP_OPT_DESC, &s );
connection_client_stop( s );
ldap_unbind( si->si_ld );
return NULL;
}
- conn.c_connid = -1;
- conn.c_send_ldap_result = slap_send_ldap_result;
- conn.c_send_search_entry = slap_send_search_entry;
- conn.c_send_search_reference = slap_send_search_reference;
- conn.c_listener = (Listener *)&dummy_list;
- conn.c_peer_name = slap_empty_bv;
-
- /* set memory context */
-#define SLAB_SIZE 1048576
- op.o_tmpmemctx = sl_mem_create( SLAB_SIZE, ctx );
- op.o_tmpmfuncs = &sl_mfuncs;
+ connection_fake_init( &conn, &op, ctx );
op.o_dn = si->si_updatedn;
op.o_ndn = si->si_updatedn;
- op.o_time = slap_get_time();
- op.o_threadctx = ctx;
op.o_managedsait = 1;
op.o_bd = si->si_be;
- op.o_conn = &conn;
- op.o_connid = op.o_conn->c_connid;
op.o_sync_state.ctxcsn = NULL;
op.o_sync_state.sid = -1;
*/
if ( rc == LDAP_SUCCESS ) {
if ( first ) {
- rc = connection_client_setup( s, (Listener *)&dummy_list, do_syncrepl,
+ rc = connection_client_setup( s, do_syncrepl,
arg );
} else {
connection_client_enable( s );
return NULL;
}
-Entry*
+int
syncrepl_message_to_entry(
syncinfo_t *si,
Operation *op,
LDAPMessage *msg,
Modifications **modlist,
+ Entry **entry,
int syncstate
)
{
Debug( LDAP_DEBUG_ANY,
"Message type should be entry (%d)", ldap_msgtype( msg ), 0, 0 );
#endif
- return NULL;
+ return -1;
}
op->o_tag = LDAP_REQ_ADD;
Debug( LDAP_DEBUG_ANY,
"syncrepl_message_to_entry : dn get failed (%d)", rc, 0, 0 );
#endif
- return NULL;
+ return rc;
}
dnPrettyNormal( NULL, &bdn, &dn, &ndn, op->o_tmpmemctx );
if ( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_DELETE )
{
- return NULL;
+ return LDAP_SUCCESS;
+ }
+
+ if ( entry == NULL ) {
+ return -1;
}
e = ( Entry * ) ch_calloc( 1, sizeof( Entry ) );
+ *entry = e;
e->e_name = op->o_req_dn;
e->e_nname = op->o_req_ndn;
e = NULL;
}
- return e;
+ return rc;
}
+static struct berval uuidbva[] = {
+ BER_BVNULL,
+ BER_BVNULL
+};
+
int
syncrepl_entry(
syncinfo_t* si,
)
{
Backend *be = op->o_bd;
- slap_callback cb;
+ slap_callback cb = { NULL };
struct berval *syncuuid_bv = NULL;
struct berval syncUUID_strrep = { 0, NULL };
int ret = LDAP_SUCCESS;
const char *text;
+ struct berval pdn = { 0, NULL };
+ struct berval org_req_dn = { 0, NULL };
+ struct berval org_req_ndn = { 0, NULL };
+ struct berval org_dn = { 0, NULL };
+ struct berval org_ndn = { 0, NULL };
+ int org_managedsait;
+
if (( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_ADD ))
{
syncuuid_bv = ber_dupbv( NULL, syncUUID );
syncUUID->bv_val, syncUUID->bv_len );
op->ors_filterstr.bv_val[op->ors_filterstr.bv_len] = '\0';
+ op->o_tag = LDAP_REQ_SEARCH;
op->ors_scope = LDAP_SCOPE_SUBTREE;
/* get syncrepl cookie of shadow replica from subentry */
si->si_syncUUID_ndn.bv_val = NULL;
- rc = be->be_search( op, &rs );
+ if ( limits_check( op, &rs ) == 0 ) {
+ rc = be->be_search( op, &rs );
+ }
if ( op->ors_filterstr.bv_val ) {
sl_free( op->ors_filterstr.bv_val, op->o_tmpmemctx );
op->o_req_ndn = si->si_syncUUID_ndn;
op->o_tag = LDAP_REQ_DELETE;
rc = be->be_delete( op, &rs );
+
+ org_req_dn = op->o_req_dn;
+ org_req_ndn = op->o_req_ndn;
+ org_dn = op->o_dn;
+ org_ndn = op->o_ndn;
+ org_managedsait = get_manageDSAit( op );
+ op->o_dn = op->o_bd->be_rootdn;
+ op->o_ndn = op->o_bd->be_rootndn;
+ op->o_managedsait = 1;
+
+ while ( rs.sr_err == LDAP_SUCCESS &&
+ op->o_delete_glue_parent ) {
+ op->o_delete_glue_parent = 0;
+ if ( !be_issuffix( op->o_bd, &op->o_req_ndn )) {
+ slap_callback cb = { NULL };
+ cb.sc_response = slap_null_cb;
+ dnParent( &op->o_req_ndn, &pdn );
+ op->o_req_dn = pdn;
+ op->o_req_ndn = pdn;
+ op->o_callback = &cb;
+ op->o_bd->be_delete( op, &rs );
+ } else {
+ break;
+ }
+ }
+
+ op->o_managedsait = org_managedsait;
+ op->o_dn = org_dn;
+ op->o_ndn = org_ndn;
+ op->o_req_dn = org_req_dn;
+ op->o_req_ndn = org_req_ndn;
+ op->o_delete_glue_parent = 0;
+
op->o_no_psearch = 0;
}
case LDAP_SYNC_MODIFY:
if ( rc == LDAP_SUCCESS ||
rc == LDAP_REFERRAL ||
- rc == LDAP_NO_SUCH_OBJECT )
+ rc == LDAP_NO_SUCH_OBJECT ||
+ rc == LDAP_NOT_ALLOWED_ON_NONLEAF )
{
attr_delete( &e->e_attrs, slap_schema.si_ad_entryUUID );
attr_merge_one( e, slap_schema.si_ad_entryUUID,
rc = be->be_add( op, &rs );
if ( rc != LDAP_SUCCESS ) {
- if ( rc == LDAP_ALREADY_EXISTS ) {
+ if ( rc == LDAP_ALREADY_EXISTS ) {
+ Modifications *mod;
+ Modifications *modtail;
+
+ for ( mod = modlist; mod != NULL; mod = mod->sml_next ) {
+ modtail = mod;
+ }
+
+ mod = (Modifications *)ch_calloc(1, sizeof(Modifications));
+ ber_dupbv( &uuidbva[0], syncUUID );
+ mod->sml_op = LDAP_MOD_REPLACE;
+ mod->sml_desc = slap_schema.si_ad_entryUUID;
+ mod->sml_type = mod->sml_desc->ad_cname;
+ mod->sml_bvalues = uuidbva;
+ modtail->sml_next = mod;
+
op->o_tag = LDAP_REQ_MODIFY;
op->orm_modlist = modlist;
op->o_req_dn = e->e_name;
op->o_req_ndn = e->e_nname;
+
rc = be->be_modify( op, &rs );
if ( rc != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
case LDAP_SYNC_DELETE :
/* Already deleted */
- ret = 1;
+ ret = 0;
goto done;
default :
return ret;
}
+static struct berval gcbva[] = {
+ BER_BVC("top"),
+ BER_BVC("glue"),
+ BER_BVNULL
+};
+
static void
syncrepl_del_nonpresent(
Operation *op,
)
{
Backend* be = op->o_bd;
- slap_callback cb;
+ slap_callback cb = { NULL };
SlapReply rs = {REP_RESULT};
struct nonpresent_entry *np_list, *np_prev;
+ int rc;
+ Modifications *ml;
+ Modifications *mlnext;
+ Modifications *mod;
+ Modifications *modlist = NULL;
+ Modifications **modtail = &modlist;
+ Attribute *attr;
+
+ struct berval pdn = { 0, NULL };
+ struct berval org_req_dn = { 0, NULL };
+ struct berval org_req_ndn = { 0, NULL };
+ struct berval org_dn = { 0, NULL };
+ struct berval org_ndn = { 0, NULL };
+ int org_managedsait;
op->o_req_dn = si->si_base;
op->o_req_ndn = si->si_base;
op->ors_filterstr = si->si_filterstr;
op->o_nocaching = 1;
- be->be_search( op, &rs );
+ op->o_managedsait = 0;
+
+ if ( limits_check( op, &rs ) == 0 ) {
+ be->be_search( op, &rs );
+ }
+
+ op->o_managedsait = 1;
op->o_nocaching = 0;
if ( op->ors_filter ) filter_free_x( op, op->ors_filter );
cb.sc_private = si;
op->o_req_dn = *np_prev->npe_name;
op->o_req_ndn = *np_prev->npe_nname;
- op->o_bd->be_delete( op, &rs );
+ rc = op->o_bd->be_delete( op, &rs );
+
+ if ( rc == LDAP_NOT_ALLOWED_ON_NONLEAF ) {
+ mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
+ mod->sml_op = LDAP_MOD_REPLACE;
+ mod->sml_desc = slap_schema.si_ad_objectClass;
+ mod->sml_type = mod->sml_desc->ad_cname;
+ mod->sml_bvalues = &gcbva[0];
+ *modtail = mod;
+ modtail = &mod->sml_next;
+
+ mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
+ mod->sml_op = LDAP_MOD_REPLACE;
+ mod->sml_desc = slap_schema.si_ad_structuralObjectClass;
+ mod->sml_type = mod->sml_desc->ad_cname;
+ mod->sml_bvalues = &gcbva[1];
+ *modtail = mod;
+ modtail = &mod->sml_next;
+
+ op->o_tag = LDAP_REQ_MODIFY;
+ op->orm_modlist = modlist;
+
+ rc = be->be_modify( op, &rs );
+
+ for ( ml = modlist; ml != NULL; ml = mlnext ) {
+ mlnext = ml->sml_next;
+ free( ml );
+ }
+ }
+
+ org_req_dn = op->o_req_dn;
+ org_req_ndn = op->o_req_ndn;
+ org_dn = op->o_dn;
+ org_ndn = op->o_ndn;
+ org_managedsait = get_manageDSAit( op );
+ op->o_dn = op->o_bd->be_rootdn;
+ op->o_ndn = op->o_bd->be_rootndn;
+ op->o_managedsait = 1;
+
+ while ( rs.sr_err == LDAP_SUCCESS &&
+ op->o_delete_glue_parent ) {
+ op->o_delete_glue_parent = 0;
+ if ( !be_issuffix( op->o_bd, &op->o_req_ndn )) {
+ slap_callback cb = { NULL };
+ cb.sc_response = slap_null_cb;
+ dnParent( &op->o_req_ndn, &pdn );
+ op->o_req_dn = pdn;
+ op->o_req_ndn = pdn;
+ op->o_callback = &cb;
+ /* give it a root privil ? */
+ op->o_bd->be_delete( op, &rs );
+ } else {
+ break;
+ }
+ }
+
+ op->o_managedsait = org_managedsait;
+ op->o_dn = org_dn;
+ op->o_ndn = org_ndn;
+ op->o_req_dn = org_req_dn;
+ op->o_req_ndn = org_req_ndn;
+ op->o_delete_glue_parent = 0;
+
ber_bvfree( np_prev->npe_name );
ber_bvfree( np_prev->npe_nname );
op->o_req_dn.bv_val = NULL;
}
-static struct berval gcbva[] = {
- BER_BVC("top"),
- BER_BVC("glue")
-};
-
void
syncrepl_add_glue(
Operation* op,
)
{
Backend *be = op->o_bd;
- slap_callback cb;
+ slap_callback cb = { NULL };
Attribute *a;
int rc;
int suffrdns;
a->a_vals = ch_calloc( 3, sizeof( struct berval ));
ber_dupbv( &a->a_vals[0], &gcbva[0] );
ber_dupbv( &a->a_vals[1], &gcbva[1] );
- a->a_vals[2].bv_len = 0;
- a->a_vals[2].bv_val = NULL;
+ ber_dupbv( &a->a_vals[2], &gcbva[2] );
a->a_nvals = a->a_vals;
a->a_vals = ch_calloc( 2, sizeof( struct berval ));
ber_dupbv( &a->a_vals[0], &gcbva[1] );
- a->a_vals[1].bv_len = 0;
- a->a_vals[1].bv_val = NULL;
+ ber_dupbv( &a->a_vals[1], &gcbva[2] );
a->a_nvals = a->a_vals;
struct berval slap_syncrepl_dn_bv = BER_BVNULL;
struct berval slap_syncrepl_cn_bv = BER_BVNULL;
- slap_callback cb;
+ slap_callback cb = { NULL };
SlapReply rs = {REP_RESULT};
slap_sync_cookie_free( &si->si_syncCookie, 0 );
modtail = &mod->sml_next;
ber_dupbv( &cnbva[0], (struct berval *) &slap_syncrepl_bvc );
- assert( si->si_id < 1000 );
+ assert( si->si_rid < 1000 );
cnbva[0].bv_len = snprintf( cnbva[0].bv_val,
slap_syncrepl_bvc.bv_len,
- "syncrepl%d", si->si_id );
+ "syncrepl%ld", si->si_rid );
mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
mod->sml_op = LDAP_MOD_REPLACE;
mod->sml_desc = slap_schema.si_ad_cn;
e = ( Entry * ) ch_calloc( 1, sizeof( Entry ));
slap_syncrepl_cn_bv.bv_val = syncrepl_cbuf;
- assert( si->si_id < 1000 );
+ assert( si->si_rid < 1000 );
slap_syncrepl_cn_bv.bv_len = snprintf( slap_syncrepl_cn_bv.bv_val,
slap_syncrepl_cn_bvc.bv_len,
- "cn=syncrepl%d", si->si_id );
+ "cn=syncrepl%ld", si->si_rid );
build_new_dn( &slap_syncrepl_dn_bv, pdn, &slap_syncrepl_cn_bv,
op->o_tmpmemctx );
static int
null_callback(
Operation* op,
- SlapReply* rs
-)
+ SlapReply* rs )
{
if ( rs->sr_err != LDAP_SUCCESS &&
rs->sr_err != LDAP_REFERRAL &&
rs->sr_err != LDAP_ALREADY_EXISTS &&
- rs->sr_err != LDAP_NO_SUCH_OBJECT )
+ rs->sr_err != LDAP_NO_SUCH_OBJECT &&
+ rs->sr_err != LDAP_NOT_ALLOWED_ON_NONLEAF )
{
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, ERR,
Backend *be,
struct berval *context_csn,
struct berval *rdn,
- struct berval *cn
-)
+ struct berval *cn )
{
Entry* e;