#include <ac/string.h>
#include <ac/socket.h>
-#include "ldap_pvt.h"
#include "lutil.h"
#include "slap.h"
#include "lutil_ldap.h"
#include "ldap_rq.h"
+/* FIXME: for ldap_ld_free() */
+#undef ldap_debug
+#include "../../libraries/libldap/ldap-int.h"
+
#define SYNCREPL_STR "syncreplxxx"
#define CN_STR "cn="
{
int i, j, k, l, n;
char **attrs, **exattrs;
- ObjectClass *oc;
if ( !sync_descs[0] ) {
sync_descs[0] = slap_schema.si_ad_objectClass;
attrs = anlist2attrs( si->si_anlist );
if ( attrs ) {
-
if ( si->si_allattrs ) {
i = 0;
while ( attrs[i] ) {
i++;
}
}
- attrs = ( char ** ) ch_realloc( attrs, (i + 1)*sizeof( char * ));
+ attrs = ( char ** ) ch_realloc( attrs, (i + 2)*sizeof( char * ) );
+ attrs[i] = ch_strdup("*");
+ attrs[i + 1] = NULL;
+
} else if ( si->si_allopattrs ) {
i = 0;
while ( attrs[i] ) {
i++;
}
}
- attrs = ( char ** ) ch_realloc( attrs, (i + 1)*sizeof( char * ));
+ attrs = ( char ** ) ch_realloc( attrs, (i + 2)*sizeof( char * ) );
+ attrs[i] = ch_strdup("+");
+ attrs[i + 1] = NULL;
}
- if ( !si->si_allopattrs ) {
- for ( i = 0; sync_descs[i] != NULL; i++ ) {
- j = 0;
- while ( attrs[j] ) {
- if ( !strcmp( attrs[j], sync_descs[i]->ad_cname.bv_val )) {
- for ( k = j; attrs[k] != NULL; k++ ) {
- if ( k == j )
- ch_free( attrs[k] );
- attrs[k] = attrs[k+1];
- }
- } else {
- j++;
+ for ( i = 0; sync_descs[i] != NULL; i++ ) {
+ j = 0;
+ while ( attrs[j] ) {
+ if ( !strcmp( attrs[j], sync_descs[i]->ad_cname.bv_val )) {
+ for ( k = j; attrs[k] != NULL; k++ ) {
+ if ( k == j )
+ ch_free( attrs[k] );
+ attrs[k] = attrs[k+1];
}
+ } else {
+ j++;
}
-
}
- for ( n = 0; attrs[ n ] != NULL; n++ ) /* empty */;
+ }
+
+ for ( n = 0; attrs[ n ] != NULL; n++ ) /* empty */;
+
+ if ( si->si_allopattrs ) {
+ attrs = ( char ** ) ch_realloc( attrs, (n + 2)*sizeof( char * ));
+ } else {
attrs = ( char ** ) ch_realloc( attrs, (n + 4)*sizeof( char * ));
- if ( attrs == NULL ) {
- Debug( LDAP_DEBUG_ANY, "out of memory\n", 0,0,0 );
- }
-
- /* Add Attributes */
+ }
+
+ if ( attrs == NULL ) {
+ Debug( LDAP_DEBUG_ANY, "out of memory\n", 0,0,0 );
+ }
+
+ /* Add Attributes */
+ if ( si->si_allopattrs ) {
+ attrs[n++] = ch_strdup( sync_descs[0]->ad_cname.bv_val );
+ } else {
for ( i = 0; sync_descs[ i ] != NULL; i++ ) {
attrs[ n++ ] = ch_strdup ( sync_descs[i]->ad_cname.bv_val );
- attrs[ n ] = NULL;
}
}
+ attrs[ n ] = NULL;
} else {
- attrs = ( char ** ) ch_realloc( attrs, 3 * sizeof( char * ));
- if ( attrs == NULL ) {
- Debug( LDAP_DEBUG_ANY, "out of memory\n", 0,0,0 );
+
+ i = 0;
+ if ( si->si_allattrs == si->si_allopattrs ) {
+ attrs = (char**) ch_malloc( 3 * sizeof(char*) );
+ attrs[i++] = ch_strdup( "*" );
+ attrs[i++] = ch_strdup( "+" );
+ } else if ( si->si_allattrs && !si->si_allopattrs ) {
+ for ( n = 0; sync_descs[ n ] != NULL; n++ ) ;
+ attrs = (char**) ch_malloc( (n+1)* sizeof(char*) );
+ attrs[i++] = ch_strdup( "*" );
+ for ( j = 1; sync_descs[ j ] != NULL; j++ ) {
+ attrs[i++] = ch_strdup ( sync_descs[j]->ad_cname.bv_val );
+ }
+ } else if ( !si->si_allattrs && si->si_allopattrs ) {
+ attrs = (char**) ch_malloc( 3 * sizeof(char*) );
+ attrs[i++] = ch_strdup( "+" );
+ attrs[i++] = ch_strdup( sync_descs[0]->ad_cname.bv_val );
}
- attrs[0] = ch_strdup( "*" );
- attrs[1] = ch_strdup( "+" );
- attrs[2] = NULL;
+ attrs[i] = NULL;
}
si->si_attrs = attrs;
exattrs = anlist2attrs( si->si_exanlist );
if ( exattrs ) {
+ for ( n = 0; exattrs[n] != NULL; n++ ) ;
for ( i = 0; sync_descs[i] != NULL; i++ ) {
j = 0;
for ( i = 0; exattrs[i] != NULL; i++ ) {
for ( j = 0; si->si_anlist[j].an_name.bv_val; j++ ) {
- if ( oc = si->si_anlist[j].an_oc ) {
+ ObjectClass *oc;
+ if ( ( oc = si->si_anlist[j].an_oc ) ) {
k = 0;
while ( oc->soc_required[k] ) {
if ( !strcmp( exattrs[i],
}
for ( i = 0; exattrs[i] != NULL; i++ ) ;
- exattrs = (char **) ch_realloc( exattrs, (i + 1)*sizeof(char *));
+
+ if ( i != n )
+ exattrs = (char **) ch_realloc( exattrs, (i + 1)*sizeof(char *));
}
si->si_exattrs = exattrs;
ber_set_option( ber, LBER_OPT_BER_MEMCTX, &ctx );
if ( si->si_syncCookie.octet_str &&
- si->si_syncCookie.octet_str[0].bv_val )
+ !BER_BVISNULL( &si->si_syncCookie.octet_str[0] ) )
{
ber_printf( ber, "{eO}",
abs(si->si_type),
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;
#ifdef HAVE_TLS
void *ssl;
/* get syncrepl cookie of shadow replica from subentry */
assert( si->si_rid < 1000 );
syncrepl_cn_bv.bv_val = syncrepl_cbuf;
- syncrepl_cn_bv.bv_len = snprintf(syncrepl_cbuf, sizeof(syncrepl_cbuf),
+ syncrepl_cn_bv.bv_len = snprintf( syncrepl_cbuf, sizeof(syncrepl_cbuf),
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 ( !cookie ) {
/* no stored cookie */
if ( sc->ctxcsn == NULL ||
- sc->ctxcsn->bv_val == NULL ) {
+ BER_BVISNULL( sc->ctxcsn ) ) {
/* if cmdline cookie does not have ctxcsn */
/* component, set it to an initial value */
slap_init_sync_cookie_ctxcsn( sc );
ldap_get_entry_controls( si->si_ld, msg, &rctrls );
/* we can't work without the control */
if ( !rctrls ) {
+ Debug( LDAP_DEBUG_ANY, "do_syncrep2: "
+ "got search entry without "
+ "control\n", 0, 0, 0 );
rc = -1;
goto done;
}
ber_scanf( ber, "{em" /*"}"*/, &syncstate, &syncUUID );
if ( ber_peek_tag( ber, &len ) == LDAP_TAG_SYNC_COOKIE ) {
ber_scanf( ber, /*"{"*/ "m}", &cookie );
- if ( cookie.bv_val ) {
+ if ( !BER_BVISNULL( &cookie ) ) {
struct berval tmp_bv;
ber_dupbv( &tmp_bv, &cookie );
ber_bvarray_add( &syncCookie.octet_str, &tmp_bv );
}
if ( syncCookie.octet_str &&
- syncCookie.octet_str[0].bv_val )
+ !BER_BVISNULL( &syncCookie.octet_str[0] ) )
+ {
slap_parse_sync_cookie( &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 );
+ syncstate, &syncUUID, &syncCookie_req, syncCookie.ctxcsn );
if ( syncCookie.octet_str &&
- syncCookie.octet_str[0].bv_val )
+ !BER_BVISNULL( &syncCookie.octet_str[0] ) )
{
syncrepl_updateCookie( si, op, psub, &syncCookie );
}
case LDAP_RES_SEARCH_REFERENCE:
Debug( LDAP_DEBUG_ANY,
- "do_syncrep2 : reference received\n", 0, 0, 0 );
+ "do_syncrep2: reference received error\n", 0, 0, 0 );
break;
case LDAP_RES_SEARCH_RESULT:
+ Debug( LDAP_DEBUG_SYNC,
+ "do_syncrep2: LDAP_RES_SEARCH_RESULT\n", 0, 0, 0 );
ldap_parse_result( si->si_ld, msg, &err, NULL, NULL, NULL,
&rctrls, 0 );
if ( rctrls ) {
ber_scanf( ber, "{" /*"}"*/);
if ( ber_peek_tag( ber, &len ) == LDAP_TAG_SYNC_COOKIE ) {
ber_scanf( ber, "m", &cookie );
- if ( cookie.bv_val ) {
+ if ( !BER_BVISNULL( &cookie ) ) {
struct berval tmp_bv;
ber_dupbv( &tmp_bv, &cookie );
ber_bvarray_add( &syncCookie.octet_str, &tmp_bv);
}
if ( syncCookie.octet_str &&
- syncCookie.octet_str[0].bv_val )
+ !BER_BVISNULL( &syncCookie.octet_str[0] ) )
{
slap_parse_sync_cookie( &syncCookie );
}
&syncCookie_req.ctxcsn[0], &syncCookie.ctxcsn[0],
&text );
}
- if ( syncCookie.octet_str && syncCookie.octet_str->bv_val &&
+ if ( syncCookie.octet_str && !BER_BVISNULL( syncCookie.octet_str ) &&
match < 0 && err == LDAP_SUCCESS )
{
syncrepl_updateCookie( si, op, psub, &syncCookie );
rc = ldap_parse_intermediate( si->si_ld, msg,
&retoid, &retdata, NULL, 0 );
if ( !rc && !strcmp( retoid, LDAP_SYNC_INFO ) ) {
- int si_refreshDelete = 0;
- int si_refreshPresent = 0;
ber_init2( ber, retdata, LBER_USE_DER );
switch ( si_tag = ber_peek_tag( ber, &len )) {
ber_tag_t tag;
case LDAP_TAG_SYNC_NEW_COOKIE:
+ Debug( LDAP_DEBUG_SYNC,
+ "do_syncrep2: %s - %s%s\n",
+ "LDAP_RES_INTERMEDIATE",
+ "NEW_COOKIE", "\n" );
ber_scanf( ber, "tm", &tag, &cookie );
break;
case LDAP_TAG_SYNC_REFRESH_DELETE:
- si_refreshDelete = 1;
+ Debug( LDAP_DEBUG_SYNC,
+ "do_syncrep2: %s - %s%s\n",
+ "LDAP_RES_INTERMEDIATE",
+ "REFRESH_DELETE\n", "\n" );
+ si->si_refreshDelete = 1;
case LDAP_TAG_SYNC_REFRESH_PRESENT:
- si_refreshPresent = 1;
+ Debug( LDAP_DEBUG_SYNC,
+ "do_syncrep2: %s - %s%s\n",
+ "LDAP_RES_INTERMEDIATE",
+ si_tag == LDAP_TAG_SYNC_REFRESH_PRESENT ?
+ "REFRESH_PRESENT" : "REFRESH_DELETE",
+ "\n" );
+ si->si_refreshDelete = 1;
+ si->si_refreshPresent = 1;
ber_scanf( ber, "t{" /*"}"*/, &tag );
if ( ber_peek_tag( ber, &len ) == LDAP_TAG_SYNC_COOKIE )
{
ber_scanf( ber, "m", &cookie );
- if ( cookie.bv_val ) {
+ if ( !BER_BVISNULL( &cookie ) ) {
struct berval tmp_bv;
ber_dupbv( &tmp_bv, &cookie );
ber_bvarray_add( &syncCookie.octet_str,
&tmp_bv);
}
if ( syncCookie.octet_str &&
- syncCookie.octet_str[0].bv_val )
+ !BER_BVISNULL( &syncCookie.octet_str[0] ) )
{
slap_parse_sync_cookie( &syncCookie );
}
ber_scanf( ber, /*"{"*/ "}" );
break;
case LDAP_TAG_SYNC_ID_SET:
+ Debug( LDAP_DEBUG_SYNC,
+ "do_syncrep2: %s - %s%s\n",
+ "LDAP_RES_INTERMEDIATE",
+ "SYNC_ID_SET",
+ "\n" );
ber_scanf( ber, "t{" /*"}"*/, &tag );
if ( ber_peek_tag( ber, &len ) ==
LDAP_TAG_SYNC_COOKIE )
{
ber_scanf( ber, "m", &cookie );
- if ( cookie.bv_val ) {
+ if ( !BER_BVISNULL( &cookie ) ) {
struct berval tmp_bv;
ber_dupbv( &tmp_bv, &cookie );
ber_bvarray_add( &syncCookie.octet_str,
&tmp_bv );
}
if ( syncCookie.octet_str &&
- syncCookie.octet_str[0].bv_val )
+ !BER_BVISNULL( &syncCookie.octet_str[0] ) )
{
slap_parse_sync_cookie( &syncCookie );
}
}
ber_scanf( ber, "[W]", &syncUUIDs );
ber_scanf( ber, /*"{"*/ "}" );
- for ( i = 0; syncUUIDs[i].bv_val; i++ ) {
+ for ( i = 0; !BER_BVISNULL( &syncUUIDs[i] ); i++ ) {
struct berval *syncuuid_bv;
syncuuid_bv = ber_dupbv( NULL, &syncUUIDs[i] );
slap_sl_free( syncUUIDs[i].bv_val,op->o_tmpmemctx );
slap_sl_free( syncUUIDs, op->o_tmpmemctx );
break;
default:
- Debug( LDAP_DEBUG_ANY,
- "do_syncrep2 : unknown syncinfo tag (%ld)\n",
+ Debug( LDAP_DEBUG_ANY,
+ "do_syncrep2 : unknown syncinfo tag (%ld)\n",
(long) si_tag, 0, 0 );
ldap_memfree( retoid );
ber_bvfree( retdata );
&syncCookie.ctxcsn[0], &text );
}
- if ( syncCookie.ctxcsn && syncCookie.ctxcsn[0].bv_val &&
+ if ( syncCookie.ctxcsn && !BER_BVISNULL( &syncCookie.ctxcsn[0] ) &&
match < 0 )
{
syncrepl_updateCookie( si, op, psub, &syncCookie);
}
- if ( si_refreshPresent == 1 ) {
+ if ( si->si_refreshPresent == 1 ) {
if ( match < 0 ) {
syncrepl_del_nonpresent( op, si );
}
syncinfo_t *si = ( syncinfo_t * ) rtask->arg;
Connection conn = {0};
Operation op = {0};
+ Opheader ohdr = {0};
int rc = LDAP_SUCCESS;
int first = 0;
int dostop = 0;
return NULL;
}
- connection_fake_init( &conn, &op, ctx );
+ connection_fake_init( &conn, &op, &ohdr, ctx );
/* use global malloc for now */
op.o_tmpmemctx = NULL;
op.o_dn = si->si_updatedn;
op.o_ndn = si->si_updatedn;
- op.o_managedsait = 1;
+ op.o_managedsait = SLAP_CONTROL_NONCRITICAL;
op.o_bd = be = si->si_be;
- op.o_sync_state.ctxcsn = NULL;
- op.o_sync_state.sid = -1;
- op.o_sync_state.octet_str = NULL;
- op.o_sync_slog_size = -1;
- LDAP_STAILQ_FIRST( &op.o_sync_slog_list ) = NULL;
- op.o_sync_slog_list.stqh_last = &LDAP_STAILQ_FIRST(&op.o_sync_slog_list);
-
/* Establish session, do search */
if ( !si->si_ld ) {
first = 1;
+ si->si_refreshDelete = 0;
+ si->si_refreshPresent = 0;
rc = do_syncrep1( &op, si );
}
while ( ber_remaining( ber ) ) {
if ( (ber_scanf( ber, "{mW}", &tmp.sml_type, &tmp.sml_values ) ==
- LBER_ERROR ) || ( tmp.sml_type.bv_val == NULL ))
+ LBER_ERROR ) || BER_BVISNULL( &tmp.sml_type ) )
{
break;
}
Modifications* modlist,
int syncstate,
struct berval* syncUUID,
- struct sync_cookie* syncCookie_req )
+ struct sync_cookie* syncCookie_req,
+ struct berval* syncCSN )
{
Backend *be = op->o_bd;
slap_callback cb = { NULL };
AttributeAssertion ava = {0};
int rc = LDAP_SUCCESS;
int ret = LDAP_SUCCESS;
- const char *text;
struct berval pdn = BER_BVNULL;
struct berval org_req_dn = BER_BVNULL;
struct berval org_ndn = BER_BVNULL;
int org_managedsait;
+ switch( syncstate ) {
+ case LDAP_SYNC_PRESENT:
+ Debug( LDAP_DEBUG_SYNC, "%s: %s\n",
+ "syncrepl_entry",
+ "LDAP_RES_SEARCH_ENTRY(LDAP_SYNC_PRESENT)", 0 );
+ break;
+ case LDAP_SYNC_ADD:
+ Debug( LDAP_DEBUG_SYNC, "%s: %s\n",
+ "syncrepl_entry",
+ "LDAP_RES_SEARCH_ENTRY(LDAP_SYNC_ADD)", 0 );
+ break;
+ case LDAP_SYNC_DELETE:
+ Debug( LDAP_DEBUG_SYNC, "%s: %s\n",
+ "syncrepl_entry",
+ "LDAP_RES_SEARCH_ENTRY(LDAP_SYNC_DELETE)", 0 );
+ break;
+ case LDAP_SYNC_MODIFY:
+ Debug( LDAP_DEBUG_SYNC, "%s: %s\n",
+ "syncrepl_entry",
+ "LDAP_RES_SEARCH_ENTRY(LDAP_SYNC_MODIFY)", 0 );
+ break;
+ default:
+ Debug( LDAP_DEBUG_ANY, "%s: %s\n",
+ "syncrepl_entry",
+ "LDAP_RES_SEARCH_ENTRY(UNKNOWN syncstate)", 0 );
+ }
+
if (( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_ADD )) {
- syncuuid_bv = ber_dupbv( NULL, syncUUID );
- avl_insert( &si->si_presentlist, (caddr_t) syncuuid_bv,
- syncuuid_cmp, avl_dup_error );
+ if ( !si->si_refreshPresent ) {
+ syncuuid_bv = ber_dupbv( NULL, syncUUID );
+ avl_insert( &si->si_presentlist, (caddr_t) syncuuid_bv,
+ syncuuid_cmp, avl_dup_error );
+ }
}
if ( syncstate == LDAP_SYNC_PRESENT ) {
f.f_choice = LDAP_FILTER_EQUALITY;
f.f_ava = &ava;
ava.aa_desc = slap_schema.si_ad_entryUUID;
- slap_uuidstr_from_normalized( &syncUUID_strrep, syncUUID, op->o_tmpmemctx );
+ (void)slap_uuidstr_from_normalized( &syncUUID_strrep, syncUUID, op->o_tmpmemctx );
ava.aa_value = *syncUUID;
op->ors_filter = &f;
- op->ors_filterstr.bv_len = (sizeof("entryUUID=")-1) + syncUUID->bv_len;
+ op->ors_filterstr.bv_len = STRLENOF( "entryUUID=" ) + syncUUID->bv_len;
op->ors_filterstr.bv_val = (char *) slap_sl_malloc(
op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
- AC_MEMCPY( op->ors_filterstr.bv_val, "entryUUID=", sizeof("entryUUID=")-1 );
- AC_MEMCPY( &op->ors_filterstr.bv_val[sizeof("entryUUID=")-1],
+ AC_MEMCPY( op->ors_filterstr.bv_val, "entryUUID=", STRLENOF( "entryUUID=" ) );
+ AC_MEMCPY( &op->ors_filterstr.bv_val[STRLENOF( "entryUUID=" )],
syncUUID->bv_val, syncUUID->bv_len );
op->ors_filterstr.bv_val[op->ors_filterstr.bv_len] = '\0';
cb.sc_response = dn_callback;
cb.sc_private = si;
- si->si_syncUUID_ndn.bv_val = NULL;
+ BER_BVZERO( &si->si_syncUUID_ndn );
if ( limits_check( op, &rs_search ) == 0 ) {
rc = be->be_search( op, &rs_search );
+ Debug( LDAP_DEBUG_SYNC,
+ "syncrepl_entry: %s (%d)\n",
+ "be_search", rc, 0 );
}
- if ( op->ors_filterstr.bv_val ) {
+ if ( !BER_BVISNULL( &op->ors_filterstr ) ) {
slap_sl_free( op->ors_filterstr.bv_val, op->o_tmpmemctx );
}
cb.sc_response = null_callback;
cb.sc_private = si;
- if ( rs_search.sr_err == LDAP_SUCCESS && si->si_syncUUID_ndn.bv_val ) {
+ if ( entry && entry->e_name.bv_val ) {
+ Debug( LDAP_DEBUG_SYNC,
+ "syncrepl_entry: %s\n",
+ entry->e_name.bv_val, 0, 0 );
+ } else {
+ Debug( LDAP_DEBUG_SYNC,
+ "syncrepl_entry: %s\n",
+ si->si_syncUUID_ndn.bv_val, 0, 0 );
+ }
+
+ if ( rs_search.sr_err == LDAP_SUCCESS &&
+ !BER_BVISNULL( &si->si_syncUUID_ndn ))
+ {
+#if 0
char *subseq_ptr;
if ( syncstate != LDAP_SYNC_DELETE ) {
}
ber_dupbv( &op->o_sync_csn, syncCookie_req->ctxcsn );
- if ( op->o_sync_csn.bv_val ) {
+ if ( !BER_BVISNULL( &op->o_sync_csn ) ) {
subseq_ptr = strstr( op->o_sync_csn.bv_val, "#0000" );
subseq_ptr += 4;
*subseq_ptr = '1';
}
+#endif
op->o_req_dn = si->si_syncUUID_ndn;
op->o_req_ndn = si->si_syncUUID_ndn;
op->o_tag = LDAP_REQ_DELETE;
rc = be->be_delete( op, &rs_delete );
+ Debug( LDAP_DEBUG_SYNC,
+ "syncrepl_entry: %s (%d)\n",
+ "be_delete", rc, 0 );
org_req_dn = op->o_req_dn;
org_req_ndn = op->o_req_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;
+ op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
while ( rs_delete.sr_err == LDAP_SUCCESS && op->o_delete_glue_parent ) {
op->o_delete_glue_parent = 0;
op->o_req_ndn = org_req_ndn;
op->o_delete_glue_parent = 0;
+#if 0
op->o_no_psearch = 0;
+#endif
}
switch ( syncstate ) {
op->o_req_ndn = entry->e_nname;
rc = be->be_add( op, &rs_add );
+ Debug( LDAP_DEBUG_SYNC,
+ "syncrepl_entry: %s (%d)\n",
+ "be_add", rc, 0 );
if ( rs_add.sr_err != LDAP_SUCCESS ) {
if ( rs_add.sr_err == LDAP_ALREADY_EXISTS &&
op->o_req_ndn = entry->e_nname;
rc = be->be_modify( op, &rs_modify );
+ Debug( LDAP_DEBUG_SYNC,
+ "syncrepl_entry: %s (%d)\n",
+ "be_modify", rc, 0 );
if ( rs_modify.sr_err != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"syncrepl_entry : be_modify failed (%d)\n",
}
done :
-
- if ( syncUUID_strrep.bv_val ) {
+ if ( !BER_BVISNULL( &syncUUID_strrep ) ) {
slap_sl_free( syncUUID_strrep.bv_val, op->o_tmpmemctx );
+ BER_BVZERO( &syncUUID_strrep );
}
- if ( si->si_syncUUID_ndn.bv_val ) {
+ if ( !BER_BVISNULL( &si->si_syncUUID_ndn ) ) {
ch_free( si->si_syncUUID_ndn.bv_val );
- si->si_syncUUID_ndn.bv_val = NULL;
+ BER_BVZERO( &si->si_syncUUID_ndn );
}
return ret;
}
Modifications *mlnext;
Modifications *mod;
Modifications *modlist = NULL;
- Modifications **modtail = &modlist;
- Attribute *attr;
+ Modifications **modtail;
AttributeName an[2];
struct berval pdn = BER_BVNULL;
op->ors_filterstr = si->si_filterstr;
op->o_nocaching = 1;
- op->o_managedsait = 0;
+ op->o_managedsait = SLAP_CONTROL_NONE;
if ( limits_check( op, &rs_search ) == 0 ) {
rc = be->be_search( op, &rs_search );
}
- op->o_managedsait = 1;
+ op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
op->o_nocaching = 0;
if ( op->ors_filter ) filter_free_x( op, op->ors_filter );
rc = op->o_bd->be_delete( op, &rs_delete );
if ( rs_delete.sr_err == LDAP_NOT_ALLOWED_ON_NONLEAF ) {
+ modtail = &modlist;
mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
mod->sml_op = LDAP_MOD_REPLACE;
mod->sml_desc = slap_schema.si_ad_objectClass;
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;
+ op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
while ( rs_delete.sr_err == LDAP_SUCCESS &&
op->o_delete_glue_parent ) {
ber_bvfree( np_prev->npe_name );
ber_bvfree( np_prev->npe_nname );
- op->o_req_dn.bv_val = NULL;
- op->o_req_ndn.bv_val = NULL;
+ BER_BVZERO( &op->o_req_dn );
+ BER_BVZERO( &op->o_req_ndn );
ch_free( np_prev );
}
}
ndn = e->e_nname;
/* count RDNs in suffix */
- if ( be->be_nsuffix[0].bv_len ) {
- for (i=0, ptr=be->be_nsuffix[0].bv_val; ptr; ptr=strchr( ptr, ',' )) {
+ if ( !BER_BVISEMPTY( &be->be_nsuffix[0] ) ) {
+ for ( i = 0, ptr = be->be_nsuffix[0].bv_val; ptr; ptr = strchr( ptr, ',' ) ) {
ptr++;
i++;
}
/* Start with BE suffix */
for ( i = 0, ptr = NULL; i < suffrdns; i++ ) {
- comma = strrchr(dn.bv_val, ',');
+ comma = strrchr( dn.bv_val, ',' );
if ( ptr ) *ptr = ',';
if ( comma ) *comma = '\0';
ptr = comma;
ber_dupbv( &e->e_name, &slap_syncrepl_dn_bv );
ber_dupbv( &e->e_nname, &slap_syncrepl_dn_bv );
- if ( slap_syncrepl_dn_bv.bv_val ) {
+ if ( !BER_BVISNULL( &slap_syncrepl_dn_bv ) ) {
slap_sl_free( slap_syncrepl_dn_bv.bv_val, op->o_tmpmemctx );
}
op->o_req_dn = e->e_name;
op->o_req_ndn = e->e_nname;
+ slap_queue_csn( op, syncCookie->ctxcsn );
+
/* update persistent cookie */
update_cookie_retry:
op->o_tag = LDAP_REQ_MODIFY;
"be_modify failed (%d)\n", rs_modify.sr_err, 0, 0 );
}
}
+ slap_graduate_commit_csn( op );
if ( e != NULL ) {
entry_free( e );
done :
- if ( cnbva[0].bv_val ) {
+ if ( !BER_BVISNULL( &cnbva[0] ) ) {
ch_free( cnbva[0].bv_val );
- cnbva[0].bv_val = NULL;
+ BER_BVZERO( &cnbva[0] );
}
- if ( scbva[0].bv_val ) {
+ if ( !BER_BVISNULL( &scbva[0] ) ) {
ch_free( scbva[0].bv_val );
- scbva[0].bv_val = NULL;
+ BER_BVZERO( &scbva[0] );
}
if ( mlnext->sml_next ) {
syncinfo_t *si = op->o_callback->sc_private;
if ( rs->sr_type == REP_SEARCH ) {
- if ( si->si_syncUUID_ndn.bv_val != NULL ) {
+ if ( !BER_BVISNULL( &si->si_syncUUID_ndn ) ) {
Debug( LDAP_DEBUG_ANY,
- "dn_callback : consistency error - entryUUID is not unique\n", 0, 0, 0 );
+ "dn_callback : consistency error - "
+ "entryUUID is not unique\n", 0, 0, 0 );
} else {
ber_dupbv_x( &si->si_syncUUID_ndn, &rs->sr_entry->e_nname, NULL );
}
} else if ( rs->sr_type == REP_RESULT ) {
if ( rs->sr_err == LDAP_SIZELIMIT_EXCEEDED ) {
Debug( LDAP_DEBUG_ANY,
- "dn_callback : consistency error - entryUUID is not unique\n", 0, 0, 0 );
+ "dn_callback : consistency error - "
+ "entryUUID is not unique\n", 0, 0, 0 );
}
}
context_csn, NULL );
}
- bv.bv_val = "{}";
- bv.bv_len = sizeof("{}")-1;
+ BER_BVSTR( &bv, "{}" );
attr_merge_one( e, slap_schema.si_ad_subtreeSpecification, &bv, NULL );
build_new_dn( &e->e_name, &be->be_nsuffix[0], rdn, NULL );
new = uuidstr;
} else {
new = (struct berval *)slap_sl_malloc( sizeof(struct berval), ctx );
+ if ( new == NULL ) {
+ return NULL;
+ }
}
new->bv_len = 36;
- if (( new->bv_val = slap_sl_malloc( new->bv_len + 1, ctx )) == NULL) {
- if ( !uuidstr ) slap_sl_free( new, ctx );
+ if ( ( new->bv_val = slap_sl_malloc( new->bv_len + 1, ctx ) ) == NULL ) {
+ if ( new != uuidstr ) {
+ slap_sl_free( new, ctx );
+ }
return NULL;
}
}
static void
-avl_ber_bvfree( void *bv )
+avl_ber_bvfree( void *v_bv )
{
- if( bv == NULL ) return;
- if ( ((struct berval *)bv)->bv_val != NULL ) {
- ch_free( ((struct berval *)bv)->bv_val );
+ struct berval *bv = (struct berval *)v_bv;
+
+ if( v_bv == NULL ) return;
+ if ( !BER_BVISNULL( bv ) ) {
+ ch_free( bv->bv_val );
}
ch_free( (char *) bv );
}
projects / openldap / blobdiff